Struct const_alloc::ConstAlloc

pub struct ConstAlloc<A>(_);

A const compatible wrapper over any Allocator type.

The wrapped Allocator doesn’t have to implement const Allocator, only Allocator. This wrapper will forward any calls to allocate at compile time to the const_allocate intrinsic. Likewise it will forward deallocate calls at compile time to the const_deallocate intrinsic.

Examples

const fn alloc_and_dealloc<A: ~const Allocator>(a: &A) {
    let ptr = a.allocate(Layout::new::<[u8; 128]>());
    if let Ok(ptr) = ptr {
        unsafe { a.deallocate(ptr.cast(), Layout::new::<[u8; 128]>()) };
    }
}

static ALLOC_COUNT: AtomicUsize = AtomicUsize::new(0);
static DEALLOC_COUNT: AtomicUsize = AtomicUsize::new(0);
 
struct CountingAlloc;
unsafe impl Allocator for CountingAlloc {
    fn allocate(&self, layout: Layout) -> Result<NonNull<[u8]>, AllocError> {
        ALLOC_COUNT.fetch_add(1, Ordering::SeqCst);
        System.allocate(layout)
    }
 
    unsafe fn deallocate(&self, ptr: NonNull<u8>, layout: Layout) {
        DEALLOC_COUNT.fetch_add(1, Ordering::SeqCst);
        System.deallocate(ptr, layout)
    }
}
static A: ConstAlloc<CountingAlloc> = ConstAlloc(CountingAlloc);
#[used]
static CT: () = alloc_and_dealloc(&A);
alloc_and_dealloc(&A);

// CountingAlloc::allocate will only be called during the runtime call to alloc_and_dealloc
assert_eq!(ALLOC_COUNT.load(Ordering::SeqCst), 1);
assert_eq!(DEALLOC_COUNT.load(Ordering::SeqCst), 1);

Trait Implementations

impl<A: Allocator> Allocator for ConstAlloc<A>

fn allocate(&self, layout: Layout) -> Result<NonNull<[u8]>, AllocError>

🔬 This is a nightly-only experimental API. (allocator_api)

Attempts to allocate a block of memory.

unsafe fn deallocate(&self, ptr: NonNull<u8>, layout: Layout)

🔬 This is a nightly-only experimental API. (allocator_api)

Deallocates the memory referenced by ptr.

fn allocate_zeroed(&self, layout: Layout) -> Result<NonNull<[u8]>, AllocError>

🔬 This is a nightly-only experimental API. (allocator_api)

Behaves like allocate, but also ensures that the returned memory is zero-initialized.

unsafe fn grow(
    &self,
    ptr: NonNull<u8>,
    old_layout: Layout,
    new_layout: Layout
) -> Result<NonNull<[u8]>, AllocError>

🔬 This is a nightly-only experimental API. (allocator_api)

Attempts to extend the memory block.

unsafe fn grow_zeroed(
    &self,
    ptr: NonNull<u8>,
    old_layout: Layout,
    new_layout: Layout
) -> Result<NonNull<[u8]>, AllocError>

🔬 This is a nightly-only experimental API. (allocator_api)

Behaves like grow, but also ensures that the new contents are set to zero before being returned.

unsafe fn shrink(
    &self,
    ptr: NonNull<u8>,
    old_layout: Layout,
    new_layout: Layout
) -> Result<NonNull<[u8]>, AllocError>

🔬 This is a nightly-only experimental API. (allocator_api)

Attempts to shrink the memory block.

fn by_ref(&self) -> &Self

🔬 This is a nightly-only experimental API. (allocator_api)

Creates a “by reference” adapter for this instance of Allocator.