use {
super::{lease_command_buffer, Cache, Lease, Pool, PoolInfo},
crate::driver::{
accel_struct::{AccelerationStructure, AccelerationStructureInfo},
buffer::{Buffer, BufferInfo},
device::Device,
image::{Image, ImageInfo},
CommandBuffer, CommandBufferInfo, DescriptorPool, DescriptorPoolInfo, DriverError,
RenderPass, RenderPassInfo,
},
log::debug,
std::{collections::HashMap, sync::Arc},
};
#[derive(Debug)]
pub struct FifoPool {
accel_struct_cache: Cache<AccelerationStructure>,
buffer_cache: Cache<Buffer>,
command_buffer_cache: HashMap<u32, Cache<CommandBuffer>>,
descriptor_pool_cache: Cache<DescriptorPool>,
device: Arc<Device>,
image_cache: Cache<Image>,
info: PoolInfo,
render_pass_cache: HashMap<RenderPassInfo, Cache<RenderPass>>,
}
impl FifoPool {
pub fn new(device: &Arc<Device>) -> Self {
Self::with_capacity(device, PoolInfo::default())
}
pub fn with_capacity(device: &Arc<Device>, info: impl Into<PoolInfo>) -> Self {
let info: PoolInfo = info.into();
let device = Arc::clone(device);
Self {
accel_struct_cache: PoolInfo::explicit_cache(info.accel_struct_capacity),
buffer_cache: PoolInfo::explicit_cache(info.buffer_capacity),
command_buffer_cache: Default::default(),
descriptor_pool_cache: PoolInfo::default_cache(),
device,
image_cache: PoolInfo::explicit_cache(info.image_capacity),
info,
render_pass_cache: Default::default(),
}
}
pub fn clear(&mut self) {
self.clear_accel_structs();
self.clear_buffers();
self.clear_images();
}
pub fn clear_accel_structs(&mut self) {
self.accel_struct_cache = PoolInfo::explicit_cache(self.info.accel_struct_capacity);
}
pub fn clear_buffers(&mut self) {
self.buffer_cache = PoolInfo::explicit_cache(self.info.buffer_capacity);
}
pub fn clear_images(&mut self) {
self.image_cache = PoolInfo::explicit_cache(self.info.image_capacity);
}
}
impl Pool<AccelerationStructureInfo, AccelerationStructure> for FifoPool {
#[profiling::function]
fn lease(
&mut self,
info: AccelerationStructureInfo,
) -> Result<Lease<AccelerationStructure>, DriverError> {
let cache_ref = Arc::downgrade(&self.accel_struct_cache);
{
profiling::scope!("check cache");
#[cfg_attr(not(feature = "parking_lot"), allow(unused_mut))]
let mut cache = self.accel_struct_cache.lock();
#[cfg(not(feature = "parking_lot"))]
let mut cache = cache.unwrap();
for idx in 0..cache.len() {
let item = unsafe { cache.get_unchecked(idx) };
if item.info.size >= info.size && item.info.ty == info.ty {
let item = cache.swap_remove(idx);
return Ok(Lease::new(cache_ref, item));
}
}
}
debug!("Creating new {}", stringify!(AccelerationStructure));
let item = AccelerationStructure::create(&self.device, info)?;
Ok(Lease::new(cache_ref, item))
}
}
impl Pool<BufferInfo, Buffer> for FifoPool {
#[profiling::function]
fn lease(&mut self, info: BufferInfo) -> Result<Lease<Buffer>, DriverError> {
let cache_ref = Arc::downgrade(&self.buffer_cache);
{
profiling::scope!("check cache");
#[cfg_attr(not(feature = "parking_lot"), allow(unused_mut))]
let mut cache = self.buffer_cache.lock();
#[cfg(not(feature = "parking_lot"))]
let mut cache = cache.unwrap();
for idx in 0..cache.len() {
let item = unsafe { cache.get_unchecked(idx) };
if item.info.alignment >= info.alignment
&& item.info.mappable == info.mappable
&& item.info.size >= info.size
&& item.info.usage.contains(info.usage)
{
let item = cache.swap_remove(idx);
return Ok(Lease::new(cache_ref, item));
}
}
}
debug!("Creating new {}", stringify!(Buffer));
let item = Buffer::create(&self.device, info)?;
Ok(Lease::new(cache_ref, item))
}
}
impl Pool<CommandBufferInfo, CommandBuffer> for FifoPool {
#[profiling::function]
fn lease(&mut self, info: CommandBufferInfo) -> Result<Lease<CommandBuffer>, DriverError> {
let cache_ref = self
.command_buffer_cache
.entry(info.queue_family_index)
.or_insert_with(PoolInfo::default_cache);
let mut item = {
#[cfg_attr(not(feature = "parking_lot"), allow(unused_mut))]
let mut cache = cache_ref.lock();
#[cfg(not(feature = "parking_lot"))]
let mut cache = cache.unwrap();
lease_command_buffer(&mut cache)
}
.map(Ok)
.unwrap_or_else(|| {
debug!("Creating new {}", stringify!(CommandBuffer));
CommandBuffer::create(&self.device, info)
})?;
CommandBuffer::drop_fenced(&mut item);
Ok(Lease::new(Arc::downgrade(cache_ref), item))
}
}
impl Pool<DescriptorPoolInfo, DescriptorPool> for FifoPool {
#[profiling::function]
fn lease(&mut self, info: DescriptorPoolInfo) -> Result<Lease<DescriptorPool>, DriverError> {
let cache_ref = Arc::downgrade(&self.descriptor_pool_cache);
{
profiling::scope!("check cache");
#[cfg_attr(not(feature = "parking_lot"), allow(unused_mut))]
let mut cache = self.descriptor_pool_cache.lock();
#[cfg(not(feature = "parking_lot"))]
let mut cache = cache.unwrap();
for idx in 0..cache.len() {
let item = unsafe { cache.get_unchecked(idx) };
if item.info.max_sets >= info.max_sets
&& item.info.acceleration_structure_count >= info.acceleration_structure_count
&& item.info.combined_image_sampler_count >= info.combined_image_sampler_count
&& item.info.input_attachment_count >= info.input_attachment_count
&& item.info.sampled_image_count >= info.sampled_image_count
&& item.info.storage_buffer_count >= info.storage_buffer_count
&& item.info.storage_buffer_dynamic_count >= info.storage_buffer_dynamic_count
&& item.info.storage_image_count >= info.storage_image_count
&& item.info.storage_texel_buffer_count >= info.storage_texel_buffer_count
&& item.info.uniform_buffer_count >= info.uniform_buffer_count
&& item.info.uniform_buffer_dynamic_count >= info.uniform_buffer_dynamic_count
&& item.info.uniform_texel_buffer_count >= info.uniform_texel_buffer_count
{
let item = cache.swap_remove(idx);
return Ok(Lease::new(cache_ref, item));
}
}
}
debug!("Creating new {}", stringify!(DescriptorPool));
let item = DescriptorPool::create(&self.device, info)?;
Ok(Lease::new(cache_ref, item))
}
}
impl Pool<ImageInfo, Image> for FifoPool {
#[profiling::function]
fn lease(&mut self, info: ImageInfo) -> Result<Lease<Image>, DriverError> {
let cache_ref = Arc::downgrade(&self.image_cache);
{
profiling::scope!("check cache");
#[cfg_attr(not(feature = "parking_lot"), allow(unused_mut))]
let mut cache = self.image_cache.lock();
#[cfg(not(feature = "parking_lot"))]
let mut cache = cache.unwrap();
for idx in 0..cache.len() {
let item = unsafe { cache.get_unchecked(idx) };
if item.info.array_elements == info.array_elements
&& item.info.depth == info.depth
&& item.info.fmt == info.fmt
&& item.info.height == info.height
&& item.info.mip_level_count == info.mip_level_count
&& item.info.sample_count == info.sample_count
&& item.info.tiling == info.tiling
&& item.info.ty == info.ty
&& item.info.width == info.width
&& item.info.flags.contains(info.flags)
&& item.info.usage.contains(info.usage)
{
let item = cache.swap_remove(idx);
return Ok(Lease::new(cache_ref, item));
}
}
}
debug!("Creating new {}", stringify!(Image));
let item = Image::create(&self.device, info)?;
Ok(Lease::new(cache_ref, item))
}
}
impl Pool<RenderPassInfo, RenderPass> for FifoPool {
#[profiling::function]
fn lease(&mut self, info: RenderPassInfo) -> Result<Lease<RenderPass>, DriverError> {
let cache_ref = if let Some(cache) = self.render_pass_cache.get(&info) {
cache
} else {
self.render_pass_cache
.entry(info.clone())
.or_insert_with(PoolInfo::default_cache)
};
let item = {
#[cfg_attr(not(feature = "parking_lot"), allow(unused_mut))]
let mut cache = cache_ref.lock();
#[cfg(not(feature = "parking_lot"))]
let mut cache = cache.unwrap();
cache.pop()
}
.map(Ok)
.unwrap_or_else(|| {
debug!("Creating new {}", stringify!(RenderPass));
RenderPass::create(&self.device, info)
})?;
Ok(Lease::new(Arc::downgrade(cache_ref), item))
}
}