Struct gpu_alloc::GpuAllocator

pub struct GpuAllocator<M> {

    dedicated_threshold: u64,
    preferred_dedicated_threshold: u64,
    transient_dedicated_threshold: u64,
    max_memory_allocation_size: u64,
    memory_for_usage: MemoryForUsage,
    memory_types: Box<[MemoryType]>,
    memory_heaps: Box<[Heap]>,
    allocations_remains: u32,
    non_coherent_atom_mask: u64,
    starting_free_list_chunk: u64,
    final_free_list_chunk: u64,
    minimal_buddy_size: u64,
    initial_buddy_dedicated_size: u64,
    buffer_device_address: bool,
    buddy_allocators: Box<[Option<BuddyAllocator<M>>]>,
    freelist_allocators: Box<[Option<FreeListAllocator<M>>]>,
}

Memory allocator for Vulkan-like APIs.

Fields

dedicated_threshold: u64

preferred_dedicated_threshold: u64

transient_dedicated_threshold: u64

max_memory_allocation_size: u64

memory_for_usage: MemoryForUsage

memory_types: Box<[MemoryType]>

memory_heaps: Box<[Heap]>

allocations_remains: u32

non_coherent_atom_mask: u64

starting_free_list_chunk: u64

final_free_list_chunk: u64

minimal_buddy_size: u64

initial_buddy_dedicated_size: u64

buffer_device_address: bool

buddy_allocators: Box<[Option<BuddyAllocator<M>>]>

freelist_allocators: Box<[Option<FreeListAllocator<M>>]>

Implementations

impl<M> GpuAllocator<M>

where M: MemoryBounds + 'static,

pub fn new(config: Config, props: DeviceProperties<'_>) -> Self

Creates new instance of GpuAllocator. Provided DeviceProperties should match properties of MemoryDevice that will be used with created GpuAllocator instance.

pub unsafe fn alloc( &mut self, device: &impl MemoryDevice<M>, request: Request, ) -> Result<MemoryBlock<M>, AllocationError>

Allocates memory block from specified device according to the request.

Safety

• device must be one with DeviceProperties that were provided to create this GpuAllocator instance.
• Same device instance must be used for all interactions with one GpuAllocator instance and memory blocks allocated from it.

pub unsafe fn alloc_with_dedicated( &mut self, device: &impl MemoryDevice<M>, request: Request, dedicated: Dedicated, ) -> Result<MemoryBlock<M>, AllocationError>

Allocates memory block from specified device according to the request. This function allows user to force specific allocation strategy. Improper use can lead to suboptimal performance or too large overhead. Prefer GpuAllocator::alloc if doubt.

Safety

• device must be one with DeviceProperties that were provided to create this GpuAllocator instance.
• Same device instance must be used for all interactions with one GpuAllocator instance and memory blocks allocated from it.

unsafe fn alloc_internal( &mut self, device: &impl MemoryDevice<M>, request: Request, dedicated: Option<Dedicated>, ) -> Result<MemoryBlock<M>, AllocationError>

pub unsafe fn import_memory( &mut self, memory: M, memory_type: u32, props: MemoryPropertyFlags, offset: u64, size: u64, ) -> MemoryBlock<M>

Creates a memory block from an existing memory allocation, transferring ownership to the allocator.

This function allows the GpuAllocator to manage memory allocated outside of the typical GpuAllocator::alloc family of functions.

Usage

If you need to import external memory, such as a Win32 HANDLE or a Linux dmabuf, import the device memory using the graphics api and platform dependent functions. Once that is done, call this function to make the GpuAllocator take ownership of the imported memory.

When calling this function, you must ensure there are enough remaining allocations.

Safety

• The memory must be allocated with the same device that was provided to create this GpuAllocator instance.
• The memory must be valid.
• The props, offset and size must match the properties, offset and size of the memory allocation.
• The memory must have been allocated with the specified memory_type.
• There must be enough remaining allocations.
• The memory allocation must not come from an existing memory block created by this allocator.
• The underlying memory object must be deallocated using the returned MemoryBlock with GpuAllocator::dealloc.

pub unsafe fn dealloc( &mut self, device: &impl MemoryDevice<M>, block: MemoryBlock<M>, )

Deallocates memory block previously allocated from this GpuAllocator instance.

Safety

• Memory block must have been allocated by this GpuAllocator instance
• device must be one with DeviceProperties that were provided to create this GpuAllocator instance
• Same device instance must be used for all interactions with one GpuAllocator instance and memory blocks allocated from it

pub fn max_allocation_size(&self) -> u64

Returns the maximum allocation size supported.

pub fn remaining_allocations(&self) -> u32

Returns the number of remaining available allocations.

This may be useful if you need know if the allocator can allocate a number of allocations ahead of time. This function is also useful for ensuring you do not allocate too much memory outside allocator (such as external memory).

pub unsafe fn set_remaining_allocations(&mut self, remaining: u32)

Sets the number of remaining available allocations.

Safety

The caller is responsible for ensuring the number of remaining allocations does not exceed how many remaining allocations there actually are on the memory device.

pub unsafe fn cleanup(&mut self, device: &impl MemoryDevice<M>)

Deallocates leftover memory objects. Should be used before dropping.

Safety

• device must be one with DeviceProperties that were provided to create this GpuAllocator instance
• Same device instance must be used for all interactions with one GpuAllocator instance and memory blocks allocated from it

Trait Implementations

impl<M: Debug> Debug for GpuAllocator<M>

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

Formats the value using the given formatter.