Timers

Everything periodic in the live core rides one facility: crates/vike-core/src/timer_wheel.rs's DeadlineTimerWheel, armed and advanced by crates/vike-core/src/runtime/timers.rs at the drain-loop boundary. Consolidating the stuck-order watchdog, both dead-man switches, managed expiry and the observers onto one wheel means none of them can touch the per-message fold: the wheel is advanced once per drain batch, after the batch has folded, and an empty wheel costs a single is_empty read. This page is written from those two modules and from the TimerKind enum in crates/vike-core/src/runtime/mod.rs.

The wheel

It is a hashed timing wheel over a slab. Deadlines are quantized to ticks of tick_ms and hashed into a power-of-two number of slots, each an intrusive doubly-linked list carved out of one pre-allocated node slab with a free list. Insert reuses a free node — no allocation on the steady path; the slab grows only when more timers are concurrently armed than ever before — and cancel is an O(1) unlink. A TimerId carries a generation, so a stale id whose slot has since been reused is rejected rather than cancelling the wrong timer.

The boundary advance is O(1) in the common case: a monotonically maintained lower bound on all armed deadlines (min_tick) makes "nothing is due yet" a single integer compare regardless of how many timers are armed. When something is due, expiry walks only the crossed slots and the bound is re-established by one slot scan; an advance that crosses a whole rotation — a long idle gap — takes a full pass that sorts the due nodes so emission stays in nondecreasing deadline order.

The runtime builds it as DeadlineTimerWheel::new(50, 1024): 50 ms resolution times 1024 slots, about a 51 s rotation, which covers a typical watchdog half-timeout in the bounded stepping path and falls back to the full-rotation pass for larger ones.

Reaching the boundary when the core is idle

The core parks in blocking_recv between messages, and a parked core never reaches the boundary on its own. An OS waker thread injects an Ingest::Watchdog message on cadence whose dispatch arm is empty — it exists purely to wake the loop so drive_due_timers runs. That waker record is journaled only when a wall-clock sweep that mutates order state can ride it — the stuck-order ladder or either dead-man's switch — and its presence is what makes a session's journal refuse replay; with neither on, the boundary can only run replay-neutral observers, the waker is not written, and the session still replays. The rule is on the replay page.

What is armed, and when

arm_boundary_timers runs once at startup and arms the first six kinds below; each of them re-arms itself when it fires. When nothing is opted in the wheel stays empty and the advance is skipped, byte-identical to a wheel-free runtime.

The self-rescheduling sweeps re-arm at now + tick, skipping missed ticks rather than bursting catch-up sweeps after a long idle. drive_due_timers stamps the injected now_ms onto every engine before acting, so a fired sweep sees the timestamp semantics the old per-message dispatch gave it.

The last two rows are never armed at startup: maintain_equity_timer and maintain_state_save_timer arm and disarm them at the boundary as their gate opens and closes, and a fired one re-arms itself only while that gate still holds. The sampler stays armed while any engine holds an open position and is cancelled the instant the book goes flat; any_position_open tests size != 0.0 rather than map emptiness, because a closed position leaves a zero-size entry behind forever. The state save deliberately does not gate on open positions — a breaker's trip count or an estimator's accumulator matters whether the book is flat or not — and is cancelled the moment every mount is gone. Two more boundary probes have no timer at all and re-walk their subject every pass: the per-mount readiness gate, which no-ops in O(1) once every mount has priced, and the wall-clock strategy schedule, driven off the clock value because an injected clock may not advance between passes.

What the observers do

sample_equity resolves each engine's equity through the same resolve_equity and CoreConfig::price_cfg the snapshot uses, notes every open position's priced-or-missing state on its engine's price board so the warn-once set arms and clears, and hands one row per engine plus a "TOTAL" cross-venue row (the same py_sum law as equity_total) to the on_equity_sample sink — the core takes no data dependency, so the caller wires persistence. save_all_strategy_state is the one save loop shared with clean shutdown: each mount's Strategy::save_state runs under catch_unwind, a Some is written atomically to its sidecar, and an error is logged and swallowed. write_portfolio_snap appends a PortfolioSample — per-venue equity, balance, realized, and every open position — to the journal best-effort; it is replay-neutral and does not advance the snapshot cadence counter.