Struct ElectedClock 

pub struct ElectedClock { /* private fields */ }

The elected pipeline clock as the sinks hold it: a stable shared handle whose target can be replaced (M1004).

ClockSync is handed to each sink once, before any frame flows, and the runner cannot reach the sinks again afterwards (their elements have moved into the arms, on other threads under the thread-per-arm runner). So when the elected clock degrades and the runner re-elects, the way the new choice reaches every sink is this handle: the ClockSync they hold points at the ElectedClock, and swap retargets it in place.

as_ticker stays None here: it lends out a borrow of the clock, which a target that can be replaced cannot give. shared_ticker is owned, so it forwards and follows the swap. The runner only installs this indirection when it is going to monitor clock health; otherwise sinks get the elected clock directly.

Implementations

impl ElectedClock

pub fn new(target: Arc<dyn PipelineClock + Send + Sync>) -> Self

A handle pointing at the freshly elected clock.

pub fn swap(&self, target: Arc<dyn PipelineClock + Send + Sync>)

Retarget every holder at target (a re-election). Reads after this see the new clock’s timeline; a sink re-anchors on its next frame the same way it does for any other epoch change.

pub fn target(&self) -> Arc<dyn PipelineClock + Send + Sync>

The clock currently pointed at.

Trait Implementations

impl Debug for ElectedClock

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl PipelineClock for ElectedClock

fn now_ns(&self) -> u64

fn shared_ticker(&self) -> Option<Arc<dyn DynAsyncClock + Send + Sync>>

The same timer as as_ticker, as an owned shared handle. The thread-per-arm runner builds each arm’s future on its own OS thread, which a borrow cannot cross, so that is where it reads the tick from instead.

fn healthy(&self) -> bool

Whether this clock still holds the reference it disciplines to. A clock that tells time from a source it cannot lose (a monotonic counter, a DAC) is always healthy, which is the default; a disciplined clock (PtpClock) reports false once its master is gone. The runner polls the elected clock and, on a loss, posts BusMessage::ClockLost and re-elects over the candidates that are still healthy.

fn as_ticker(&self) -> Option<&dyn DynAsyncClock>

This clock as a deadline sleeper, when it is one. The cooperative runner reads it to derive a fan-in element’s tick timer (PipelinePacket::Tick, M880) from the pipeline clock itself, so a parse_launch line running against any sleepable clock ticks without a separate entry point.