Struct bulk_allocator::BulkA

pub struct BulkA<B> where
    B: GlobalAlloc,  { /* fields omitted */ }

'BulkA' stands for 'Bulk Allocator'. This implements GlobalAlloc . It allocates and caches bulk memory from the backend, and deallocates them on the drop at once.

The Layout to be cached is limited. size must be less than or equal to MAX_LAYOUT_SIZE and align must be less than or equal to MAX_LAYOUT_ALIGN . Method alloc and dealloc just delegate the requests to the backend if specified Layout does not satisfied the condition.

alloc tries to find a cached pointer and returns it if specified Layout is cacheable. If appropriate cache is not found, tries to find a larger cache and splits it to return. (The rest parts of the large cache will be cached again.) If neither the appropriate nor larger cache is not found, it allocates a memory chunk from backend, and makes a cache at first. (The size of memory chunk is same to MEMORY_CHUNK_SIZE .)

Method dealloc caches the passed pointer if specified Layout is cacheable. i.e. the memory will not be freed then. It is when the instance is dropped to deallocate the memories.

Instance drop releases all the memory chunks using the backend allocator. Pointers allocated via this instance will be invalid after the instance drop if the Layout is cacheable. Accessing such a pointer may lead memory unsafety even if the pointer itself is not deallocated.

Warnings

Pointers via this instance will be invalid after the instance drop if the Layout is cacheable. Accessing such a pointer may lead memory unsafety even if the pointer itself is not deallocated.

Implementations

impl<B> BulkA<B> where
    B: GlobalAlloc, 

pub const MAX_LAYOUT_SIZE: usize

The max size of the Layout that method alloc uses the cache. Method alloc delegates the request to the backend if the size of specified Layout is greater than this value.

pub const MAX_LAYOUT_ALIGN: usize

The max layout of the Layout that method alloc uses the cache. Method dealloc delegates the request to the backend if the size of specified Layout is greater than this value.

(Actually, the align of Layout usually equals to or less than this number except for that the programer dares to set some greater value for some reason.)

impl<B> BulkA<B> where
    B: GlobalAlloc, 

pub fn new(backend: B) -> Self

Creates a new instance with empty cache.

backend is an allocator to allocate memory chunks to make cache. It is also used to deallocate the memory chunks on the drop.

Examples

use bulk_allocator::BulkA;
use std::alloc::System;

let _alloc = BulkA::new(System);

impl<B> BulkA<B> where
    B: GlobalAlloc, 

pub fn backend(&self) -> &B

Provides a reference to the backend allocator.

Trait Implementations

impl<B> GlobalAlloc for BulkA<B> where
    B: GlobalAlloc, 

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.