vk::mem · Structs · A1

Native extent reserved to this region, including non-coherent atom padding.

Translate an allocation-relative range to a native block range. This does not validate allocator liveness or establish a mapping.

Donor: VMA VmaAllocator_T::GetFlushOrInvalidateRange. Adaptation: checked arithmetic, no-op ranges, allocation-end exception.

Borrow a registered allocation extension and its linked records.

Errors

Rejects cycles, duplicate tags, overlong chains, allocator-owned records and native records without an admitted allocator ownership/accounting contract.

Safety

Every reachable header and full payload must be valid, correctly tagged, immutable and readable for 'a; all nested pointers/handles and enabled capabilities must meet native valid usage at allocation. Imports must use an explicitly compatible memory type/size. Native import handle transfer occurs on successful vkAllocateMemory, even if later mapping/binding fails.

Borrow an import chain with explicit external payload accounting.

Use this for platform imports whose native allocation size is ignored or whose compatible types come from external properties. No OS query is guessed.

Errors

Same chain validation as new_from_record, plus absent/invalid import metadata, null resource identities and incompatible dedication policy.

Safety

The complete new_from_record contract applies. info must describe this exact payload and device: obtain size/types from the platform Vulkan query or authoritative OS/export metadata. Include all backing bytes, even when native allocationSize is ignored/zero. A supplied resource must be live, unbound, compatible, and have requirements covered by this size/type mask. Every native dedication rule still applies, including an exact requirements size wherever required. Fuchsia collection resource/index/size must match. Android/QNX/OHOS image profiles and Metal textures require their image. External host/OS objects must survive every native use, not just this borrow.

Gate new native memory against owned cached/refreshed budgets; reuse needs no new budget.

Force separate native storage, including in automatic custom pools.

Borrowed native allocation chain. Implies separate storage; never combined with a pool chain. Imports are attempted once and never initialized/poisoned.

Reuse existing pool storage only; never grow or fall back to separate native storage.

Reserve conservatively for alias resources and omit resource-specific dedication.

Non-default priority requires captured enabled EXT_memory_priority.

Additional offset alignment; zero means only native/pool/atom constraints. Otherwise a power of two, combined with every mandatory alignment.

Fixed-type custom pool. Overrides policy; native type compatibility and required properties remain mandatory. No fallback outside this pool.

Pool policy storage cannot outlive or be used after destroying its pool:

let options = vk::mem::AllocationCreateInfo::new().set_pool(Some(pool));
allocator.destroy_pool(pool).unwrap();
assert!(!options.pool.unwrap().is_destroyed());

Automatic host intent also prefers already mapped compatible blocks. Explicit usage retains mapping intent; absence of automatic intent prefers unmapped blocks.

Permit automatic selection of non-host-visible memory; caller supplies staging.

Properties penalized during memory-type selection; never a hard exclusion.

Intersected with queried native requirements; zero admits no memory types.

TLSF block search is forward except MinTime, which searches in reverse. Other strategies group host-visible blocks by mapping preference first.

Allocate downward in a single-block linear custom pool. Other routes reject it.

Retain a mapping until explicit allocation release. Requires host-visible storage.

Construct the record with its default state.

Set within_budget and return the updated record.

Set dedicated_memory and return the updated record.

Set memory_allocate_next and return the updated record.

The descriptor retains its chain storage borrow:

let options;
{
    let record = vk::ExportMemoryAllocateInfo::new();
    // SAFETY: this correctly tagged record has no linked or nested storage.
    let chain = unsafe { vk::mem::AllocationChain::new_from_record(&record) }.unwrap();
    options = vk::mem::AllocationCreateInfo::new()
        .set_memory_allocate_next(Some(chain))
        .set_dedicated_memory(true);
}
assert!(options.memory_allocate_next.is_some());

Set never_allocate and return the updated record.

Set can_alias and return the updated record.

Set priority and return the updated record.

Set min_allocation_alignment and return the updated record.

Set pool and return the updated record.

Set usage and return the updated record.

Set host_access and return the updated record.

Set allow_transfer_instead and return the updated record.

Set avoided_flags and return the updated record.

Set required_flags and return the updated record.

Set preferred_flags and return the updated record.

Set memory_type_bits and return the updated record.

Set strategy and return the updated record.

Set upper_address and return the updated record.

Set policy and return the updated record.

Set persistent_map and return the updated record.

Includes non-coherent atom padding reserved to a pooled region.

Actual selected memory properties, rather than requested preferences.

Allocation-relative pointer, present only for this region’s mapping hold. Observing this pointer does not acquire a hold or authorize dereferencing it.

Explicit mapping holds; persistent mapping is independent.

Size of the backing native memory object, including other pooled regions.

Separate native storage rather than a pooled placement (not proof of native dedication).

Opaque consumer metadata. No dereference or ownership is inferred.

Set device_memory and return the updated record.

Set offset and return the updated record.

Set size and return the updated record.

Set reserved_size and return the updated record.

Set memory_type_index and return the updated record.

Set heap_index and return the updated record.

Set memory_properties and return the updated record.

Set mapped_pointer and return the updated record.

Set map_count and return the updated record.

Set native_size and return the updated record.

Set is_separate and return the updated record.

Set user_data and return the updated record.

Set device and return the updated record.

Set instance and return the updated record.

Set physical_device and return the updated record.

Set api_version and return the updated record.

Sum of native requirements sizes, or full accounted external import extents.

Includes cache-atom padding reserved to live pooled regions.

Construct the record with its default state.

Set allocation_count and return the updated record.

Set native_allocation_count and return the updated record.

Set pooled_block_count and return the updated record.

Set allocation_bytes and return the updated record.

Set reserved_bytes and return the updated record.

Set native_bytes and return the updated record.

Set mapped_native_count and return the updated record.

Construct explicit requirements with no required or preferred properties. The selector/allocation operation validates size, alignment and type compatibility.

Set size and return the updated record.

Set alignment and return the updated record.

Set memory_type_bits and return the updated record.

Set required_flags and return the updated record.

Set preferred_flags and return the updated record.