Struct bulk_allocator::LayoutBulkAllocator

pub struct LayoutBulkAllocator<'a, B: 'a + AllocRef> { /* fields omitted */ }

LayoutBulkAllocator pools allocated memory and frees it on the destruction.

alloc() and dealloc() delegates the request if the layout is different from what is specified to the constructor; otherwise, dealloc() caches the passed pointer and alloc() returns the cache. If no memory is pooled, alloc() allocate memory chunk from the backend, and makes caches at first.

Compared to BulkAllocator the performance of LayoutBulkAllocator is better than that of BulkAllocator as long as the argument layout of alloc() and dealloc() is same to which is passed to the constructor.

Lifetime

Each instance owns or borrows the backend AllocRef instance. If it is borrowed, the lifetime is limited by the reference; otherwise, the lifetime will be 'static.

Thread safety

All the mutable methods are thread unsafe.

Warnings

After drop, programer must NOT use the memories which method alloc() of this instance returned.

Implementations

impl<B> LayoutBulkAllocator<'static, B> where
    B: AllocRef + Default, 

pub fn from_layout(layout: Layout) -> Self

Constructor specifies only the layout for the instance to use the cache.

The backend AllocRef instance is created by Default::default(). The instance owns the backend, so there is no limitation for the lifetime.

impl<B: AllocRef> LayoutBulkAllocator<'static, B>

pub fn from_layout_backend(layout: Layout, backend: B) -> Self

Construct a new instance from the layout and the backend AllocRef instance.

The instance owns the backend, so there is no limitation of the lifetime.

impl<'a, B: 'a + AllocRef> LayoutBulkAllocator<'a, B>

pub fn from_layout_mut_backend(layout: Layout, backend: &'a mut B) -> Self

Construct a neww instance from the layout and the reference to the backend.

The instance just borrows the backend, so the lifetime is limited.

Trait Implementations

impl<B: AllocRef, '_> AllocRef for LayoutBulkAllocator<'_, B>

Thread safety

All the methods are thread unsafe.

fn alloc(&mut self, layout: Layout) -> Result<NonNull<[u8]>, AllocErr>

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

Attempts to allocate a block of memory.

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

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

Deallocates the memory referenced by ptr.

fn alloc_zeroed(&mut self, layout: Layout) -> Result<NonNull<[u8]>, AllocErr>

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

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

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

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

Attempts to extend the memory block.

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

🔬 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(
    &mut self,
    ptr: NonNull<u8>,
    old_layout: Layout,
    new_layout: Layout
) -> Result<NonNull<[u8]>, AllocErr>

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

Attempts to shrink the memory block.

fn by_ref(&mut self) -> &mut Self

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

Creates a "by reference" adaptor for this instance of AllocRef.

impl<B: AllocRef, '_> Drop for LayoutBulkAllocator<'_, B>

fn drop(&mut self)

Executes the destructor for this type.