use crate::device::{Device, DeviceOwned};
use crate::instance::MemoryType;
use crate::memory::DedicatedAlloc;
use crate::memory::DeviceMemory;
use crate::memory::DeviceMemoryAllocError;
use crate::memory::MappedDeviceMemory;
use crate::memory::MemoryRequirements;
pub use self::host_visible::StdHostVisibleMemoryTypePool;
pub use self::host_visible::StdHostVisibleMemoryTypePoolAlloc;
pub use self::non_host_visible::StdNonHostVisibleMemoryTypePool;
pub use self::non_host_visible::StdNonHostVisibleMemoryTypePoolAlloc;
pub use self::pool::StdMemoryPool;
pub use self::pool::StdMemoryPoolAlloc;
use std::sync::Arc;
mod host_visible;
mod non_host_visible;
mod pool;
fn choose_allocation_memory_type<'s, F>(
device: &'s Arc<Device>,
requirements: &MemoryRequirements,
mut filter: F,
map: MappingRequirement,
) -> MemoryType<'s>
where
F: FnMut(MemoryType) -> AllocFromRequirementsFilter,
{
let mem_ty = {
let mut filter = |ty: MemoryType| {
if map == MappingRequirement::Map && !ty.is_host_visible() {
return AllocFromRequirementsFilter::Forbidden;
}
filter(ty)
};
let first_loop = device
.physical_device()
.memory_types()
.map(|t| (t, AllocFromRequirementsFilter::Preferred));
let second_loop = device
.physical_device()
.memory_types()
.map(|t| (t, AllocFromRequirementsFilter::Allowed));
first_loop
.chain(second_loop)
.filter(|&(t, _)| (requirements.memory_type_bits & (1 << t.id())) != 0)
.filter(|&(t, rq)| filter(t) == rq)
.next()
.expect("Couldn't find a memory type to allocate from")
.0
};
mem_ty
}
pub unsafe trait MemoryPool: DeviceOwned {
type Alloc: MemoryPoolAlloc;
fn alloc_generic(
&self,
ty: MemoryType,
size: usize,
alignment: usize,
layout: AllocLayout,
map: MappingRequirement,
) -> Result<Self::Alloc, DeviceMemoryAllocError>;
#[cfg(target_os = "linux")]
fn alloc_generic_with_exportable_fd(
&self,
ty: MemoryType,
size: usize,
alignment: usize,
layout: AllocLayout,
map: MappingRequirement,
) -> Result<Self::Alloc, DeviceMemoryAllocError>;
fn alloc_from_requirements<F>(
&self,
requirements: &MemoryRequirements,
layout: AllocLayout,
map: MappingRequirement,
dedicated: DedicatedAlloc,
filter: F,
) -> Result<PotentialDedicatedAllocation<Self::Alloc>, DeviceMemoryAllocError>
where
F: FnMut(MemoryType) -> AllocFromRequirementsFilter,
{
let mem_ty = choose_allocation_memory_type(self.device(), requirements, filter, map);
if !requirements.prefer_dedicated
|| !self.device().loaded_extensions().khr_dedicated_allocation
{
let alloc = self.alloc_generic(
mem_ty,
requirements.size,
requirements.alignment,
layout,
map,
)?;
return Ok(alloc.into());
}
if let DedicatedAlloc::None = dedicated {
let alloc = self.alloc_generic(
mem_ty,
requirements.size,
requirements.alignment,
layout,
map,
)?;
return Ok(alloc.into());
}
match map {
MappingRequirement::Map => {
let mem = DeviceMemory::dedicated_alloc_and_map(
self.device().clone(),
mem_ty,
requirements.size,
dedicated,
)?;
Ok(PotentialDedicatedAllocation::DedicatedMapped(mem))
}
MappingRequirement::DoNotMap => {
let mem = DeviceMemory::dedicated_alloc(
self.device().clone(),
mem_ty,
requirements.size,
dedicated,
)?;
Ok(PotentialDedicatedAllocation::Dedicated(mem))
}
}
}
#[cfg(target_os = "linux")]
fn alloc_from_requirements_with_exportable_fd<F>(
&self,
requirements: &MemoryRequirements,
layout: AllocLayout,
map: MappingRequirement,
dedicated: DedicatedAlloc,
filter: F,
) -> Result<PotentialDedicatedAllocation<Self::Alloc>, DeviceMemoryAllocError>
where
F: FnMut(MemoryType) -> AllocFromRequirementsFilter,
{
assert!(self.device().loaded_extensions().khr_external_memory_fd);
assert!(self.device().loaded_extensions().khr_external_memory);
let mem_ty = choose_allocation_memory_type(self.device(), requirements, filter, map);
if !requirements.prefer_dedicated
|| !self.device().loaded_extensions().khr_dedicated_allocation
{
let alloc = self.alloc_generic_with_exportable_fd(
mem_ty,
requirements.size,
requirements.alignment,
layout,
map,
)?;
return Ok(alloc.into());
}
if let DedicatedAlloc::None = dedicated {
let alloc = self.alloc_generic_with_exportable_fd(
mem_ty,
requirements.size,
requirements.alignment,
layout,
map,
)?;
return Ok(alloc.into());
}
match map {
MappingRequirement::Map => {
let mem = DeviceMemory::dedicated_alloc_and_map_with_exportable_fd(
self.device().clone(),
mem_ty,
requirements.size,
dedicated,
)?;
Ok(PotentialDedicatedAllocation::DedicatedMapped(mem))
}
MappingRequirement::DoNotMap => {
let mem = DeviceMemory::dedicated_alloc_with_exportable_fd(
self.device().clone(),
mem_ty,
requirements.size,
dedicated,
)?;
Ok(PotentialDedicatedAllocation::Dedicated(mem))
}
}
}
}
#[derive(Debug, Copy, Clone, PartialEq, Eq)]
pub enum AllocFromRequirementsFilter {
Preferred,
Allowed,
Forbidden,
}
pub unsafe trait MemoryPoolAlloc {
fn mapped_memory(&self) -> Option<&MappedDeviceMemory>;
fn memory(&self) -> &DeviceMemory;
fn offset(&self) -> usize;
}
#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
pub enum MappingRequirement {
Map,
DoNotMap,
}
#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
pub enum AllocLayout {
Linear,
Optimal,
}
#[derive(Debug)]
pub enum PotentialDedicatedAllocation<A> {
Generic(A),
Dedicated(DeviceMemory),
DedicatedMapped(MappedDeviceMemory),
}
unsafe impl<A> MemoryPoolAlloc for PotentialDedicatedAllocation<A>
where
A: MemoryPoolAlloc,
{
#[inline]
fn mapped_memory(&self) -> Option<&MappedDeviceMemory> {
match *self {
PotentialDedicatedAllocation::Generic(ref alloc) => alloc.mapped_memory(),
PotentialDedicatedAllocation::Dedicated(_) => None,
PotentialDedicatedAllocation::DedicatedMapped(ref mem) => Some(mem),
}
}
#[inline]
fn memory(&self) -> &DeviceMemory {
match *self {
PotentialDedicatedAllocation::Generic(ref alloc) => alloc.memory(),
PotentialDedicatedAllocation::Dedicated(ref mem) => mem,
PotentialDedicatedAllocation::DedicatedMapped(ref mem) => mem.as_ref(),
}
}
#[inline]
fn offset(&self) -> usize {
match *self {
PotentialDedicatedAllocation::Generic(ref alloc) => alloc.offset(),
PotentialDedicatedAllocation::Dedicated(_) => 0,
PotentialDedicatedAllocation::DedicatedMapped(_) => 0,
}
}
}
impl<A> From<A> for PotentialDedicatedAllocation<A> {
#[inline]
fn from(alloc: A) -> PotentialDedicatedAllocation<A> {
PotentialDedicatedAllocation::Generic(alloc)
}
}