Struct mnemos_alloc::heap::AHeap

pub struct AHeap {
    freelist: MpscQueue<Recycle>,
    state: AtomicU8,
    heap: UnsafeCell<Heap>,
    heap_wait: WaitQueue,
    inhibit_alloc: AtomicBool,
    any_frees: AtomicBool,
}

An Anachro Heap item

Fields

freelist: MpscQueue<Recycle>

state: AtomicU8

heap: UnsafeCell<Heap>

heap_wait: WaitQueue

inhibit_alloc: AtomicBool

any_frees: AtomicBool

Implementations

impl AHeap

const INIT_IDLE: u8 = 1u8

The AHeap is initialized, and no HeapGuards are active.

const BUSY_LOCKED: u8 = 2u8

The AHeap is “locked”, and cannot currently be retrieved. In MOST cases this also means the heap is initialized, except for the brief period of time while the heap is being initialized.

pub unsafe fn bootstrap( addr: *mut u8, size: usize ) -> Result<(NonNull<Self>, HeapGuard), ()>

Construct a thread safe async allocator from a pool of memory.

Safety: The pool of memory MUST be valid for the ’static lifetime, e.g. obtained by a leaked buffer, a linker section, or some other mechanism. Additionally, we must semantically have exclusive access to this region of memory: There must be no other live references, or pointers to this region that are dereferenced after this call.

pub(crate) unsafe fn release_node(&'static self, node: NonNull<Recycle>)

pub fn poll(&'static self)

pub fn lock(&'static self) -> Result<HeapGuard, u8>

pub async fn allocate<T>(&'static self, item: T) -> HeapBox<T>

pub async fn allocate_arc<T>(&'static self, item: T) -> HeapArc<T>

pub async fn allocate_array_with<F, T>( &'static self, f: F, count: usize ) -> HeapArray<T>where F: Fn() -> T,

pub async fn allocate_fixed_vec<T>( &'static self, capacity: usize ) -> HeapFixedVec<T>

pub async fn allocate_raw(&'static self, layout: Layout) -> NonNull<()>

Trait Implementations

impl Send for AHeap

impl Sync for AHeap