Struct SharedFenceClock 

pub struct SharedFenceClock { /* private fields */ }

Implementations

impl SharedFenceClock

pub fn create( path: impl AsRef<Path>, capacity: usize, ) -> Result<Self, FenceClockError>

pub fn open( path: impl AsRef<Path>, expected_capacity: usize, ) -> Result<Self, FenceClockError>

pub fn capacity(&self) -> usize

pub fn shared_clock_us(&self) -> u64

Current shared cross-process cached wall clock (microseconds). This is the freshest cache any process on the host has published to the MMF; it advances when any process ticks. One atomic load.

pub fn register(&self, pid: u32) -> Result<usize, FenceClockError>

Register the calling process. CAS-claims the first empty slot; returns slot index.

pub fn unregister(&self, idx: usize)

Release a slot so another process can claim it.

pub fn tick(&self, idx: usize) -> Hlc

Local internal-event HLC tick. Advances this slot’s HLC per the standard rules.

pub fn merge(&self, idx: usize, remote: Hlc) -> Hlc

Merge a remote HLC (e.g., received in a message) into this slot. Returns the new local HLC.

pub fn get_local(&self, idx: usize) -> Hlc

Read this slot’s current HLC.

pub fn compute_global_fence(&self) -> Hlc

Walk all slots and compute max(slot.hlc) across all non-vacant slots. This is the global fence: the timestamp at which all peers’ events are observable.

pub fn publish_global_fence(&self) -> Hlc

Publish the computed global fence to the header so other processes can read it via read_global_fence at O(1).

pub fn read_global_fence(&self) -> Hlc

Read the most-recently-published global fence (O(1); set by a publisher process / coordinator).

pub fn slot_snapshot(&self, idx: usize) -> Option<HlcSlotSnapshot>

Snapshot a specific slot (returns None when vacant).

pub fn fence_epoch(&self) -> u64

Total fence-publish epochs (counter bumped by publish_global_fence).

pub fn flush(&self) -> Result<(), FenceClockError>

pub fn flush_async(&self) -> Result<(), FenceClockError>

Non-blocking flush: schedules a writeback via the OS. Note: Windows is only partially async (sync to page cache, not to disk).

Trait Implementations

impl AdaptiveInstance for SharedFenceClock

fn header(&self) -> &HandshakeHeader

fn ring(&self) -> &ObservationRing

fn make_policy(&self) -> Box<dyn Policy>

fn apply_migration(&self, new_tag: u32)

Called by the sidecar when the policy returns a new strategy tag. Default implementation: just set the tag on the header. Primitives that need heavier migration (data-layout swap) override this to perform the swap before (or after) updating the tag.

impl Send for SharedFenceClock

impl Sync for SharedFenceClock