Struct vulkano::memory::DeviceMemory

pub struct DeviceMemory { /* private fields */ }

Represents memory that has been allocated from the device.

The destructor of DeviceMemory automatically frees the memory.

Examples

use vulkano::memory::{DeviceMemory, MemoryAllocateInfo};

let memory_type_index = 0;

// Allocates 1KB of memory.
let memory = DeviceMemory::allocate(
    device.clone(),
    MemoryAllocateInfo {
        allocation_size: 1024,
        memory_type_index,
        ..Default::default()
    },
)
.unwrap();

Implementations

impl DeviceMemory

pub fn allocate( device: Arc<Device>, allocate_info: MemoryAllocateInfo<'_> ) -> Result<Self, Validated<VulkanError>>

Allocates a block of memory from the device.

Some platforms may have a limit on the maximum size of a single allocation. For example, certain systems may fail to create allocations with a size greater than or equal to 4GB.

Panics

• Panics if allocate_info.dedicated_allocation is Some and the contained buffer or image does not belong to device.

pub unsafe fn import( device: Arc<Device>, allocate_info: MemoryAllocateInfo<'_>, import_info: MemoryImportInfo ) -> Result<Self, Validated<VulkanError>>

Imports a block of memory from an external source.

Safety

• See the documentation of the variants of MemoryImportInfo.

Panics

• Panics if allocate_info.dedicated_allocation is Some and the contained buffer or image does not belong to device.

pub unsafe fn from_handle( device: Arc<Device>, handle: DeviceMemory, allocate_info: MemoryAllocateInfo<'_> ) -> Self

Creates a new DeviceMemory from a raw object handle.

Safety

• handle must be a valid Vulkan object handle created from device.
• allocate_info must match the info used to create the object.

pub fn memory_type_index(&self) -> u32

Returns the index of the memory type that this memory was allocated from.

pub fn allocation_size(&self) -> DeviceSize

Returns the size in bytes of the memory allocation.

pub fn is_dedicated(&self) -> bool

Returns true if the memory is a dedicated to a resource.

pub fn export_handle_types(&self) -> ExternalMemoryHandleTypes

Returns the handle types that can be exported from the memory allocation.

pub fn imported_handle_type(&self) -> Option<ExternalMemoryHandleType>

Returns the handle type that the memory allocation was imported from, if any.

pub fn flags(&self) -> MemoryAllocateFlags

Returns the flags the memory was allocated with.

pub fn mapping_state(&self) -> Option<&MappingState>

Returns the current mapping state, or None if the memory is not currently host-mapped.

pub fn map( &mut self, map_info: MemoryMapInfo ) -> Result<(), Validated<VulkanError>>

Maps a range of memory to be accessed by the host.

self must not be host-mapped already and must be allocated from host-visible memory.

pub fn unmap( &mut self, unmap_info: MemoryUnmapInfo ) -> Result<(), Validated<VulkanError>>

Unmaps the memory. It will no longer be accessible from the host.

self must be currently host-mapped.

pub unsafe fn invalidate_range( &self, memory_range: MappedMemoryRange ) -> Result<(), Validated<VulkanError>>

Invalidates the host cache for a range of mapped memory.

If the device memory is not host-coherent, you must call this function before the memory is read by the host, if the device previously wrote to the memory. It has no effect if the memory is host-coherent.

Safety

• If there are memory writes by the device that have not been propagated into the host cache, then there must not be any references in Rust code to any portion of the specified memory_range.

pub unsafe fn flush_range( &self, memory_range: MappedMemoryRange ) -> Result<(), Validated<VulkanError>>

Flushes the host cache for a range of mapped memory.

If the device memory is not host-coherent, you must call this function after writing to the memory, if the device is going to read the memory. It has no effect if the memory is host-coherent.

Safety

• There must be no operations pending or executing in a device queue, that access the specified memory_range.

pub fn commitment(&self) -> Result<DeviceSize, Box<ValidationError>>

Retrieves the amount of lazily-allocated memory that is currently commited to this memory object.

The device may change this value at any time, and the returned value may be already out-of-date.

self must have been allocated from a memory type that has the LAZILY_ALLOCATED flag set.

pub fn export_fd( &self, handle_type: ExternalMemoryHandleType ) -> Result<File, Validated<VulkanError>>

Exports the device memory into a Unix file descriptor. The caller owns the returned File.

Panics

• Panics if the user requests an invalid handle type for this device memory object.

Trait Implementations

impl AsMut<DeviceMemory> for MappedDeviceMemory

fn as_mut(&mut self) -> &mut DeviceMemory

Converts this type into a mutable reference of the (usually inferred) input type.

impl AsRef<DeviceMemory> for MappedDeviceMemory

fn as_ref(&self) -> &DeviceMemory

Converts this type into a shared reference of the (usually inferred) input type.

impl Debug for DeviceMemory

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

Formats the value using the given formatter.

impl DeviceOwned for DeviceMemory

fn device(&self) -> &Arc<Device>

Returns the device that owns self.

impl Drop for DeviceMemory

fn drop(&mut self)

Executes the destructor for this type.

impl Hash for DeviceMemory

fn hash<H: Hasher>(&self, state: &mut H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl PartialEq for DeviceMemory

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

This method tests for self and other values to be equal, and is used by ==.

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

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

impl VulkanObject for DeviceMemory

type Handle = DeviceMemory

The type of the object.

fn handle(&self) -> Self::Handle

Returns the raw Vulkan handle of the object.

impl Eq for DeviceMemory