use std::cell::Cell;
use std::collections::{BTreeMap, HashMap};
use std::ops::{Deref, DerefMut};
use std::sync::atomic::{AtomicBool, AtomicU64, AtomicUsize, Ordering, fence};
use std::sync::{Arc, Mutex, MutexGuard, TryLockError};
use std::task::Waker;
use std::time::Duration;
use snare_interpose::{ClockKind, Flow, Layer, RaceCell, SleepRequest, SpinStep, ThreadClass};
const Q32: f64 = 4_294_967_296.0;
pub(crate) const MAX_RATE: f64 = 1e6;
const HELD_POLL: Duration = Duration::from_millis(200);
const SPIN_SETTLE: Duration = Duration::from_millis(5);
#[derive(Clone, Copy, Debug)]
pub(crate) struct Line {
pub(crate) anchor_v: u64,
pub(crate) anchor_real: u64,
pub(crate) rate_q32: u64,
pub(crate) horizon: u64,
}
impl Line {
pub(crate) fn value_at(&self, real: u64) -> u64 {
let dr = real.saturating_sub(self.anchor_real) as u128;
let dv = (dr * self.rate_q32 as u128) >> 32;
let v = (self.anchor_v as u128 + dv).min(u64::MAX as u128) as u64;
v.min(self.horizon)
}
pub(crate) fn real_at(&self, v: u64) -> Option<u64> {
if v > self.horizon {
return None;
}
if v <= self.anchor_v {
return Some(self.anchor_real);
}
if self.rate_q32 == 0 {
return None;
}
let dr = (((v - self.anchor_v) as u128) << 32).div_ceil(self.rate_q32 as u128);
Some((self.anchor_real as u128 + dr).min(u64::MAX as u128) as u64)
}
}
pub(crate) fn rate_to_q32(rate: f64) -> u64 {
(rate.clamp(0.0, MAX_RATE) * Q32).round() as u64
}
#[track_caller]
pub(crate) fn validate_rate(rate: f64, deterministic: bool) {
assert!(
rate >= 0.0,
"time rate {rate} would run the monotonic clock backwards or undefined; use a rate in \
(0, 1e6], 0.0 to pause or f64::INFINITY for virtual time"
);
assert!(
!(deterministic && rate.is_finite() && rate > 0.0),
"a deterministic Sim cannot run its clock at a real-time rate ({rate}): nothing in it may \
depend on real time; pause, advance or set the clock instead"
);
}
pub(crate) type DriverTime = (u64, u64);
thread_local! {
static DRIVER_TIME: Cell<Option<DriverTime>> = const { Cell::new(None) };
static CLOCK_WAKE: Cell<bool> = const { Cell::new(false) };
}
pub(crate) fn in_clock_wake() -> bool {
CLOCK_WAKE.try_with(Cell::get).unwrap_or(false)
}
pub(crate) fn wake_id() -> u64 {
static NEXT: AtomicU64 = AtomicU64::new(1);
NEXT.fetch_add(1, Ordering::Relaxed)
}
pub(crate) fn set_driver_time(t: Option<DriverTime>) -> Option<DriverTime> {
DRIVER_TIME.try_with(|d| d.replace(t)).unwrap_or(None)
}
#[derive(Default)]
pub(crate) struct Entry {
waits: u32,
events: u32,
wakers: Vec<(u64, Option<u64>, Waker)>,
awaiting: Vec<u64>,
owners: TimerOwners,
}
#[derive(Default)]
struct TimerOwners {
inline: [u64; 4],
len: usize,
overflow: Vec<u64>,
}
impl TimerOwners {
fn len(&self) -> usize {
self.len
}
fn first(&self) -> Option<&u64> {
self.iter().next()
}
fn iter(&self) -> impl Iterator<Item = &u64> {
self.inline[..self.len.min(self.inline.len())]
.iter()
.chain(self.overflow.iter())
}
fn push(&mut self, owner: u64) {
if self.len < self.inline.len() {
self.inline[self.len] = owner;
} else {
self.overflow.push(owner);
}
self.len += 1;
}
fn pop(&mut self) -> Option<u64> {
if self.len == 0 {
return None;
}
self.len -= 1;
if self.len >= self.inline.len() {
self.overflow.pop()
} else {
Some(self.inline[self.len])
}
}
fn swap_remove(&mut self, i: usize) {
if i >= self.inline.len() {
self.overflow.swap_remove(i - self.inline.len());
self.len -= 1;
} else if let Some(last) = self.pop()
&& i < self.len
{
self.inline[i] = last;
}
}
}
impl Entry {
fn is_empty(&self) -> bool {
self.waits == 0 && self.events == 0 && self.wakers.is_empty() && self.awaiting.is_empty()
}
fn count(&self) -> u32 {
self.waits + self.events + u32::try_from(self.wakers.len()).unwrap_or(u32::MAX)
}
}
#[derive(Default)]
struct Timers {
entries: BTreeMap<u64, Entry>,
wake_deadlines: HashMap<u64, u64>,
}
impl Deref for Timers {
type Target = BTreeMap<u64, Entry>;
fn deref(&self) -> &Self::Target {
&self.entries
}
}
impl DerefMut for Timers {
fn deref_mut(&mut self) -> &mut Self::Target {
&mut self.entries
}
}
impl Timers {
fn register_wake(&mut self, at: u64, id: u64, owner: Option<u64>, waker: Waker) {
self.entries
.entry(at)
.or_default()
.wakers
.push((id, owner, waker));
self.wake_deadlines.insert(id, at);
}
fn take_wakers_at(&mut self, at: u64, hold: bool, out: &mut Vec<Waker>) -> bool {
let entry = self.entries.get_mut(&at).unwrap();
let any = !entry.wakers.is_empty();
for (id, _, waker) in entry.wakers.drain(..) {
if hold {
entry.awaiting.push(id);
} else {
self.wake_deadlines.remove(&id);
}
out.push(waker);
}
any
}
fn cancel_wake(&mut self, id: u64) -> Option<Option<Waker>> {
let at = self.wake_deadlines.remove(&id)?;
let entry = self.entries.get_mut(&at).unwrap();
let waker = if let Some(i) = entry.wakers.iter().position(|&(key, _, _)| key == id) {
Some(entry.wakers.swap_remove(i).2)
} else {
let i = entry.awaiting.iter().position(|&key| key == id).unwrap();
entry.awaiting.swap_remove(i);
None
};
if entry.is_empty() {
self.entries.remove(&at);
}
Some(waker)
}
}
pub(crate) struct PendingTimer {
pub(crate) at: u64,
pub(crate) owner: Option<u64>,
}
pub(crate) fn nanos(d: Duration) -> u64 {
u64::try_from(d.as_nanos()).unwrap_or(u64::MAX)
}
fn creep_past(t: u64) -> u64 {
#[cfg(windows)]
{
nanos(snare_interpose::next_performance_count(
Duration::from_nanos(t),
))
}
#[cfg(not(windows))]
{
t.saturating_add(1)
}
}
fn real_nanos() -> u64 {
nanos(crate::readiness::real_now())
}
pub(crate) struct Clock {
monotonic_nanos: AtomicU64,
base_realtime_nanos: u64,
tai_offset_nanos: u64,
discrete: AtomicBool,
paused: AtomicBool,
seq: AtomicU64,
anchor_real: AtomicU64,
rate_q32: AtomicU64,
horizon: AtomicU64,
scaled_rate: AtomicU64,
floor: AtomicU64,
deterministic: AtomicBool,
driven: AtomicBool,
stamp: AtomicU64,
driver_gen: AtomicU64,
control: Mutex<()>,
fired: AtomicBool,
woke_timers: AtomicBool,
spin_due_since: AtomicU64,
held: AtomicBool,
pending: Mutex<Timers>,
foreign: Mutex<Timers>,
dormant: AtomicBool,
dormant_v: AtomicU64,
dormant_real: AtomicU64,
runner: RaceCell<Arc<WakeRunner>>,
domain: AtomicUsize,
owner: Mutex<Option<snare_interpose::WeakDomain>>,
}
impl Drop for Clock {
fn drop(&mut self) {
if let Some(runner) = self.runner.get() {
snare_interpose::real(|| runner.close());
}
}
}
fn foreign_caller() -> bool {
snare_interpose::thread_class().is_some_and(|class| class != ThreadClass::Participant)
}
fn driver_caller() -> bool {
snare_interpose::thread_class() == Some(ThreadClass::Driver)
}
impl Clock {
pub(crate) fn new(tai_offset_secs: u64) -> Self {
Clock {
monotonic_nanos: AtomicU64::new(0),
base_realtime_nanos: 1_700_000_000u64 * 1_000_000_000,
tai_offset_nanos: tai_offset_secs * 1_000_000_000,
discrete: AtomicBool::new(true),
paused: AtomicBool::new(false),
seq: AtomicU64::new(0),
anchor_real: AtomicU64::new(0),
rate_q32: AtomicU64::new(0),
horizon: AtomicU64::new(u64::MAX),
scaled_rate: AtomicU64::new(0f64.to_bits()),
floor: AtomicU64::new(0),
deterministic: AtomicBool::new(false),
driven: AtomicBool::new(false),
stamp: AtomicU64::new(0),
driver_gen: AtomicU64::new(0),
control: Mutex::new(()),
fired: AtomicBool::new(false),
woke_timers: AtomicBool::new(false),
spin_due_since: AtomicU64::new(0),
held: AtomicBool::new(false),
pending: Mutex::new(Timers::default()),
foreign: Mutex::new(Timers::default()),
dormant: AtomicBool::new(false),
dormant_v: AtomicU64::new(0),
dormant_real: AtomicU64::new(0),
runner: RaceCell::new(),
domain: AtomicUsize::new(0),
owner: Mutex::new(None),
}
}
pub(crate) fn domain(&self) -> usize {
self.domain.load(Ordering::Acquire)
}
pub(crate) fn set_domain(&self, domain: &snare_interpose::Domain) {
*self.owner.lock().unwrap_or_else(|e| e.into_inner()) = Some(domain.downgrade());
self.domain.store(domain.key(), Ordering::Release);
}
pub(crate) fn set_dormant(&self, on: bool) {
self.controlled(|| {
if on {
self.dormant_v.store(self.peek(), Ordering::Release);
self.dormant_real.store(real_nanos(), Ordering::Release);
}
self.dormant.store(on, Ordering::Release);
});
}
fn is_dormant(&self) -> bool {
self.dormant.load(Ordering::Acquire)
}
fn dormant_limit(&self) -> Option<u64> {
self.is_dormant().then(|| {
let real = real_nanos().saturating_sub(self.dormant_real.load(Ordering::Acquire));
self.dormant_v.load(Ordering::Acquire).saturating_add(real)
})
}
pub(crate) fn base_realtime(&self) -> Duration {
Duration::from_nanos(self.base_realtime_nanos)
}
fn realtime_at(&self, monotonic: u64) -> u64 {
self.base_realtime_nanos + monotonic
}
pub(crate) fn set_discrete(&self, on: bool) {
self.discrete.store(on, Ordering::Relaxed);
}
pub(crate) fn set_deterministic(&self, on: bool) {
self.deterministic.store(on, Ordering::Relaxed);
}
pub(crate) fn is_deterministic(&self) -> bool {
self.deterministic.load(Ordering::Relaxed)
}
pub(crate) fn is_driven(&self) -> bool {
self.driven.load(Ordering::Acquire)
}
fn is_discrete(&self) -> bool {
self.discrete.load(Ordering::Relaxed)
}
pub(crate) fn is_paused(&self) -> bool {
self.paused.load(Ordering::Acquire)
}
fn is_scaled(&self) -> bool {
self.rate_q32.load(Ordering::Acquire) != 0
}
fn jumps(&self) -> bool {
!self.is_discrete()
&& !self.is_paused()
&& !self.is_scaled()
&& !self.is_driven()
&& !self.is_dormant()
}
fn line(&self) -> (Line, u64, bool) {
loop {
let s1 = self.seq.load(Ordering::Acquire);
if s1 & 1 == 1 {
std::hint::spin_loop();
continue;
}
let line = Line {
anchor_v: self.monotonic_nanos.load(Ordering::Relaxed),
anchor_real: self.anchor_real.load(Ordering::Relaxed),
rate_q32: self.rate_q32.load(Ordering::Relaxed),
horizon: self.horizon.load(Ordering::Relaxed),
};
let paused = self.paused.load(Ordering::Relaxed);
let real = real_nanos();
fence(Ordering::Acquire);
if self.seq.load(Ordering::Relaxed) == s1 {
return (line, real, paused);
}
}
}
fn held_value(&self) -> u64 {
self.monotonic_nanos
.load(Ordering::Acquire)
.max(self.floor.load(Ordering::Acquire))
}
pub(crate) fn peek(&self) -> u64 {
if self.is_driven() {
return self.line_value();
}
if self.is_paused() || !self.is_scaled() {
return self.held_value();
}
let (line, real, paused) = self.line();
if paused || line.rate_q32 == 0 {
return self.held_value();
}
let v = line.value_at(real);
self.floor.fetch_max(v, Ordering::AcqRel).max(v)
}
fn line_value(&self) -> u64 {
let (line, real, _) = self.line();
let v = line.value_at(real);
self.floor.fetch_max(v, Ordering::AcqRel).max(v)
}
fn publish(&self, rate_q32: u64, paused: bool, to: impl FnOnce(u64) -> u64) {
let s = self.seq.load(Ordering::Relaxed);
self.seq.store(s.wrapping_add(1), Ordering::Relaxed);
fence(Ordering::Release);
let real = real_nanos();
let held = self.held_value();
let line = Line {
anchor_v: self.monotonic_nanos.load(Ordering::Relaxed),
anchor_real: self.anchor_real.load(Ordering::Relaxed),
rate_q32: self.rate_q32.load(Ordering::Relaxed),
horizon: self.horizon.load(Ordering::Relaxed),
};
let now = if self.is_paused() || line.rate_q32 == 0 {
held
} else {
line.value_at(real).max(held)
};
self.monotonic_nanos.fetch_max(to(now), Ordering::Relaxed);
self.anchor_real.store(real, Ordering::Relaxed);
self.rate_q32.store(rate_q32, Ordering::Relaxed);
self.horizon.store(u64::MAX, Ordering::Relaxed);
self.paused.store(paused, Ordering::Release);
self.seq.store(s.wrapping_add(2), Ordering::Release);
}
fn publish_line(&self, anchor_v: u64, anchor_real: u64, rate_q32: u64, horizon: u64) {
let s = self.seq.load(Ordering::Relaxed);
self.seq.store(s.wrapping_add(1), Ordering::Relaxed);
fence(Ordering::Release);
self.monotonic_nanos.fetch_max(anchor_v, Ordering::Relaxed);
self.anchor_real.store(anchor_real, Ordering::Relaxed);
self.rate_q32.store(rate_q32, Ordering::Relaxed);
self.horizon.store(horizon, Ordering::Relaxed);
self.seq.store(s.wrapping_add(2), Ordering::Release);
}
fn control(&self) -> MutexGuard<'_, ()> {
self.control.lock().unwrap_or_else(|e| e.into_inner())
}
fn controlled<R>(&self, f: impl FnOnce() -> R) -> R {
let _control = self.control();
f()
}
fn try_control(&self) -> Option<MutexGuard<'_, ()>> {
match self.control.try_lock() {
Ok(guard) => Some(guard),
Err(TryLockError::Poisoned(e)) => Some(e.into_inner()),
Err(TryLockError::WouldBlock) => None,
}
}
fn advance(&self) -> u64 {
if !self.jumps() {
let stamp = self.stamp.load(Ordering::Acquire);
return self.peek().max(stamp);
}
let Some(_control) = self.try_control() else {
return self.peek();
};
if !self.jumps() {
return self.peek();
}
self.step_base(1_000).1
}
fn step_base(&self, by: u64) -> (u64, u64) {
let floor = self.floor.load(Ordering::Acquire);
#[allow(deprecated)]
let before = self
.monotonic_nanos
.fetch_update(Ordering::AcqRel, Ordering::Acquire, |m| {
Some(m.max(floor).saturating_add(by))
})
.unwrap_or_else(|m| m)
.max(floor);
let after = before.saturating_add(by);
self.floor.fetch_max(after, Ordering::AcqRel);
(before, after)
}
fn jump_to(&self, wake: u64) -> bool {
let _control = self.control();
if !self.jumps() {
return false;
}
self.monotonic_nanos.fetch_max(wake, Ordering::Relaxed);
true
}
pub(crate) fn now(&self, kind: ClockKind) -> Duration {
self.reading(kind, self.advance())
}
fn reading(&self, kind: ClockKind, m: u64) -> Duration {
let nanos = match kind {
ClockKind::Monotonic => m,
ClockKind::Realtime => self.realtime_at(m),
ClockKind::Tai => self.realtime_at(m) + self.tai_offset_nanos,
};
Duration::from_nanos(nanos)
}
#[cfg(target_os = "linux")]
pub(crate) fn tick_realtime(&self) -> Duration {
Duration::from_nanos(self.realtime_at(self.advance()))
}
#[cfg(target_os = "linux")]
pub(crate) fn ptp_sample(&self, phc_offset_nanos: i64) -> [(i64, u32); 3] {
let m = self.advance();
let realtime = self.realtime_at(m);
let device = realtime.saturating_add_signed(phc_offset_nanos);
let split = |nanos: u64| {
(
(nanos / 1_000_000_000) as i64,
(nanos % 1_000_000_000) as u32,
)
};
[split(device), split(realtime), split(m)]
}
pub(crate) fn sleep(&self, request: SleepRequest) {
let wake = match request {
SleepRequest::For(d) => self.peek().saturating_add(nanos(d)),
SleepRequest::Until(ClockKind::Monotonic, t) => nanos(t),
SleepRequest::Until(kind, t) => {
let epoch = match kind {
ClockKind::Tai => self.base_realtime_nanos + self.tai_offset_nanos,
_ => self.base_realtime_nanos,
};
nanos(t).saturating_sub(epoch)
}
};
let done = || self.peek() >= wake || self.jumps() && self.jump_to(wake);
if done() {
return;
}
let readiness = crate::readiness::readiness();
if foreign_caller() {
snare_interpose::note_effect("sleep");
loop {
let left = Duration::from_nanos(wake.saturating_sub(self.peek()));
let deadline = crate::readiness::Deadline::after(left);
readiness.wait_until("sleep", Some(deadline), || {
self.peek() >= wake || self.jumps()
});
if done() {
return;
}
}
}
self.add_pending(wake, false, false);
loop {
snare_interpose::note_wait_deadline(Some(Duration::from_nanos(wake)));
readiness.wait_until("sleep", None, || self.peek() >= wake || self.jumps());
if done() {
break;
}
}
self.unregister_timer(wake, false);
}
fn timers(&self, foreign: bool) -> MutexGuard<'_, Timers> {
let timers = if foreign {
&self.foreign
} else {
&self.pending
};
timers.lock().unwrap_or_else(|e| e.into_inner())
}
fn add_pending(&self, wake: u64, foreign: bool, event: bool) {
let mut timers = self.timers(foreign);
let entry = timers.entry(wake).or_default();
if event {
entry.events += 1;
} else {
entry.waits += 1;
entry.owners.push(snare_interpose::thread_lineage());
}
}
#[cfg(target_os = "macos")]
pub(crate) fn register_event_quiet(&self, after: Duration) -> Option<Duration> {
if self.jumps() || after.is_zero() {
return None;
}
self.add_pending(self.peek().saturating_add(nanos(after)), false, true);
self.real_span(after)
}
pub(crate) fn register_timer(
&self,
after: Duration,
foreign: bool,
event: bool,
) -> Option<u64> {
if self.jumps() || event && after.is_zero() {
return None;
}
let now = self.peek();
let wake = now.saturating_add(nanos(after));
if foreign {
self.add_pending(wake, true, event);
return Some(wake);
}
let pruned = {
let mut pending = self.timers(false);
let pruned = if self.is_scaled()
&& !self.is_driven()
&& pending
.first_key_value()
.is_some_and(|(&first, _)| first <= now)
{
self.fired.store(true, Ordering::Release);
take_upto(&mut pending, now).1
} else {
Vec::new()
};
let entry = pending.entry(wake).or_default();
if event {
entry.events += 1;
} else {
entry.waits += 1;
entry.owners.push(snare_interpose::thread_lineage());
}
pruned
};
self.wake_taken(pruned);
Some(wake)
}
#[cfg(unix)]
pub(crate) fn reach_realtime(&self, realtime: Duration) {
if self.jumps() {
let at = nanos(realtime).saturating_sub(self.base_realtime_nanos);
self.jump_to(at);
}
}
pub(crate) fn expire(&self, deadline: Duration) {
if self.jumps() {
self.jump_to(nanos(deadline));
}
}
fn charge(&self, latency: Duration) -> bool {
if self.is_driven() {
return self.charge_driven(latency);
}
let running_discrete = || self.is_discrete() && !self.is_paused() && !self.is_scaled();
if !running_discrete() {
return false;
}
let (reached, wakers) = {
let Some(_control) = self.try_control() else {
return false;
};
if !running_discrete() {
return false;
}
let (before, after) = self.step_base(nanos(latency));
let reached = self.reached(before, after);
(reached, self.fire_upto(before, after).1)
};
self.wake_taken(wakers);
reached
}
fn spin_step(&self, step: Duration) -> SpinStep {
let held = || self.is_paused() || self.is_driven();
let runs = || !self.is_discrete() || self.is_scaled();
if held() {
return SpinStep::Held;
}
if runs() {
return SpinStep::Runs;
}
let spin = || {
let _control = self.control();
if held() {
return (SpinStep::Held, Vec::new());
}
if runs() {
return (SpinStep::Runs, Vec::new());
}
let now = self.peek();
if !self.is_deterministic() && self.due().is_some() {
let real = real_nanos().max(1);
let since = match self.spin_due_since.compare_exchange(
0,
real,
Ordering::AcqRel,
Ordering::Acquire,
) {
Ok(_) => real,
Err(since) => since,
};
if real.saturating_sub(since) < nanos(SPIN_SETTLE) {
return (SpinStep::Waking, Vec::new());
}
}
self.spin_due_since.store(0, Ordering::Release);
let target = now.saturating_add(nanos(step).max(1));
let landing = match self.next_deadline_after(now) {
Some(at) if target >= at && now < at - 1 => at - 1,
Some(at) if target >= at => at.saturating_add(1),
_ => target,
};
let (before, after) = self.step_base(landing - now);
let fired = self.reached(before, after);
(SpinStep::Moved { fired }, self.fire_upto(before, after).1)
};
#[cfg(windows)]
let owner = (!self.is_deterministic() && !self.is_dormant())
.then(|| {
self.owner
.lock()
.unwrap()
.as_ref()
.and_then(|owner| owner.upgrade())
})
.flatten();
#[cfg(windows)]
let (step, wakers) = if let Some(owner) = owner {
crate::readiness::readiness()
.spin_clock(&owner, spin)
.unwrap_or((SpinStep::Waking, Vec::new()))
} else {
spin()
};
#[cfg(not(windows))]
let (step, wakers) = spin();
self.wake_taken(wakers);
step
}
fn charge_driven(&self, latency: Duration) -> bool {
let fired = {
let Some(_control) = self.try_control() else {
return false;
};
if !self.is_driven() {
return false;
}
let before = self.peek();
let horizon = self.horizon.load(Ordering::Acquire);
let after = before.saturating_add(nanos(latency)).min(horizon);
if after <= before {
return false;
}
self.floor.fetch_max(after, Ordering::AcqRel);
let reached = self.reached(before, after);
let (_, wakers) = self.fire_upto(before, after);
(reached, wakers)
};
self.wake_taken(fired.1);
fired.0
}
fn reached(&self, before: u64, after: u64) -> bool {
[false, true].into_iter().any(|foreign| {
self.timers(foreign)
.range(before.saturating_add(1)..=after)
.next()
.is_some()
})
}
pub(crate) fn fire_upto(&self, from: u64, t: u64) -> (u32, Vec<Waker>) {
let mut count = 0u32;
let mut wakers = Vec::new();
for foreign in [false, true] {
let mut timers = self.timers(foreign);
let due: Vec<u64> = timers.range(..=t).map(|(&at, _)| at).collect();
for at in due {
let Some(entry) = timers.get_mut(&at) else {
continue;
};
if !foreign && at > from {
count = count.saturating_add(entry.count());
}
entry.events = 0;
let hold = !foreign && !self.is_deterministic();
let taken = timers.take_wakers_at(at, hold, &mut wakers);
if hold && taken {
self.held.store(true, Ordering::Release);
}
if timers.get(&at).unwrap().is_empty() {
timers.remove(&at);
}
}
}
if !wakers.is_empty() {
self.woke_timers.store(true, Ordering::Release);
}
(count, wakers)
}
pub(crate) fn unregister_timer(&self, wake: u64, foreign: bool) {
let me = snare_interpose::thread_lineage();
for foreign in [foreign, !foreign] {
let mut timers = self.timers(foreign);
let Some(entry) = timers.get_mut(&wake).filter(|e| e.waits > 0) else {
continue;
};
entry.waits -= 1;
let owner = entry.owners.iter().position(|&o| o == me);
match owner {
Some(i) => {
entry.owners.swap_remove(i);
}
None => {
entry.owners.pop();
}
}
if entry.is_empty() {
timers.remove(&wake);
}
break;
}
self.release_held();
}
fn release_held(&self) {
if !self.held.load(Ordering::Acquire) {
return;
}
let now = self.peek();
if [false, true]
.into_iter()
.any(|foreign| reached_wait(&self.timers(foreign), now))
{
return;
}
if !self.held.swap(false, Ordering::AcqRel) {
return;
}
crate::readiness::readiness().bump_time_unscheduled(self.domain());
let owner = self.owner.lock().unwrap_or_else(|e| e.into_inner()).clone();
if self.holds_wakers()
&& let Some(domain) = owner.and_then(|owner| owner.upgrade())
{
crate::readiness::skip_idle_later(&domain);
}
}
pub(crate) fn unregister_event(&self, wake: u64) {
let mut timers = self.timers(false);
let Some(entry) = timers.get_mut(&wake).filter(|e| e.events > 0) else {
return;
};
entry.events -= 1;
if entry.is_empty() {
timers.remove(&wake);
}
}
pub(crate) fn register_wake(&self, at: u64, waker: Waker, foreign: bool) -> Option<u64> {
if self.jumps() {
return None;
}
let id = wake_id();
let owner = snare_interpose::Domain::current().map(|_| snare_interpose::thread_lineage());
let real_at = (self.is_scaled() && !self.is_driven() && !self.is_paused())
.then(|| self.line().0.real_at(at))
.flatten();
if let Some(real_at) = real_at {
crate::readiness::schedule_wake(Duration::from_nanos(real_at), id, waker.clone());
}
self.timers(foreign).register_wake(at, id, owner, waker);
Some(id)
}
pub(crate) fn cancel_wake(&self, id: u64) {
crate::readiness::cancel_wake(id);
for foreign in [false, true] {
let cancelled = {
let mut timers = self.timers(foreign);
timers.cancel_wake(id)
};
if let Some(cancelled) = cancelled {
drop(cancelled);
self.release_held();
return;
}
}
}
fn take_wakers(&self, t: u64) -> Vec<Waker> {
let mut wakers = Vec::new();
for foreign in [false, true] {
let mut timers = self.timers(foreign);
let due: Vec<u64> = timers
.range(..=t)
.filter(|(_, entry)| !entry.wakers.is_empty())
.map(|(&at, _)| at)
.collect();
for at in due {
let hold = !foreign && !self.is_deterministic();
let taken = timers.take_wakers_at(at, hold, &mut wakers);
if hold && taken {
self.held.store(true, Ordering::Release);
}
if timers.get(&at).unwrap().is_empty() {
timers.remove(&at);
}
}
}
wakers
}
fn wake_taken(&self, wakers: Vec<Waker>) {
if wakers.is_empty() {
return;
}
self.woke_timers.store(true, Ordering::Release);
wake_all(&self.runner, wakers);
}
fn holds_wakers(&self) -> bool {
[false, true].into_iter().any(|foreign| {
self.timers(foreign)
.values()
.any(|entry| !entry.wakers.is_empty())
})
}
fn wait_due(&self) -> bool {
if !self.is_discrete()
|| self.is_scaled()
|| self.is_paused()
|| self.is_driven()
|| self.is_deterministic()
{
return false;
}
let due = reached_wait(&self.timers(false), self.peek());
if due {
self.held.store(true, Ordering::Release);
}
due
}
pub(crate) fn wait_reached(&self) -> bool {
let now = self.peek();
[false, true]
.into_iter()
.any(|foreign| reached_wait(&self.timers(foreign), now))
}
pub(crate) fn wake_due(&self) {
let wakers = self.take_wakers(self.peek());
self.wake_taken(wakers);
}
pub(crate) fn monotonic(&self) -> u64 {
self.peek().max(self.stamp.load(Ordering::Acquire))
}
#[track_caller]
pub(crate) fn check_rate(&self, rate: f64) {
validate_rate(rate, self.deterministic.load(Ordering::Relaxed));
}
pub(crate) fn set_rate(&self, rate: f64) {
self.controlled(|| {
if self.is_driven() {
return;
}
if rate == 0.0 {
if !self.is_paused() {
self.publish(self.rate_q32.load(Ordering::Relaxed), true, |now| now);
}
return;
}
let (q32, scaled) = if rate.is_finite() {
let rate = rate.min(MAX_RATE);
(rate_to_q32(rate), rate)
} else {
(0, 0.0)
};
self.publish(q32, false, |now| now);
self.scaled_rate.store(scaled.to_bits(), Ordering::Release);
});
}
pub(crate) fn rate(&self) -> f64 {
if self.is_driven() {
return f64::from_bits(self.scaled_rate.load(Ordering::Acquire));
}
if self.is_paused() {
return 0.0;
}
let rate = f64::from_bits(self.scaled_rate.load(Ordering::Acquire));
if rate == 0.0 { f64::INFINITY } else { rate }
}
pub(crate) fn pause(&self) {
self.set_rate(0.0);
}
pub(crate) fn resume(&self) {
self.controlled(|| {
if !self.is_paused() || self.is_driven() {
return;
}
self.publish(self.rate_q32.load(Ordering::Relaxed), false, |now| now);
});
}
pub(crate) fn advance_by(&self, d: Duration) {
if d.is_zero() {
return;
}
self.controlled(|| {
if self.is_driven() {
return;
}
let paused = self.is_paused();
self.publish(self.rate_q32.load(Ordering::Relaxed), paused, |now| {
now.saturating_add(nanos(d))
});
});
}
pub(crate) fn set_value(&self, value: Duration) -> Result<(), Duration> {
let value = nanos(value);
self.controlled(|| {
let now = self.peek();
if self.is_driven() {
return Ok(());
}
if value < now {
return Err(Duration::from_nanos(now));
}
if value > now {
let paused = self.is_paused();
self.publish(self.rate_q32.load(Ordering::Relaxed), paused, |now| {
now.max(value)
});
}
Ok(())
})
}
pub(crate) fn value(&self) -> Duration {
let stamp = self.stamp.load(Ordering::Acquire);
Duration::from_nanos(self.peek().max(stamp))
}
pub(crate) fn driver_time_at(&self, t: u64) -> DriverTime {
(t, self.driver_gen.load(Ordering::Acquire))
}
pub(crate) fn driver_time(&self) -> Option<u64> {
let (t, generation) = DRIVER_TIME.try_with(Cell::get).ok()??;
(generation == self.driver_gen.load(Ordering::Acquire)).then_some(t)
}
pub(crate) fn attach_driven(&self) {
self.controlled(|| {
let now = self.peek();
self.publish_line(now, real_nanos(), 0, now);
self.scaled_rate.store(0f64.to_bits(), Ordering::Release);
self.driven.store(true, Ordering::Release);
self.paused.store(false, Ordering::Release);
});
}
pub(crate) fn detach_driven(&self) {
self.controlled(|| {
if !self.is_driven() {
return;
}
let now = self.peek().max(self.stamp.load(Ordering::Acquire));
self.publish_line(now, real_nanos(), 0, u64::MAX);
self.floor.fetch_max(now, Ordering::AcqRel);
self.stamp.store(0, Ordering::Release);
self.driver_gen.fetch_add(1, Ordering::AcqRel);
self.driven.store(false, Ordering::Release);
self.scaled_rate.store(0f64.to_bits(), Ordering::Release);
});
}
pub(crate) fn grant(&self, anchor_v: u64, anchor_real: u64, rate: f64, horizon: u64) {
self.controlled(|| {
if !self.is_driven() {
return;
}
let now = self.peek();
let (anchor_v, anchor_real) = if anchor_v >= now {
(anchor_v, anchor_real)
} else {
(now, real_nanos())
};
self.publish_line(
anchor_v,
anchor_real,
rate_to_q32(rate),
horizon.max(anchor_v),
);
self.scaled_rate.store(rate.to_bits(), Ordering::Release);
});
}
pub(crate) fn freeze(&self) {
self.controlled(|| {
if !self.is_driven() {
return;
}
let now = self.peek();
self.publish_line(now, real_nanos(), 0, now);
self.scaled_rate.store(0f64.to_bits(), Ordering::Release);
});
}
pub(crate) fn jump_driven(&self, t: u64, to_next: bool, past: bool) -> (u64, u64) {
self.controlled(|| {
let now = self.peek();
if !self.is_driven() {
return (now, now);
}
let landing = match self.next_deadline_after(now).filter(|_| to_next) {
Some(next) => next.min(t),
None => t,
};
let to = now.max(landing);
let reach = if past { creep_past(to) } else { to };
let horizon = self.horizon.load(Ordering::Acquire).max(reach);
self.publish_line(
to,
real_nanos(),
self.rate_q32.load(Ordering::Acquire),
horizon,
);
(now, to)
})
}
pub(crate) fn set_stamp(&self, t: Option<u64>) {
self.stamp.store(t.unwrap_or(0), Ordering::Release);
}
pub(crate) fn next_deadline_after(&self, now: u64) -> Option<u64> {
self.timers(false)
.range(now.saturating_add(1)..)
.next()
.map(|(&at, _)| at)
}
fn next_any_after(&self, now: u64) -> Option<u64> {
[false, true]
.into_iter()
.filter_map(|foreign| {
self.timers(foreign)
.range(now.saturating_add(1)..)
.next()
.map(|(&at, _)| at)
})
.min()
}
pub(crate) fn due(&self) -> Option<Option<u64>> {
let now = self.peek();
self.timers(false)
.range(..=now)
.next()
.map(|(_, entry)| entry.owners.first().copied())
}
pub(crate) fn owner_at(&self, at: u64) -> Option<u64> {
self.timers(false)
.get(&at)
.and_then(|entry| entry.owners.first().copied())
}
pub(crate) fn driver_value(&self) -> Option<Duration> {
self.driver_time().map(Duration::from_nanos)
}
pub(crate) fn pending_timers(&self, n: usize) -> Vec<PendingTimer> {
let mut out = Vec::new();
for foreign in [false, true] {
for (&at, entry) in self.timers(foreign).iter() {
let owners = entry.owners.iter().map(|&o| Some(o));
let anonymous = (entry.owners.len()..(entry.waits as usize))
.chain(0..entry.events as usize)
.map(|_| None);
let wakers = entry.wakers.iter().map(|(_, owner, _)| *owner);
out.extend(
owners
.chain(anonymous)
.chain(wakers)
.map(|owner| PendingTimer { at, owner }),
);
if out.len() >= n {
out.truncate(n);
return out;
}
}
}
out
}
pub(crate) fn next_flow_wake(&self) -> Option<u64> {
if !self.is_driven() {
return None;
}
let (line, ..) = self.line();
if line.rate_q32 == 0 {
return None;
}
let next = self.next_any_after(self.peek())?;
line.real_at(next)
}
fn advance_to_next_deadline(&self) -> bool {
let (moved, pruned) = self.collect_skip(false, || {
let _control = self.control();
if self.is_paused() || self.is_driven() {
return (false, Vec::new());
}
if self.is_scaled() {
let now = self.peek();
let mut pending = self.timers(false);
let (any, pruned) = take_upto(&mut pending, now);
let fired = self.fired.swap(false, Ordering::AcqRel) || any;
(fired, pruned)
} else if !self.is_discrete() && !self.is_dormant() {
(false, Vec::new())
} else {
self.skip_to_next_deadline()
}
});
self.wake_taken(pruned);
moved
}
fn skip_to_next_deadline(&self) -> (bool, Vec<Waker>) {
let now = self.peek();
let mut pending = self.timers(false);
if !self.is_deterministic() && reached_wait(&pending, now) {
self.held.store(true, Ordering::Release);
return (false, Vec::new());
}
let pruned = take_upto(&mut pending, now).1;
let Some((&next, _)) = pending.iter().next() else {
return (false, pruned);
};
if self.dormant_limit().is_some_and(|limit| next >= limit) {
return (false, pruned);
}
self.monotonic_nanos
.fetch_max(next.saturating_add(1), Ordering::Relaxed);
drop(pending);
let mut pruned = pruned;
pruned.extend(self.take_wakers(next.saturating_add(1)));
(true, pruned)
}
fn advance_to_next_any_deadline(&self) -> bool {
let (moved, pruned) = self.collect_skip(true, || {
let mut pruned = Vec::new();
let _control = self.control();
if self.is_paused()
|| self.is_scaled()
|| (!self.is_discrete() && !self.is_dormant())
|| self.is_driven()
{
return (false, pruned);
}
let now = self.peek();
if !self.is_deterministic()
&& [false, true]
.into_iter()
.any(|foreign| reached_wait(&self.timers(foreign), now))
{
self.held.store(true, Ordering::Release);
return (false, pruned);
}
let next = [false, true]
.into_iter()
.filter_map(|foreign| {
let mut timers = self.timers(foreign);
pruned.extend(take_upto(&mut timers, now).1);
timers.first_key_value().map(|(&wake, _)| wake)
})
.min()
.filter(|&next| self.dormant_limit().is_none_or(|limit| next < limit));
if let Some(next) = next {
self.monotonic_nanos
.fetch_max(next.saturating_add(1), Ordering::Relaxed);
pruned.extend(self.take_wakers(next.saturating_add(1)));
}
(next.is_some(), pruned)
});
self.wake_taken(pruned);
moved
}
fn collect_skip(
&self,
_foreign: bool,
skip: impl FnOnce() -> (bool, Vec<Waker>),
) -> (bool, Vec<Waker>) {
#[cfg(windows)]
if !self.is_deterministic() && !self.is_dormant() {
let owner = self
.owner
.lock()
.unwrap()
.as_ref()
.and_then(|owner| owner.upgrade());
if let Some(owner) = owner {
return crate::readiness::readiness()
.skip_clock(&owner, _foreign, skip)
.unwrap_or_default();
}
}
let result = skip();
#[cfg(windows)]
if result.0 && !self.is_deterministic() {
crate::readiness::readiness().bump_time_unscheduled(self.domain());
}
result
}
pub(crate) fn virtual_now(&self) -> Option<Duration> {
(!self.jumps()).then(|| Duration::from_nanos(self.peek()))
}
fn real_span(&self, span: Duration) -> Option<Duration> {
if self.is_paused() && !self.is_driven() {
return None;
}
let rate_q32 = self.rate_q32.load(Ordering::Acquire);
if rate_q32 == 0 {
return None;
}
let from_zero = Line {
anchor_v: 0,
anchor_real: 0,
rate_q32,
horizon: u64::MAX,
};
from_zero.real_at(nanos(span)).map(Duration::from_nanos)
}
fn idle_wait(&self) -> Option<Duration> {
if self.is_paused() || self.is_driven() {
return Some(HELD_POLL);
}
if let Some(limit) = self.dormant_limit().filter(|_| !self.is_scaled()) {
let now = self.peek();
let earliest = [false, true]
.into_iter()
.filter_map(|foreign| {
let timers = self.timers(foreign);
timers
.range(now.saturating_add(1)..)
.next()
.map(|(&at, _)| at)
})
.min();
let Some(earliest) = earliest else {
return Some(HELD_POLL);
};
let span = earliest.saturating_add(1).saturating_sub(limit);
return Some(Duration::from_nanos(span).max(Duration::from_micros(1)));
}
if !self.is_scaled() {
return None;
}
let now = self.peek();
let earliest = *self.timers(false).range(now.saturating_add(1)..).next()?.0;
let span = self.real_span(Duration::from_nanos(earliest - now))?;
Some(span.max(Duration::from_micros(1)))
}
}
fn reached_wait(timers: &Timers, now: u64) -> bool {
timers
.range(..=now)
.any(|(_, entry)| entry.waits > 0 || !entry.awaiting.is_empty())
}
fn take_upto(timers: &mut Timers, upto: u64) -> (bool, Vec<Waker>) {
let later = timers.entries.split_off(&upto.saturating_add(1));
let due = std::mem::replace(&mut timers.entries, later);
let any = !due.is_empty();
let wakers = due
.into_values()
.flat_map(|entry| {
for id in entry
.awaiting
.iter()
.chain(entry.wakers.iter().map(|(id, _, _)| id))
{
timers.wake_deadlines.remove(id);
}
entry.wakers.into_iter().map(|(_, _, waker)| waker)
})
.collect();
(any, wakers)
}
fn wake_all(runner: &RaceCell<Arc<WakeRunner>>, wakers: Vec<Waker>) {
if wakers.is_empty() {
return;
}
if in_clock_wake() {
wakers.into_iter().for_each(Waker::wake);
return;
}
snare_interpose::real(|| WakeRunner::started(runner).run(wakers));
}
struct WakeRunner {
state: Mutex<RunnerState>,
changed: std::sync::Condvar,
}
#[derive(Default)]
struct RunnerState {
job: Option<Vec<Waker>>,
posted: u64,
done: u64,
closed: bool,
}
impl WakeRunner {
fn started(cell: &RaceCell<Arc<WakeRunner>>) -> &Arc<WakeRunner> {
let (runner, won) = cell.get_or_init(|| {
Arc::new(WakeRunner {
state: Mutex::default(),
changed: std::sync::Condvar::new(),
})
});
if won {
let serving = runner.clone();
std::thread::Builder::new()
.name("snare-timer-wakes".into())
.spawn(move || {
let _service = snare_interpose::service_thread();
serving.serve();
})
.expect("start the timer waker thread");
}
runner
}
fn lock(&self) -> MutexGuard<'_, RunnerState> {
self.state.lock().unwrap_or_else(|e| e.into_inner())
}
fn run(&self, wakers: Vec<Waker>) {
let mut state = self.lock();
while state.job.is_some() {
state = self.changed.wait(state).unwrap_or_else(|e| e.into_inner());
}
state.job = Some(wakers);
state.posted += 1;
let ticket = state.posted;
self.changed.notify_all();
while state.done < ticket {
state = self.changed.wait(state).unwrap_or_else(|e| e.into_inner());
}
}
fn close(&self) {
self.lock().closed = true;
self.changed.notify_all();
}
fn serve(&self) {
CLOCK_WAKE.set(true);
let mut state = self.lock();
loop {
let Some(wakers) = state.job.take() else {
if state.closed {
return;
}
state = self.changed.wait(state).unwrap_or_else(|e| e.into_inner());
continue;
};
drop(state);
let outcome = std::panic::catch_unwind(std::panic::AssertUnwindSafe(|| {
wakers.into_iter().for_each(Waker::wake);
}));
state = self.lock();
state.done += 1;
self.changed.notify_all();
drop(outcome);
}
}
}
pub(crate) struct ClockLayer(pub(crate) Arc<Clock>);
impl Layer for ClockLayer {
fn now(&self, clock: ClockKind) -> Flow<Duration> {
if let Some(t) = self.0.driver_time() {
return Flow::Done(self.0.reading(clock, t));
}
if driver_caller() {
return Flow::Pass;
}
Flow::Done(self.0.now(clock))
}
fn sleep(&self, request: SleepRequest) -> Flow<()> {
if driver_caller() {
return Flow::Pass;
}
self.0.sleep(request);
Flow::Done(())
}
fn try_time_skip(&self) -> bool {
self.0.advance_to_next_deadline()
}
fn try_foreign_time_skip(&self) -> bool {
self.0.advance_to_next_any_deadline()
}
fn register_timer(&self, after: Duration) -> Option<u64> {
self.0.register_timer(after, foreign_caller(), false)
}
fn register_event_timer(&self, after: Duration) -> Option<u64> {
self.0.register_timer(after, false, true)
}
fn unregister_timer(&self, key: u64) {
self.0.unregister_timer(key, foreign_caller());
}
fn unregister_event_timer(&self, key: u64) {
self.0.unregister_event(key);
}
fn supports_timer_wakes(&self) -> bool {
true
}
fn register_wake(&self, at: Duration, waker: Waker) -> Option<u64> {
let foreign = foreign_caller();
let key = self.0.register_wake(nanos(at), waker, foreign)?;
if foreign && let Some(domain) = snare_interpose::Domain::current() {
crate::readiness::skip_idle_later(&domain);
}
Some(key)
}
fn register_owned_wake(&self, at: Duration, waker: Waker, foreign: bool) -> Option<u64> {
self.0.register_wake(nanos(at), waker, foreign)
}
fn take_timer_wakes(&self) -> bool {
self.0.woke_timers.swap(false, Ordering::AcqRel)
}
fn native_quiescence(&self, domain: &snare_interpose::Domain) {
if self.0.holds_wakers() {
crate::readiness::skip_idle_later(domain);
}
}
fn cancel_wake(&self, key: u64) {
self.0.cancel_wake(key);
}
fn charge_latency(&self, latency: Duration) -> bool {
self.0.charge(latency)
}
fn spin_step(&self, step: Duration) -> SpinStep {
if driver_caller() {
return SpinStep::Runs;
}
self.0.spin_step(step)
}
fn expire_timer(&self, deadline: Duration) {
self.0.expire(deadline);
}
fn virtual_now(&self) -> Option<Duration> {
if let Some(t) = self.0.driver_time() {
return Some(Duration::from_nanos(t));
}
self.0.virtual_now()
}
fn real_span(&self, span: Duration) -> Option<Duration> {
self.0.real_span(span)
}
fn idle_wait(&self) -> Option<Duration> {
self.0.idle_wait()
}
fn wake_waiters(&self, domain: usize) {
crate::readiness::readiness().bump_time(domain);
}
fn wake_waiters_after_readiness(&self, _domain: usize) {}
fn wake_unscheduled(&self, domain: usize) {
crate::readiness::readiness().bump_time_unscheduled(domain);
}
fn settling(&self, domain: usize) -> bool {
crate::readiness::readiness().settling(domain)
}
fn dormant(&self, dormant: bool) {
self.0.set_dormant(dormant);
}
fn wait_due(&self) -> bool {
self.0.wait_due()
}
}
#[cfg(test)]
mod tests {
use super::*;
use std::task::Wake;
struct RecordedWake {
id: usize,
fired: Arc<Mutex<Vec<usize>>>,
}
impl Wake for RecordedWake {
fn wake(self: Arc<Self>) {
self.fired.lock().unwrap().push(self.id);
}
}
#[test]
fn cancelling_distinct_deadlines_preserves_remaining_wakes() {
crate::Sim::new().run(|| {
let clock = Clock::new(0);
clock.set_discrete(true);
let fired = Arc::new(Mutex::new(Vec::new()));
let ids: Vec<_> = (0..256)
.map(|i| {
clock
.register_wake(
i as u64 + 1,
Waker::from(Arc::new(RecordedWake {
id: i,
fired: fired.clone(),
})),
i % 3 == 0,
)
.unwrap()
})
.collect();
for i in (0..256).rev().filter(|i| i % 2 == 0) {
clock.cancel_wake(ids[i]);
}
let (_, wakers) = clock.fire_upto(0, 256);
wakers.into_iter().for_each(Waker::wake);
let expected: Vec<_> = [false, true]
.into_iter()
.flat_map(|foreign| (0..256).filter(move |i| i % 2 == 1 && (i % 3 == 0) == foreign))
.collect();
assert_eq!(*fired.lock().unwrap(), expected);
for id in ids {
clock.cancel_wake(id);
}
for foreign in [false, true] {
let timers = clock.timers(foreign);
assert!(timers.is_empty());
assert!(timers.wake_deadlines.is_empty());
}
});
}
#[test]
fn cancelling_a_tied_wake_preserves_swap_removal_order() {
crate::Sim::new().run(|| {
let clock = Clock::new(0);
clock.set_discrete(true);
let fired = Arc::new(Mutex::new(Vec::new()));
let ids: Vec<_> = (0..4)
.map(|id| {
clock
.register_wake(
10,
Waker::from(Arc::new(RecordedWake {
id,
fired: fired.clone(),
})),
false,
)
.unwrap()
})
.collect();
clock.cancel_wake(ids[1]);
clock.fire_upto(0, 10).1.into_iter().for_each(Waker::wake);
assert_eq!(*fired.lock().unwrap(), [0, 3, 2]);
for id in ids {
clock.cancel_wake(id);
}
assert!(clock.timers(false).is_empty());
});
}
#[test]
fn delivered_native_wakes_hold_the_deadline_until_cancelled() {
crate::Sim::new().run(|| {
let clock = Clock::new(0);
clock.set_discrete(true);
let first = clock
.register_wake(10, Waker::noop().clone(), false)
.unwrap();
let second = clock
.register_wake(10, Waker::noop().clone(), false)
.unwrap();
let wakers = clock.fire_upto(0, 10).1;
assert_eq!(wakers.len(), 2);
assert!(reached_wait(&clock.timers(false), 10));
clock.cancel_wake(first);
assert!(reached_wait(&clock.timers(false), 10));
clock.cancel_wake(second);
assert!(!reached_wait(&clock.timers(false), 10));
assert!(clock.timers(false).wake_deadlines.is_empty());
});
}
#[test]
fn firing_or_pruning_wakes_cleans_unheld_reverse_entries() {
crate::Sim::new().run(|| {
for (deterministic, foreign) in [(false, true), (true, false), (true, true)] {
let clock = Clock::new(0);
clock.set_discrete(true);
clock.set_deterministic(deterministic);
let id = clock
.register_wake(10, Waker::noop().clone(), foreign)
.unwrap();
assert_eq!(clock.take_wakers(10).len(), 1);
assert!(clock.timers(foreign).is_empty());
assert!(clock.timers(foreign).wake_deadlines.is_empty());
clock.cancel_wake(id);
}
let clock = Clock::new(0);
clock.set_discrete(true);
clock
.register_wake(10, Waker::noop().clone(), false)
.unwrap();
clock
.register_wake(20, Waker::noop().clone(), false)
.unwrap();
clock.fire_upto(0, 10);
let pruned = {
let mut timers = clock.timers(false);
let (any, wakers) = take_upto(&mut timers, 20);
assert!(any);
assert!(timers.is_empty());
assert!(timers.wake_deadlines.is_empty());
wakers
};
assert_eq!(pruned.len(), 1);
});
}
struct CancelWakeOnDrop {
clock: std::sync::Weak<Clock>,
sibling: u64,
dropped: Arc<AtomicBool>,
}
#[allow(
clippy::manual_noop_waker,
reason = "the destructor cancels another timer"
)]
impl Wake for CancelWakeOnDrop {
fn wake(self: Arc<Self>) {}
}
impl Drop for CancelWakeOnDrop {
fn drop(&mut self) {
self.clock.upgrade().unwrap().cancel_wake(self.sibling);
self.dropped.store(true, Ordering::SeqCst);
}
}
#[test]
fn cancellation_drops_a_waker_after_unlocking_its_table() {
crate::Sim::new().run(|| {
let clock = Arc::new(Clock::new(0));
clock.set_discrete(true);
let sibling = clock
.register_wake(20, Waker::noop().clone(), false)
.unwrap();
let dropped = Arc::new(AtomicBool::new(false));
let id = clock
.register_wake(
10,
Waker::from(Arc::new(CancelWakeOnDrop {
clock: Arc::downgrade(&clock),
sibling,
dropped: dropped.clone(),
})),
false,
)
.unwrap();
clock.cancel_wake(id);
assert!(dropped.load(Ordering::SeqCst));
assert!(clock.timers(false).is_empty());
assert!(clock.timers(false).wake_deadlines.is_empty());
});
}
#[test]
fn deterministic_spin_steps_do_not_wait_for_native_timer_settling() {
let clock = Clock::new(0);
clock.set_discrete(true);
clock.set_deterministic(true);
let timer = clock.register_timer(Duration::ZERO, false, false).unwrap();
assert!(matches!(
clock.spin_step(Duration::from_nanos(1)),
SpinStep::Moved { .. }
));
clock.unregister_timer(timer, false);
}
#[test]
fn line_round_trips_through_real_at() {
let line = Line {
anchor_v: 1_000,
anchor_real: 50,
rate_q32: rate_to_q32(10.0),
horizon: u64::MAX,
};
let r = line.real_at(1_000 + 5_000_000).unwrap();
assert_eq!(r, 50 + 500_000);
assert!(line.value_at(r) >= 1_000 + 5_000_000);
assert!(line.value_at(r - 1) < 1_000 + 5_000_000);
}
#[test]
fn max_rate_does_not_saturate() {
let line = Line {
anchor_v: 0,
anchor_real: 0,
rate_q32: rate_to_q32(MAX_RATE),
horizon: u64::MAX,
};
assert_eq!(line.value_at(1_000), 1_000_000_000);
assert_eq!(line.value_at(3_600_000_000_000), 3_600_000_000_000_000_000);
assert_eq!(line.real_at(1_000_000_000), Some(1_000));
}
#[test]
fn real_at_is_none_at_rate_zero() {
let line = Line {
anchor_v: 10,
anchor_real: 0,
rate_q32: 0,
horizon: u64::MAX,
};
assert_eq!(line.real_at(11), None);
assert_eq!(line.real_at(10), Some(0));
assert_eq!(line.value_at(1_000_000), 10);
}
#[test]
fn horizon_clamps_value_at() {
let line = Line {
anchor_v: 0,
anchor_real: 0,
rate_q32: rate_to_q32(1.0),
horizon: 7,
};
assert_eq!(line.value_at(1_000), 7);
assert_eq!(line.real_at(8), None);
assert_eq!(line.real_at(7), Some(7));
}
#[test]
fn rates_clamp_to_the_maximum() {
assert_eq!(rate_to_q32(1e9), rate_to_q32(MAX_RATE));
}
}