Enum MemoryHints 

pub enum MemoryHints {
    Performance,
    MemoryUsage,
    Manual {
        suballocated_device_memory_block_size: Range<u64>,
    },
}

Hints to the device about the memory allocation strategy.

Some backends may ignore these hints.

Variants

Performance

Favor performance over memory usage (the default value).

MemoryUsage

Favor memory usage over performance.

Manual

Applications that have control over the content that is rendered (typically games) may find an optimal compromise between memory usage and performance by specifying the allocation configuration.

Fields

suballocated_device_memory_block_size: Range<u64>

Defines the range of allowed memory block sizes for sub-allocated resources.

The backend may attempt to group multiple resources into fewer device memory blocks (sub-allocation) for performance reasons. The start of the provided range specifies the initial memory block size for sub-allocated resources. After running out of space in existing memory blocks, the backend may chose to progressively increase the block size of subsequent allocations up to a limit specified by the end of the range.

This does not limit resource sizes. If a resource does not fit in the specified range, it will typically be placed in a dedicated memory block.

Implementations

impl MemoryHints

pub const fn default() -> MemoryHints

This function is identical to Default::default() except that it is a const fn.

Trait Implementations

impl Clone for MemoryHints

fn clone(&self) -> MemoryHints

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for MemoryHints

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

Formats the value using the given formatter.

impl Default for MemoryHints

fn default() -> MemoryHints

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for MemoryHints

fn deserialize<__D>( __deserializer: __D, ) -> Result<MemoryHints, <__D as Deserializer<'de>>::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl PartialEq for MemoryHints

fn eq(&self, other: &MemoryHints) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Serialize for MemoryHints

fn serialize<__S>( &self, __serializer: __S, ) -> Result<<__S as Serializer>::Ok, <__S as Serializer>::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl Eq for MemoryHints

impl StructuralPartialEq for MemoryHints