Struct rendy_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> LinearAllocator<B> where
    B: Backend, 

pub fn properties_required() -> Properties

Get properties required by the LinearAllocator.

pub fn max_allocation(&self) -> u64

Maximum allocation size.

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

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

pub fn dispose(self, device: &B::Device)

Perform full cleanup of the memory allocated.

Trait Implementations

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

type Block = LinearBlock<B>

Block type returned by allocator.

fn kind() -> Kind

Get allocator kind.

fn alloc(
    &mut self,
    device: &B::Device,
    size: u64,
    align: u64
) -> Result<(LinearBlock<B>, u64), 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) -> u64

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.