Free least recently used

This commit is contained in:
grovesNL 2022-05-16 09:23:13 -02:30 committed by Josh Groves
parent 4b4594492a
commit 7aa2bd7b72
2 changed files with 179 additions and 49 deletions

View file

@ -1,6 +1,6 @@
use std::{ use std::{
borrow::Cow, borrow::Cow,
collections::{HashMap, HashSet}, collections::HashSet,
error::Error, error::Error,
fmt::{self, Display, Formatter}, fmt::{self, Display, Formatter},
iter, iter,
@ -15,6 +15,7 @@ use fontdue::{
layout::{GlyphRasterConfig, Layout}, layout::{GlyphRasterConfig, Layout},
Font, Font,
}; };
use recently_used::RecentlyUsedMap;
use wgpu::{ use wgpu::{
BindGroup, BindGroupEntry, BindGroupLayoutEntry, BindingResource, BindingType, BlendState, BindGroup, BindGroupEntry, BindGroupLayoutEntry, BindingResource, BindingType, BlendState,
Buffer, BufferBindingType, BufferDescriptor, BufferUsages, ColorTargetState, ColorWrites, Buffer, BufferBindingType, BufferDescriptor, BufferUsages, ColorTargetState, ColorWrites,
@ -28,6 +29,8 @@ use wgpu::{
pub use fontdue; pub use fontdue;
mod recently_used;
#[repr(C)] #[repr(C)]
pub struct Color { pub struct Color {
pub r: u8, pub r: u8,
@ -54,7 +57,9 @@ impl Display for PrepareError {
impl Error for PrepareError {} impl Error for PrepareError {}
#[derive(Clone, Copy, Debug, Eq, PartialEq)] #[derive(Clone, Copy, Debug, Eq, PartialEq)]
pub enum RenderError {} pub enum RenderError {
AtlasFull,
}
impl Display for RenderError { impl Display for RenderError {
fn fmt(&self, f: &mut Formatter) -> fmt::Result { fn fmt(&self, f: &mut Formatter) -> fmt::Result {
@ -96,40 +101,22 @@ pub struct Params {
screen_resolution: Resolution, screen_resolution: Resolution,
} }
fn try_allocate( fn try_allocate(atlas: &mut InnerAtlas, width: usize, height: usize) -> Option<Allocation> {
atlas: &mut InnerAtlas,
layout: &Layout<impl HasColor>,
width: usize,
height: usize,
) -> Option<Allocation> {
let size = size2(width as i32, height as i32); let size = size2(width as i32, height as i32);
let allocation = atlas.packer.allocate(size);
if allocation.is_some() { loop {
return allocation; let allocation = atlas.packer.allocate(size);
} if allocation.is_some() {
return allocation;
// Try to free any allocations not used in the current layout
// TODO: use LRU instead
let used_glyphs = layout
.glyphs()
.iter()
.map(|gp| gp.key)
.collect::<HashSet<_>>();
atlas.glyph_cache.retain(|key, details| {
if used_glyphs.contains(&key) {
true
} else {
if let Some(atlas_id) = details.atlas_id {
atlas.packer.deallocate(atlas_id)
}
false
} }
});
// Attempt to reallocate // Try to free least recently used allocation
atlas.packer.allocate(size) let (key, value) = atlas.glyph_cache.entries_least_recently_used().next()?;
atlas
.packer
.deallocate(value.atlas_id.expect("cache corrupt"));
atlas.glyph_cache.remove(&key);
}
} }
struct InnerAtlas { struct InnerAtlas {
@ -138,7 +125,7 @@ struct InnerAtlas {
packer: BucketedAtlasAllocator, packer: BucketedAtlasAllocator,
width: u32, width: u32,
height: u32, height: u32,
glyph_cache: HashMap<GlyphRasterConfig, GlyphDetails>, glyph_cache: RecentlyUsedMap<GlyphRasterConfig, GlyphDetails>,
params: Params, params: Params,
params_buffer: Buffer, params_buffer: Buffer,
} }
@ -183,7 +170,7 @@ impl TextAtlas {
..Default::default() ..Default::default()
}); });
let glyph_cache = HashMap::new(); let glyph_cache = RecentlyUsedMap::new();
// Create a render pipeline to use for rendering later // Create a render pipeline to use for rendering later
let shader = device.create_shader_module(&ShaderModuleDescriptor { let shader = device.create_shader_module(&ShaderModuleDescriptor {
@ -340,6 +327,7 @@ pub struct TextRenderer {
index_buffer_size: u64, index_buffer_size: u64,
vertices_to_render: u32, vertices_to_render: u32,
atlas: TextAtlas, atlas: TextAtlas,
glyphs_in_use: HashSet<GlyphRasterConfig>,
} }
impl TextRenderer { impl TextRenderer {
@ -367,6 +355,7 @@ impl TextRenderer {
index_buffer_size, index_buffer_size,
vertices_to_render: 0, vertices_to_render: 0,
atlas: atlas.clone(), atlas: atlas.clone(),
glyphs_in_use: HashSet::new(),
} }
} }
@ -402,8 +391,12 @@ impl TextRenderer {
} }
let mut upload_bounds = None::<UploadBounds>; let mut upload_bounds = None::<UploadBounds>;
self.glyphs_in_use.clear();
for layout in layouts.iter() { for layout in layouts.iter() {
for glyph in layout.glyphs() { for glyph in layout.glyphs() {
self.glyphs_in_use.insert(glyph.key);
let already_on_gpu = self let already_on_gpu = self
.atlas .atlas
.inner .inner
@ -411,6 +404,7 @@ impl TextRenderer {
.expect("atlas locked") .expect("atlas locked")
.glyph_cache .glyph_cache
.contains_key(&glyph.key); .contains_key(&glyph.key);
if already_on_gpu { if already_on_gpu {
continue; continue;
} }
@ -422,11 +416,10 @@ impl TextRenderer {
let (gpu_cache, atlas_id) = if glyph.char_data.rasterize() { let (gpu_cache, atlas_id) = if glyph.char_data.rasterize() {
// Find a position in the packer // Find a position in the packer
let allocation = let allocation = match try_allocate(&mut atlas, metrics.width, metrics.height) {
match try_allocate(&mut atlas, layout, metrics.width, metrics.height) { Some(a) => a,
Some(a) => a, None => return Err(PrepareError::AtlasFull),
None => return Err(PrepareError::AtlasFull), };
};
let atlas_min = allocation.rectangle.min; let atlas_min = allocation.rectangle.min;
let atlas_max = allocation.rectangle.max; let atlas_max = allocation.rectangle.max;
@ -467,15 +460,17 @@ impl TextRenderer {
(GpuCache::SkipRasterization, None) (GpuCache::SkipRasterization, None)
}; };
atlas.glyph_cache.insert( if !atlas.glyph_cache.contains_key(&glyph.key) {
glyph.key, atlas.glyph_cache.insert(
GlyphDetails { glyph.key,
width: metrics.width as u16, GlyphDetails {
height: metrics.height as u16, width: metrics.width as u16,
gpu_cache, height: metrics.height as u16,
atlas_id, gpu_cache,
}, atlas_id,
); },
);
}
} }
} }
@ -599,11 +594,19 @@ impl TextRenderer {
Ok(()) Ok(())
} }
pub fn render<'pass>(&'pass mut self, pass: &mut RenderPass<'pass>) -> Result<(), ()> { pub fn render<'pass>(&'pass mut self, pass: &mut RenderPass<'pass>) -> Result<(), RenderError> {
if self.vertices_to_render == 0 { if self.vertices_to_render == 0 {
return Ok(()); return Ok(());
} }
// Validate that glyphs haven't been evicted from cache since `prepare`
let atlas = self.atlas.inner.read().expect("atlas locked");
for glyph in self.glyphs_in_use.iter() {
if !atlas.glyph_cache.contains_key(glyph) {
return Err(RenderError::AtlasFull);
}
}
pass.set_pipeline(&self.atlas.pipeline); pass.set_pipeline(&self.atlas.pipeline);
pass.set_bind_group(0, &self.atlas.bind_group, &[]); pass.set_bind_group(0, &self.atlas.bind_group, &[]);
pass.set_vertex_buffer(0, self.vertex_buffer.slice(..)); pass.set_vertex_buffer(0, self.vertex_buffer.slice(..));

127
src/recently_used.rs Normal file
View file

@ -0,0 +1,127 @@
use std::{
borrow::Borrow,
collections::{hash_map::Entry, HashMap},
hash::Hash,
};
struct RecentlyUsedItem<V> {
entry_idx: usize,
value: V,
}
pub struct RecentlyUsedMap<K: Clone + Copy + Eq + Hash, V> {
keys: Vec<K>,
map: HashMap<K, RecentlyUsedItem<V>>,
}
impl<K: Clone + Copy + Eq + Hash, V> RecentlyUsedMap<K, V> {
pub fn new() -> Self {
Self::with_capacity(0)
}
pub fn with_capacity(capacity: usize) -> Self {
Self {
keys: Vec::with_capacity(capacity),
map: HashMap::with_capacity(capacity),
}
}
pub fn insert(&mut self, key: K, value: V) {
let new_idx = self.keys.len();
match self.map.entry(key) {
Entry::Occupied(mut occupied) => {
let old = occupied.insert(RecentlyUsedItem {
entry_idx: new_idx,
value,
});
let removed = self.keys.remove(old.entry_idx);
self.keys.push(removed);
}
Entry::Vacant(vacant) => {
vacant.insert(RecentlyUsedItem {
entry_idx: new_idx,
value,
});
self.keys.push(key);
}
}
}
pub fn remove<Q: ?Sized>(&mut self, key: &Q)
where
K: Borrow<Q>,
Q: Hash + Eq,
{
if let Some(entry) = self.map.remove(key.borrow()) {
self.keys.remove(entry.entry_idx);
}
}
pub fn get<Q: ?Sized>(&self, k: &Q) -> Option<&V>
where
K: Borrow<Q>,
Q: Hash + Eq,
{
self.map.get(k).map(|item| &item.value)
}
pub fn contains_key<Q: ?Sized>(&self, k: &Q) -> bool
where
K: Borrow<Q>,
Q: Hash + Eq,
{
self.map.contains_key(k)
}
pub fn entries_least_recently_used(&self) -> impl Iterator<Item = (K, &V)> + '_ {
self.keys.iter().map(|k| (*k, &self.map[k].value))
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn insert() {
let mut rus = RecentlyUsedMap::new();
rus.insert("a", ());
rus.insert("b", ());
assert_eq!(
rus.entries_least_recently_used()
.map(|(k, _)| k)
.collect::<String>(),
"ab"
);
}
#[test]
fn reinsert() {
let mut rus = RecentlyUsedMap::new();
rus.insert("a", ());
rus.insert("b", ());
rus.insert("c", ());
rus.insert("a", ());
assert_eq!(
rus.entries_least_recently_used()
.map(|(k, _)| k)
.collect::<String>(),
"bca"
);
}
#[test]
fn remove() {
let mut rus = RecentlyUsedMap::new();
rus.insert("a", ());
rus.insert("b", ());
rus.remove("a");
rus.remove("c");
assert_eq!(
rus.entries_least_recently_used()
.map(|(k, _)| k)
.collect::<String>(),
"b"
);
}
}