1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55
bitflags::bitflags! {
/// Memory properties type.
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct MemoryPropertyFlags: u8 {
/// This flag is set for device-local memory types.
/// Device-local memory is situated "close" to the GPU cores
/// and allows for fast access.
const DEVICE_LOCAL = 0x01;
/// This flag is set for host-visible memory types.
/// Host-visible memory can be mapped to the host memory range.
const HOST_VISIBLE = 0x02;
/// This flag is set for host-coherent memory types.
/// Host-coherent memory does not requires manual invalidation for
/// modifications on GPU to become visible on host;
/// nor flush for modification on host to become visible on GPU.
/// Access synchronization is still required.
const HOST_COHERENT = 0x04;
/// This flag is set for host-cached memory types.
/// Host-cached memory uses cache in host memory for faster reads from host.
const HOST_CACHED = 0x08;
/// This flag is set for lazily-allocated memory types.
/// Lazily-allocated memory must be used (and only) for transient image attachments.
const LAZILY_ALLOCATED = 0x10;
/// This flag is set for protected memory types.
/// Protected memory can be used for writing by protected operations
/// and can be read only by protected operations.
/// Protected memory cannot be host-visible.
/// Implementation must guarantee that there is no way for data to flow
/// from protected to unprotected memory.
const PROTECTED = 0x20;
}
}
/// Defines memory type.
#[derive(Clone, Copy, Debug)]
pub struct MemoryType {
/// Heap index of the memory type.
pub heap: u32,
/// Property flags of the memory type.
pub props: MemoryPropertyFlags,
}
/// Defines memory heap.
#[derive(Clone, Copy, Debug)]
pub struct MemoryHeap {
/// Size of memory heap in bytes.
pub size: u64,
}