From b47f5658496cf787db06cdb46681c36d96bffbf6 Mon Sep 17 00:00:00 2001 From: Cosmic <84875247+Online5277@users.noreply.github.com> Date: Sat, 17 Oct 2026 04:04:25 -0400 Subject: [PATCH] Reclaim unused terrain GPU arena pages --- crates/horizon-client/src/gfx.rs | 2 + crates/horizon-client/src/gfx/arena.rs | 147 +++++++++++++++++++++---- 2 files changed, 128 insertions(+), 21 deletions(-) diff --git a/crates/horizon-client/src/gfx.rs b/crates/horizon-client/src/gfx.rs index 7391ad8b9..6c4b89240 100644 --- a/crates/horizon-client/src/gfx.rs +++ b/crates/horizon-client/src/gfx.rs @@ -2181,6 +2181,8 @@ impl Renderer { ); } pub fn render(&mut self, frame: &Frame) -> Result { + self.arena.trim(); + self.sorted_indices.trim(); if self.suspended { return Ok(false); } diff --git a/crates/horizon-client/src/gfx/arena.rs b/crates/horizon-client/src/gfx/arena.rs index 233333e04..19576204c 100644 --- a/crates/horizon-client/src/gfx/arena.rs +++ b/crates/horizon-client/src/gfx/arena.rs @@ -49,9 +49,10 @@ struct Page { /// Terrain vertices in pages of at most `page_limit` vertices (devices cap /// buffer sizes): a section's vertices sit in one page. pub struct Arena { - pages: Vec, + pages: Vec>, stride: u64, page_limit: u64, + initial_capacity: u64, usage: wgpu::BufferUsages, } @@ -73,13 +74,10 @@ impl Arena { let page_limit = (bytes / stride) / GRAIN * GRAIN; let capacity = capacity.next_multiple_of(GRAIN).min(page_limit); Self { - pages: vec![Page { - buffer: Self::create(device, stride, capacity, usage), - capacity, - free: FreeList::new(capacity), - }], + pages: Vec::new(), stride, page_limit, + initial_capacity: capacity, usage, } } @@ -102,10 +100,13 @@ impl Arena { } /// Bytes of every page's buffer. pub fn bytes(&self) -> u64 { - self.pages.iter().map(|p| p.capacity).sum::() * self.stride + self.pages.iter().flatten().map(|p| p.capacity).sum::() * self.stride } pub fn buffer(&self, page: u32) -> &wgpu::Buffer { - &self.pages[page as usize].buffer + &self.pages[page as usize] + .as_ref() + .expect("live arena page") + .buffer } /// A range of `vertices`: (page, first vertex). Grows the newest page /// (copying its contents on the GPU) or starts a new one when nothing @@ -118,39 +119,62 @@ impl Arena { ) -> (u32, u64) { let len = Self::span(vertices).min(self.page_limit); for (i, page) in self.pages.iter_mut().enumerate() { - if let Some(start) = page.free.take(len) { + if let Some(page) = page + && let Some(start) = page.free.take(len) + { return (i as u32, start); } } - let last = self.pages.len() - 1; - let current = self.pages[last].capacity; - if current < self.page_limit { + let last = self.pages.len().saturating_sub(1); + if let Some(page) = self.pages.last().and_then(Option::as_ref) + && page.capacity < self.page_limit + { + let current = page.capacity; let grown = (current * 2).max(current + len).min(self.page_limit); if grown - current >= len || grown == self.page_limit { self.grow(device, queue, last, grown); - if let Some(start) = self.pages[last].free.take(len) { + if let Some(start) = self.pages[last].as_mut().unwrap().free.take(len) { return (last as u32, start); } } } - let capacity = (1 << 20u64).max(len).min(self.page_limit); + let capacity = if self.pages.is_empty() { + self.initial_capacity + } else { + 1 << 20 + } + .max(len) + .min(self.page_limit); let mut free = FreeList::new(capacity); let start = free.take(len).expect("a new page fits one section"); - self.pages.push(Page { + let page = Page { buffer: Self::create(device, self.stride, capacity, self.usage), capacity, free, - }); - ((self.pages.len() - 1) as u32, start) + }; + let index = self + .pages + .iter() + .position(Option::is_none) + .unwrap_or_else(|| { + self.pages.push(None); + self.pages.len() - 1 + }); + self.pages[index] = Some(page); + (index as u32, start) } pub fn release(&mut self, page: u32, start: u64, vertices: u64) { let len = Self::span(vertices).min(self.page_limit); - self.pages[page as usize].free.give(start, len); + self.pages[page as usize] + .as_mut() + .expect("live arena page") + .free + .give(start, len); } fn grow(&mut self, device: &wgpu::Device, queue: &wgpu::Queue, page: usize, capacity: u64) { let capacity = capacity.next_multiple_of(GRAIN).min(self.page_limit); let buffer = Self::create(device, self.stride, capacity, self.usage); - let old = &mut self.pages[page]; + let old = self.pages[page].as_mut().expect("live arena page"); let mut encoder = device.create_command_encoder(&wgpu::CommandEncoderDescriptor { label: Some("Grow section arena"), }); @@ -162,10 +186,23 @@ impl Arena { old.capacity = capacity; old.free.give(previous, capacity - previous); } - pub fn clear(&mut self) { + /// Reclaim after an upload batch, so replacing a section can reuse its range. + pub fn trim(&mut self) { for page in &mut self.pages { - page.free = FreeList::new(page.capacity); + if let Some(p) = page + && p.free.0.len() == 1 + && p.free.0.get(&0) == Some(&p.capacity) + { + *page = None; + } } + // Keep live page indices stable; later allocations reuse interior holes. + while self.pages.last().is_some_and(Option::is_none) { + self.pages.pop(); + } + } + pub fn clear(&mut self) { + self.pages.clear(); } } @@ -173,6 +210,74 @@ impl Arena { mod tests { use super::*; + fn device() -> Option<(wgpu::Device, wgpu::Queue)> { + let instance = wgpu::Instance::new(wgpu::InstanceDescriptor::new_without_display_handle()); + let adapter = pollster::block_on(instance.request_adapter(&Default::default())).ok()?; + eprintln!("arena GPU regression: {}", adapter.get_info().name); + pollster::block_on(adapter.request_device(&Default::default())).ok() + } + + #[test] + fn empty_pages_are_reclaimed_without_moving_live_ranges() { + let Some((device, queue)) = device() else { + eprintln!("no GPU adapter: skipped"); + return; + }; + let mut arena = Arena::new(&device, 4, GRAIN); + arena.page_limit = 2 * GRAIN; + assert_eq!(arena.bytes(), 0); + let (first, a) = arena.alloc(&device, &queue, GRAIN); + let (_, b) = arena.alloc(&device, &queue, GRAIN); + let (live, c) = arena.alloc(&device, &queue, 2 * GRAIN); + let buffer = arena.buffer(live).clone(); + let data = [1u8, 2, 3, 4]; + queue.write_buffer(&buffer, c * 4, &data); + assert_eq!(arena.bytes(), 4 * GRAIN * 4); + arena.release(first, a, GRAIN); + arena.trim(); + assert_eq!(arena.bytes(), 4 * GRAIN * 4); + arena.release(first, b, GRAIN); + arena.trim(); + assert_eq!(arena.bytes(), 2 * GRAIN * 4); + assert_eq!(arena.buffer(live), &buffer); + let (reused, d) = arena.alloc(&device, &queue, GRAIN); + assert_eq!(reused, first); + + let (tx, rx) = std::sync::mpsc::channel(); + wgpu::util::DownloadBuffer::read_buffer( + &device, + &queue, + &arena.buffer(live).slice(c * 4..c * 4 + 4), + move |result| tx.send(result.unwrap().to_vec()).unwrap(), + ); + device.poll(wgpu::PollType::wait_indefinitely()).unwrap(); + assert_eq!(rx.recv().unwrap(), data); + arena.release(reused, d, GRAIN); + arena.release(live, c, 2 * GRAIN); + arena.trim(); + assert_eq!(arena.bytes(), 0); + assert!(arena.pages.is_empty()); + } + + #[test] + fn clearing_an_arena_releases_buffers_and_can_allocate_again() { + let Some((device, queue)) = device() else { + eprintln!("no GPU adapter: skipped"); + return; + }; + for mut arena in [ + Arena::new(&device, 28, GRAIN), + Arena::indices(&device, GRAIN), + ] { + arena.alloc(&device, &queue, GRAIN); + assert_eq!(arena.bytes(), arena.stride * GRAIN); + arena.clear(); + assert_eq!(arena.bytes(), 0); + assert_eq!(arena.alloc(&device, &queue, GRAIN), (0, 0)); + assert_eq!(arena.bytes(), arena.stride * GRAIN); + } + } + #[test] fn free_ranges_coalesce() { let mut free = FreeList::new(4 * GRAIN);