Struct AllocationSizes 

pub struct AllocationSizes {
    pub(crate) min_device_memblock_size: u64,
    pub(crate) max_device_memblock_size: u64,
    pub(crate) min_host_memblock_size: u64,
    pub(crate) max_host_memblock_size: u64,
}

The sizes of the memory blocks that the allocator will create.

Useful for tuning the allocator to your application’s needs. For example most games will be fine with the default values, but eg. an app might want to use smaller block sizes to reduce the amount of memory used.

Clamped between 4MB and 256MB, and rounds up to the nearest multiple of 4MB for alignment reasons.

Note that these limits only apply to shared memory blocks that can hold multiple allocations. If an allocation does not fit within the corresponding maximum block size, it will be placed in a dedicated memory block holding only this allocation, without limitations other than what the underlying hardware and driver are able to provide.

Fixed or growable block size

This structure represents ranges of allowed sizes for shared memory blocks. By default, if the upper bounds are not extended using with_max_*_memblock_size, the allocator will be configured to use a fixed memory block size for shared allocations.

Otherwise, the allocator will pick a memory block size within the specifed range, depending on the number of existing allocations for the memory type.

As a rule of thumb, the allocator will start with the minimum block size and double the size with each new allocation, up to the specified maximum block size. This growth is tracked independently for each memory type. The block size also decreases when blocks are deallocated.

Example

use gpu_allocator::AllocationSizes;
const MB: u64 = 1024 * 1024;
// This configuration uses fixed memory block sizes.
let fixed = AllocationSizes::new(256 * MB, 64 * MB);

// This configuration starts with 8MB memory blocks
// and grows the block size of a given memory type each
// time a new allocation is needed, up to a limit of
// 256MB for device memory and 64MB for host memory.
let growing = AllocationSizes::new(8 * MB, 8 * MB)
    .with_max_device_memblock_size(256 * MB)
    .with_max_host_memblock_size(64 * MB);

Fields

min_device_memblock_size: u64

The initial size for device memory blocks.

The size of new device memory blocks doubles each time a new block is needed, up to AllocationSizes::max_device_memblock_size.

Defaults to 256MB.

max_device_memblock_size: u64

The maximum size for device memory blocks.

Defaults to the value of AllocationSizes::min_device_memblock_size.

min_host_memblock_size: u64

The initial size for host memory blocks.

The size of new host memory blocks doubles each time a new block is needed, up to AllocationSizes::max_host_memblock_size.

Defaults to 64MB.

max_host_memblock_size: u64

The maximum size for host memory blocks.

Defaults to the value of AllocationSizes::min_host_memblock_size.

Implementations

impl AllocationSizes

pub fn new(device_memblock_size: u64, host_memblock_size: u64) -> Self

Sets the minimum device and host memory block sizes.

The maximum block sizes are initialized to the minimum sizes and can be increased using AllocationSizes::with_max_device_memblock_size and AllocationSizes::with_max_host_memblock_size.

pub fn with_max_device_memblock_size(self, size: u64) -> Self

Sets the maximum device memblock size, in bytes.

pub fn with_max_host_memblock_size(self, size: u64) -> Self

Sets the maximum host memblock size, in bytes.

pub(crate) fn adjust_memblock_size(size: u64, kind: &str) -> u64

pub(crate) fn get_memblock_size(&self, is_host: bool, count: usize) -> u64

Used internally to decide the size of a shared memory block based within the allowed range, based on the number of existing allocations. The more blocks there already are (where the requested allocation didn’t fit), the larger the returned memory block size is going to be (up to max_*_memblock_size).

Trait Implementations

impl Clone for AllocationSizes

fn clone(&self) -> AllocationSizes

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for AllocationSizes

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

Formats the value using the given formatter.

impl Default for AllocationSizes

fn default() -> Self

Returns the “default value” for a type.

impl Copy for AllocationSizes