Struct SimpleFirstFit 

pub struct SimpleFirstFit<StateElement, Element> { /* private fields */ }

Simple first fit free block manager, always search free block from memory region head (no free block link list), slowest, lowest internal fragment, lowest code size, and only support single memory region(extend just ignored)

Implementations

impl<StateElement, Element> SimpleFirstFit<StateElement, Element>

pub const fn new() -> Self

Trait Implementations

impl<StateElement, Element> Default for SimpleFirstFit<StateElement, Element>

fn default() -> Self

Returns the “default value” for a type.

impl<StateElement: PrimaryUInt, Element> FreeBlockManager for SimpleFirstFit<StateElement, Element>

const MAX_ELEMENT_COUNT: ElementCount<Self::StateElement, Self::Element> = ElementCount::MAX

max element count for single region, and is max allocable element count for single allocation, memory region will be splited (when enxtend or init) if region element count bigger than Self::MAX_ELEMENT_COUNT

type StateElement = StateElement

Block state element, block state exactually use 2 Self::StateElement, must ensure size_of::<Self::StateElement>() <= size_of::<usize>(),

type Element = Element

Block element, block underlying is [Self::Element], block align >= align_of::<Self::Element>, block size is multiple of size_of::<Self::Element>(), must ensure size_of::<Self::Element>() % align_of::<Self::Element>() == 0 && align_of::<Self::Element>() >= 2 && size_of::<Self::Element>() != 0. bigger size_of::Self::Element lead to bigger internal fragmentation, but can manage bigger memory region with same Self::StateElement

type Node = ()

Free block node, manager store Self::Node at free block head, then block size always >= size_of::<Self::Node>()

fn address_range(&self) -> (usize, usize)

acceptable address range, default full aligned range, maybe changed after init

fn take_out( &mut self, element_count: ElementCount<Self::StateElement, Self::Element>, ) -> Option<NonNull<Self::Node>>

take out a free block (find and unregister)

unsafe fn register(&mut self, _: NonNull<Self::Node>)

register a node to pool, caller must ensure node is free and in memory region managed by this manager

unsafe fn unregister(&mut self, _: NonNull<Self::Node>)

unregister a node from pool, caller must ensture node is in this pool

unsafe fn init(&mut self, ptr: NonNull<Self::Element>)

init manager, must call once and only once before call any other method, default call register. caller must ensure block body in address range

unsafe fn extend(&mut self, ptr: NonNull<Self::Element>)

extend with new anther memory region node, default call register, caller must ensure block body in address range

fn after_allocate(&mut self, ptr: NonNull<u8>, layout: Layout)

called by allocator just before block return to user, usually used by monitor, default no-op

fn before_deallocate(&mut self, ptr: NonNull<u8>, layout: Layout)

called by allocator just before deallocate block, usually used by monitor, default no-op