|
| 1 | +//! Sampler cache for Vulkan backend. |
| 2 | +//! |
| 3 | +//! Nearly identical to the DX12 sampler cache, without descriptor heap management. |
| 4 | +
|
| 5 | +use std::collections::{hash_map::Entry, HashMap}; |
| 6 | + |
| 7 | +use ash::vk; |
| 8 | +use ordered_float::OrderedFloat; |
| 9 | + |
| 10 | +/// [`vk::SamplerCreateInfo`] is not hashable, so we wrap it in a newtype that is. |
| 11 | +/// |
| 12 | +/// We use [`OrderedFloat`] to allow for floating point values to be compared and |
| 13 | +/// hashed in a defined way. |
| 14 | +#[derive(Copy, Clone)] |
| 15 | +struct HashableSamplerCreateInfo(vk::SamplerCreateInfo<'static>); |
| 16 | + |
| 17 | +impl PartialEq for HashableSamplerCreateInfo { |
| 18 | + fn eq(&self, other: &Self) -> bool { |
| 19 | + self.0.flags == other.0.flags |
| 20 | + && self.0.mag_filter == other.0.mag_filter |
| 21 | + && self.0.min_filter == other.0.min_filter |
| 22 | + && self.0.mipmap_mode == other.0.mipmap_mode |
| 23 | + && self.0.address_mode_u == other.0.address_mode_u |
| 24 | + && self.0.address_mode_v == other.0.address_mode_v |
| 25 | + && self.0.address_mode_w == other.0.address_mode_w |
| 26 | + && OrderedFloat(self.0.mip_lod_bias) == OrderedFloat(other.0.mip_lod_bias) |
| 27 | + && self.0.anisotropy_enable == other.0.anisotropy_enable |
| 28 | + && OrderedFloat(self.0.max_anisotropy) == OrderedFloat(other.0.max_anisotropy) |
| 29 | + && self.0.compare_enable == other.0.compare_enable |
| 30 | + && self.0.compare_op == other.0.compare_op |
| 31 | + && OrderedFloat(self.0.min_lod) == OrderedFloat(other.0.min_lod) |
| 32 | + && OrderedFloat(self.0.max_lod) == OrderedFloat(other.0.max_lod) |
| 33 | + && self.0.border_color == other.0.border_color |
| 34 | + && self.0.unnormalized_coordinates == other.0.unnormalized_coordinates |
| 35 | + } |
| 36 | +} |
| 37 | + |
| 38 | +impl Eq for HashableSamplerCreateInfo {} |
| 39 | + |
| 40 | +impl std::hash::Hash for HashableSamplerCreateInfo { |
| 41 | + fn hash<H: std::hash::Hasher>(&self, state: &mut H) { |
| 42 | + self.0.flags.hash(state); |
| 43 | + self.0.mag_filter.hash(state); |
| 44 | + self.0.min_filter.hash(state); |
| 45 | + self.0.mipmap_mode.hash(state); |
| 46 | + self.0.address_mode_u.hash(state); |
| 47 | + self.0.address_mode_v.hash(state); |
| 48 | + self.0.address_mode_w.hash(state); |
| 49 | + OrderedFloat(self.0.mip_lod_bias).hash(state); |
| 50 | + self.0.anisotropy_enable.hash(state); |
| 51 | + OrderedFloat(self.0.max_anisotropy).hash(state); |
| 52 | + self.0.compare_enable.hash(state); |
| 53 | + self.0.compare_op.hash(state); |
| 54 | + OrderedFloat(self.0.min_lod).hash(state); |
| 55 | + OrderedFloat(self.0.max_lod).hash(state); |
| 56 | + self.0.border_color.hash(state); |
| 57 | + self.0.unnormalized_coordinates.hash(state); |
| 58 | + } |
| 59 | +} |
| 60 | + |
| 61 | +/// Entry in the sampler cache. |
| 62 | +struct CacheEntry { |
| 63 | + sampler: vk::Sampler, |
| 64 | + ref_count: u32, |
| 65 | +} |
| 66 | + |
| 67 | +/// Global sampler cache. |
| 68 | +/// |
| 69 | +/// As some devices have a low limit (4000) on the number of unique samplers that can be created, |
| 70 | +/// we need to cache samplers to avoid running out if people eagerly create duplicate samplers. |
| 71 | +pub(crate) struct SamplerCache { |
| 72 | + /// Mapping from the sampler description to sampler and reference count. |
| 73 | + samplers: HashMap<HashableSamplerCreateInfo, CacheEntry>, |
| 74 | + /// Maximum number of unique samplers that can be created. |
| 75 | + total_capacity: u32, |
| 76 | +} |
| 77 | + |
| 78 | +impl SamplerCache { |
| 79 | + pub fn new(total_capacity: u32) -> Self { |
| 80 | + SamplerCache { |
| 81 | + samplers: HashMap::new(), |
| 82 | + total_capacity, |
| 83 | + } |
| 84 | + } |
| 85 | + |
| 86 | + /// Create a sampler, or return an existing one if it already exists. |
| 87 | + /// |
| 88 | + /// If the sampler already exists, the reference count is incremented. |
| 89 | + /// |
| 90 | + /// If the sampler does not exist, a new sampler is created and inserted into the cache. |
| 91 | + /// |
| 92 | + /// If the cache is full, an error is returned. |
| 93 | + pub fn create_sampler( |
| 94 | + &mut self, |
| 95 | + device: &ash::Device, |
| 96 | + create_info: vk::SamplerCreateInfo<'static>, |
| 97 | + ) -> Result<vk::Sampler, crate::DeviceError> { |
| 98 | + // Get the number of used samplers. Needs to be done before to appease the borrow checker. |
| 99 | + let used_samplers = self.samplers.len(); |
| 100 | + |
| 101 | + match self.samplers.entry(HashableSamplerCreateInfo(create_info)) { |
| 102 | + Entry::Occupied(occupied_entry) => { |
| 103 | + // We have found a match, so increment the refcount and return the index. |
| 104 | + let value = occupied_entry.into_mut(); |
| 105 | + value.ref_count += 1; |
| 106 | + Ok(value.sampler) |
| 107 | + } |
| 108 | + Entry::Vacant(vacant_entry) => { |
| 109 | + // We need to create a new sampler. |
| 110 | + |
| 111 | + // We need to check if we can create more samplers. |
| 112 | + if used_samplers >= self.total_capacity as usize { |
| 113 | + log::error!("There is no more room in the global sampler heap for more unique samplers. Your device supports a maximum of {} unique samplers.", self.samplers.len()); |
| 114 | + return Err(crate::DeviceError::OutOfMemory); |
| 115 | + } |
| 116 | + |
| 117 | + // Create the sampler. |
| 118 | + let sampler = unsafe { device.create_sampler(&create_info, None) } |
| 119 | + .map_err(super::map_host_device_oom_and_ioca_err)?; |
| 120 | + |
| 121 | + // Insert the new sampler into the mapping. |
| 122 | + vacant_entry.insert(CacheEntry { |
| 123 | + sampler, |
| 124 | + ref_count: 1, |
| 125 | + }); |
| 126 | + |
| 127 | + Ok(sampler) |
| 128 | + } |
| 129 | + } |
| 130 | + } |
| 131 | + |
| 132 | + /// Decrease the reference count of a sampler and destroy it if the reference count reaches 0. |
| 133 | + /// |
| 134 | + /// The provided sampler is checked against the sampler in the cache to ensure there is no clerical error. |
| 135 | + pub fn destroy_sampler( |
| 136 | + &mut self, |
| 137 | + device: &ash::Device, |
| 138 | + create_info: vk::SamplerCreateInfo<'static>, |
| 139 | + provided_sampler: vk::Sampler, |
| 140 | + ) { |
| 141 | + let Entry::Occupied(mut hash_map_entry) = |
| 142 | + self.samplers.entry(HashableSamplerCreateInfo(create_info)) |
| 143 | + else { |
| 144 | + log::error!("Trying to destroy a sampler that does not exist."); |
| 145 | + return; |
| 146 | + }; |
| 147 | + let cache_entry = hash_map_entry.get_mut(); |
| 148 | + |
| 149 | + assert_eq!( |
| 150 | + cache_entry.sampler, provided_sampler, |
| 151 | + "Provided sampler does not match the sampler in the cache." |
| 152 | + ); |
| 153 | + |
| 154 | + cache_entry.ref_count -= 1; |
| 155 | + |
| 156 | + if cache_entry.ref_count == 0 { |
| 157 | + unsafe { device.destroy_sampler(cache_entry.sampler, None) }; |
| 158 | + hash_map_entry.remove(); |
| 159 | + } |
| 160 | + } |
| 161 | +} |
0 commit comments