Struct ConcurrentMemoryManager 

pub struct ConcurrentMemoryManager<P: Payload> { /* private fields */ }

Public concurrent manager handle.

This is cheap to clone (clones the Arc), so multiple threads can share a ConcurrentMemoryManager instance and call the *_shared(&self) methods concurrently.

Implementations

impl<P: Payload> ConcurrentMemoryManager<P>

pub fn new(capacity: usize) -> Self

Create a new manager with the given capacity. Capacity must be finite and typically small-to-moderate (4..1024) for best performance.

The manager defaults to MemoryClass::Host.

pub fn with_memory_class(capacity: usize, mem_class: MemoryClass) -> Self

Create a new manager with explicit memory_class metadata.

memory_class is useful for telemetry and for future routing decisions when different storage classes exist.

pub fn store_shared( &self, value: Message<P>, ) -> Result<MessageToken, MemoryError>

Store a Message<P> and return its MessageToken.

This method:

• Pops a free index from the freelist (lock-free).
• Acquires the slot write lock and sets message = Some(value).

Returns MemoryError::NoFreeSlots if the freelist is empty.

Concurrency: multiple threads may concurrently allocate and store into different slots. Only the chosen slot is write-locked during the store.

pub fn read_shared( &self, token: MessageToken, ) -> Result<ConcurrentReadGuard<'_, P>, MemoryError>

Borrow a stored message immutably, returning a guard that keeps the slot read-locked for the lifetime of the guard.

Returns:

• BadToken if the token index is out of range,
• NotAllocated if the slot is currently empty,
• Poisoned if the slot lock is poisoned.

Concurrency: read locks allow many concurrent readers for the same slot.

pub fn read_mut_shared( &self, token: MessageToken, ) -> Result<ConcurrentWriteGuard<'_, P>, MemoryError>

Borrow a stored message mutably, returning a guard that keeps the slot write-locked for the lifetime of the guard.

This enforces exclusive access to the stored message while the guard is live.

pub fn free_shared(&self, token: MessageToken) -> Result<(), MemoryError>

Free a previously allocated token/slot.

Behavior:

• Acquire the slot write lock (this will wait for readers/writers).
• Ensure the slot is allocated; set message = None.
• Push the index back onto the lock-free freelist.

Returns NotAllocated if slot already empty or BadToken if token invalid.

pub fn available(&self) -> usize

Return the approximate number of free slots. This is updated atomically on each successful freelist push/pop. The value is diagnostic and may be slightly stale if concurrent operations are in-flight.

pub fn capacity(&self) -> usize

Return the configured capacity (number of slots).

pub fn memory_class(&self) -> MemoryClass

Return the memory class attached to this manager.

Trait Implementations

impl<P: Payload> Clone for ConcurrentMemoryManager<P>

fn clone(&self) -> Self

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<P: Payload> HeaderStore for ConcurrentMemoryManager<P>

fn peek_header( &self, token: MessageToken, ) -> Result<Self::HeaderGuard<'_>, MemoryError>

Peek the header of the stored message identified by token.

This acquires a slot read lock and returns a guard that keeps the lock for the lifetime of the returned guard.

type HeaderGuard<'a> = ConcurrentHeaderGuard<'a, P> where Self: 'a

Guard type returned by HeaderStore::peek_header.

impl<P: Payload> MemoryManager<P> for ConcurrentMemoryManager<P>

type ReadGuard<'a> = ConcurrentReadGuard<'a, P> where Self: 'a

Shared read guard returned by MemoryManager::read.

type WriteGuard<'a> = ConcurrentWriteGuard<'a, P> where Self: 'a

Exclusive mutable guard returned by MemoryManager::read_mut.

fn store(&mut self, value: Message<P>) -> Result<MessageToken, MemoryError>

Allocate storage for value and return its token.

fn read(&self, token: MessageToken) -> Result<Self::ReadGuard<'_>, MemoryError>

Borrow a stored message immutably.

fn read_mut( &mut self, token: MessageToken, ) -> Result<Self::WriteGuard<'_>, MemoryError>

Borrow a stored message mutably.

fn free(&mut self, token: MessageToken) -> Result<(), MemoryError>

Free the slot identified by token.

fn available(&self) -> usize

Return the number of currently free slots.

fn capacity(&self) -> usize

Return the total slot capacity of the manager.

fn memory_class(&self) -> MemoryClass

Return the memory class represented by this manager.

impl<P: Payload + Send + Sync> ScopedManager<P> for ConcurrentMemoryManager<P>

type Handle<'a> = ConcurrentMemoryManager<P> where Self: 'a

Per-worker handle type.

fn scoped_handle<'a>(&'a self) -> Self::Handle<'a>

where Self: 'a,

Create a scoped handle for a worker thread.