Struct SharedRegion 

pub struct SharedRegion<T: Copy + 'static> { /* private fields */ }

Implementations

impl<T: Copy + 'static> SharedRegion<T>

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

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

pub fn capacity(&self) -> usize

pub fn mmap_ptr(&self) -> *const u8

Raw pointer to the start of the MMF. Useful for primitives built on top of SharedRegion that need direct memory access (e.g., SharedLinkedList reads node next/prev/value fields directly at computed offsets instead of copying the whole node).

pub fn len(&self) -> usize

Number of slots currently allocated (bump high-water minus free-list length). This is a snapshot; concurrent alloc/free may race.

pub fn is_empty(&self) -> bool

pub fn free_count(&self) -> usize

Walk the free list (best-effort under concurrent activity) and return its length. O(N_free).

pub fn allocate(&self, value: T) -> Result<OffsetPtr<T>, RegionError>

Allocate a slot. Tries the free list first, then bump allocates. Returns Err(Full) when both are exhausted.

pub fn free(&self, ptr: OffsetPtr<T>) -> Result<T, RegionError>

Free a slot, returning the T it held. Pushes onto the Treiber-stack free list.

pub fn get(&self, ptr: OffsetPtr<T>) -> Result<T, RegionError>

Read the value at ptr. Returns Err(InvalidPtr) for nil or out-of-bounds. Caller is responsible for ensuring the ptr refers to a still-allocated slot (free’d slots may be reallocated and contain a different value).

pub fn set(&self, ptr: OffsetPtr<T>, value: T) -> Result<(), RegionError>

Overwrite the value at ptr. Same caveats as get: caller must hold a still-valid pointer.

pub fn clear(&self)

Reset the region to empty: bump pointer back to 0 and free list back to NIL. Existing OffsetPtr values become stale; callers must drop them. Useful for steady-state benches that need to reset accumulated state between iterations.

Not thread-safe: do not call concurrently with allocate / free from other threads. Intended for single-threaded reset (e.g. test setup, bench iter setup).

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

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

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<T: Copy + Send + Sync + 'static> AdaptiveInstance for SharedRegion<T>

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<T: Copy + Send + 'static> Send for SharedRegion<T>

impl<T: Copy + Sync + 'static> Sync for SharedRegion<T>