Struct gfx_memory::LinearAllocator

pub struct LinearAllocator<B: Backend> { /* fields omitted */ }

Linear allocator that return memory from chunk sequentially. It keeps only number of bytes allocated from each chunk. Once chunk is exhausted it is placed into list. When all blocks allocated from head of that list are freed, head is freed as well.

This allocator suites best short-lived types of allocations. Allocation strategy requires minimal overhead and implementation is fast. But holding single block will completely stop memory recycling.

Methods

impl<B: Backend> LinearAllocator<B>

pub fn new(
    memory_type: MemoryTypeId,
    memory_properties: Properties,
    config: &LinearConfig,
    non_coherent_atom_size: Size
) -> Self

Create new LinearAllocator for memory_type with memory_properties specified, with LinearConfig provided.

pub fn max_allocation(&self) -> Size

Maximum allocation size.

pub fn clear(&mut self, device: &B::Device)

Perform full cleanup of the memory allocated.

Trait Implementations

impl<B: Backend> Allocator<B> for LinearAllocator<B>

type Block = LinearBlock<B>

Block type returned by allocator.

const KIND: Kind

Allocator kind.

fn alloc(
    &mut self,
    device: &B::Device,
    size: Size,
    align: Size
) -> Result<(LinearBlock<B>, Size), AllocationError>

Allocate block of memory. On success returns allocated block and amount of memory consumed from device.

fn free(&mut self, device: &B::Device, block: Self::Block) -> Size

Free block of memory. Returns amount of memory returned to the device.

impl<B: Debug + Backend> Debug for LinearAllocator<B>

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

Formats the value using the given formatter.

impl<B: Backend> Drop for LinearAllocator<B>

fn drop(&mut self)

Executes the destructor for this type.