#![cfg_attr(
not(any(feature = "wgpu", all(feature = "dx12", target_os = "windows"))),
allow(dead_code)
)]
use std::collections::HashMap;
use super::frame_cache::{FrameCache, Limits};
#[cfg(test)]
mod tests;
const MIN_CHARGE: usize = 64 * 1024;
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub struct CanvasAssetBudget(usize);
impl CanvasAssetBudget {
pub const DEFAULT_BYTES: usize = 64 * 1024 * 1024;
pub const MAX_BYTES: usize = 1024 * 1024 * 1024;
pub const fn new(bytes: usize) -> Self {
Self(if bytes > Self::MAX_BYTES {
Self::MAX_BYTES
} else {
bytes
})
}
pub const fn bytes(self) -> usize {
self.0
}
pub const fn ceiling_bytes(self) -> usize {
self.0 * 2
}
}
impl Default for CanvasAssetBudget {
fn default() -> Self {
Self::new(Self::DEFAULT_BYTES)
}
}
#[derive(Clone, Copy, Debug, Default, PartialEq, Eq)]
#[cfg_attr(not(any(test, feature = "perf_profile")), allow(dead_code))]
pub(crate) struct AssetCacheStats {
pub evictions: usize,
pub uncached: usize,
pub uncached_bytes: usize,
pub stretch_bytes: usize,
}
pub(crate) struct AssetCache<T> {
resident: FrameCache<T>,
overflow: HashMap<u64, T>,
stats: AssetCacheStats,
}
impl<T> AssetCache<T> {
pub(crate) fn new(budget: CanvasAssetBudget) -> Self {
Self {
resident: FrameCache::framed(Limits {
budget: budget.bytes(),
ceiling: budget.ceiling_bytes(),
}),
overflow: HashMap::new(),
stats: AssetCacheStats::default(),
}
}
#[cfg(any(test, feature = "perf_profile"))]
pub(crate) fn bytes(&self) -> usize {
self.resident.bytes()
}
#[cfg(any(test, feature = "perf_profile"))]
pub(crate) fn len(&self) -> usize {
self.resident.len()
}
#[cfg(any(test, feature = "perf_profile"))]
pub(crate) fn budget(&self) -> usize {
self.resident.limits().budget
}
pub(crate) fn get(&mut self, id: u64) -> Option<&T> {
if self.overflow.contains_key(&id) {
return self.overflow.get(&id);
}
self.resident.get(id)
}
#[cfg(any(test, feature = "wgpu"))]
pub(crate) fn peek(&self, id: u64) -> Option<&T> {
self.overflow.get(&id).or_else(|| self.resident.peek(id))
}
pub(crate) fn insert(&mut self, id: u64, texture: T, len: usize, mut retire: impl FnMut(T)) {
let bytes = len.max(MIN_CHARGE);
let stats = &mut self.stats;
let kept = self.resident.insert(id, texture, bytes, |old| {
stats.evictions += 1;
retire(old);
});
match kept {
Ok(()) => self.note_stretch(),
Err(texture) => {
stats.uncached += 1;
stats.uncached_bytes += bytes;
self.overflow.insert(id, texture);
}
}
}
fn note_stretch(&mut self) {
let above = self.resident.bytes().saturating_sub(self.resident.limits().budget);
self.stats.stretch_bytes = self.stats.stretch_bytes.max(above);
}
pub(crate) fn finish_encode(&mut self, frame_ends: bool, mut retire: impl FnMut(T)) -> AssetCacheStats {
for (_, texture) in self.overflow.drain() {
retire(texture);
}
self.note_stretch();
if frame_ends {
let stats = &mut self.stats;
self.resident.close_frame(|old| {
stats.evictions += 1;
retire(old);
});
}
std::mem::take(&mut self.stats)
}
}