Struct olio::mem::MemHandle

pub struct MemHandle<T> where
    T: Deref<Target = [u8]>,  { /* fields omitted */ }

Wrapper over a byte buffer, supporting concurrent memory access advice, where the highest priority advice wins.

This is likely to only be useful for memory mapped regions and memory mapped files in particular.

Uses an internal Arc over shared state, so cloning the handle is inexpensive. Each new and cloned handle starts with the implicit MemAdvice::Normal. The shared state, a list of advisor interest counts, is maintained as a single atomic integer, for minimal overhead. Each MemAdvice level is allocated 10-bits or up to 1,023 MemHandle advisors. Any advice beyond this capacity or after an error is returned from advise, may be ignored, favoring the prior highest priority advice.

Implementations

impl<T> MemHandle<T> where
    T: Deref<Target = [u8]>, 

pub fn new(mem: T) -> MemHandle<T>

Wrap an owned instance of a byte slice buffer. Additional (atomic) references to the underlying buffer can then be created by clone of this handle.

pub fn advise(&self, advice: MemAdvice) -> Result<MemAdvice, MemAdviseError>

Advise on access plans for the underlying memory. There may be multiple cloned handles to the same memory region, so the advice is only relayed to the operating system if it has greater priority than any other advice made via another surviving handle. On success, returns the MemAdvice as relayed, or a snapshot of the current, highest priority advice. Returns an error if the underlying system call fails.

Trait Implementations

impl<T> Clone for MemHandle<T> where
    T: Deref<Target = [u8]>, 

pub fn clone(&self) -> MemHandle<T>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<T: Debug> Debug for MemHandle<T> where
    T: Deref<Target = [u8]>, 

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

Formats the value using the given formatter.

impl<T> Deref for MemHandle<T> where
    T: Deref<Target = [u8]>, 

type Target = [u8]

The resulting type after dereferencing.

pub fn deref(&self) -> &[u8]

Dereferences the value.

impl<T> Drop for MemHandle<T> where
    T: Deref<Target = [u8]>, 

pub fn drop(&mut self)

Executes the destructor for this type.