Struct simple_chunk_allocator::GlobalChunkAllocator

pub struct GlobalChunkAllocator<'a, const CHUNK_SIZE: usize = DEFAULT_CHUNK_SIZE>(_);

Synchronized high-level wrapper around ChunkAllocator that implements the Rust traits GlobalAlloc which enables the usage as global allocator. The method GlobalChunkAllocator::allocator_api_glue returns an object of type AllocatorApiGlue which can be used with the allocator_api feature.

#![feature(const_mut_refs)]

use simple_chunk_allocator::{heap, heap_bitmap, GlobalChunkAllocator, PageAligned};

// The macros help to get a correctly sized arrays types.
// I page-align them for better caching and to improve the availability of
// page-aligned addresses.

/// Backing storage for heap (1Mib). (read+write) static memory in final executable.
static mut HEAP: PageAligned<[u8; 1048576]> = heap!();
/// Backing storage for heap bookkeeping bitmap. (read+write) static memory in final executable.
static mut HEAP_BITMAP: PageAligned<[u8; 512]> = heap_bitmap!();

#[global_allocator]
static ALLOCATOR: GlobalChunkAllocator =
    unsafe { GlobalChunkAllocator::new(HEAP.deref_mut_const(), HEAP_BITMAP.deref_mut_const()) };

Implementations

impl<'a, const CHUNK_SIZE: usize> GlobalChunkAllocator<'a, CHUNK_SIZE>

pub const fn new(heap: &'a mut [u8], bitmap: &'a mut [u8]) -> Self

High-level constructor around ChunkAllocator::<CHUNK_SIZE>::new_const.

It is recommended that the heap and the bitmap both start at page-aligned addresses for better performance and to enable a faster search for correctly aligned addresses.

pub fn usage(&self) -> f32

Returns the usage of the allocator in percentage.

pub const fn allocator_api_glue<'b>(
    &'b self
) -> AllocatorApiGlue<'a, 'b, CHUNK_SIZE>

Returns an instance of AllocatorApiGlue.

Trait Implementations

impl<'a, const CHUNK_SIZE: usize> Debug for GlobalChunkAllocator<'a, CHUNK_SIZE>

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

Formats the value using the given formatter.

impl<'a, const CHUNK_SIZE: usize> GlobalAlloc for GlobalChunkAllocator<'a, CHUNK_SIZE>

unsafe fn alloc(&self, layout: Layout) -> *mut u8

Allocate memory as described by the given layout.

unsafe fn dealloc(&self, ptr: *mut u8, layout: Layout)

Deallocate the block of memory at the given ptr pointer with the given layout.

unsafe fn alloc_zeroed(&self, layout: Layout) -> *mut u8

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

unsafe fn realloc(
    &self,
    ptr: *mut u8,
    layout: Layout,
    new_size: usize
) -> *mut u8

Shrink or grow a block of memory to the given new_size. The block is described by the given ptr pointer and layout.