Struct vulkano::memory::MappedDeviceMemory

pub struct MappedDeviceMemory { /* private fields */ }

Represents memory that has been allocated and mapped in CPU accessible space.

Can be obtained with DeviceMemory::alloc_and_map. The function will panic if the memory type is not host-accessible.

In order to access the content of the allocated memory, you can use the read_write method. This method returns a guard object that derefs to the content.

Example

use vulkano::memory::DeviceMemory;

// The memory type must be mappable.
let mem_ty = device.physical_device().memory_types()
                    .filter(|t| t.is_host_visible())
                    .next().unwrap();    // Vk specs guarantee that this can't fail

// Allocates 1KB of memory.
let memory = DeviceMemory::alloc_and_map(device.clone(), mem_ty, 1024).unwrap();

// Get access to the content. Note that this is very unsafe for two reasons: 1) the content is
// uninitialized, and 2) the access is unsynchronized.
unsafe {
    let mut content = memory.read_write::<[u8]>(0 .. 1024);
    content[12] = 54;       // `content` derefs to a `&[u8]` or a `&mut [u8]`
}

Implementations

impl MappedDeviceMemory

pub fn unmap(self) -> DeviceMemory

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

pub unsafe fn read_write<T: ?Sized>(
    &self,
    range: Range<usize>
) -> CpuAccess<'_, T>where
    T: Content,

Gives access to the content of the memory.

This function takes care of calling vkInvalidateMappedMemoryRanges and vkFlushMappedMemoryRanges on the given range. You are therefore encouraged to use the smallest range as possible, and to not call this function multiple times in a row for several small changes.

Safety

• Type safety is not checked. You must ensure that T corresponds to the content of the buffer.
• Accesses are not synchronized. Synchronization must be handled outside of the MappedDeviceMemory.

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 MappedDeviceMemory

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

Formats the value using the given formatter.

impl DeviceOwned for MappedDeviceMemory

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

Returns the device that owns Self.

impl Send for MappedDeviceMemory

impl Sync for MappedDeviceMemory