monolith

public

Star0

Fork 0

Watch0

142 commits 1 branch 0 tags 0 releases1.5 MiB

Commit `cacda79c0faa`

tarball

atagen <boss@atagen.co>2026-10-19 06:11 UTC

4 files changed+40-2

render-vk: give idle staging memory back

Pooled staging buffers lived until renderer drop and the pool held up to 96 MB, all host-visible and so resident. Under the default 64 MB host blocks gpu-allocator also kept an idle block per memory type. Buffers now expire after two seconds unused, with reaping driven from after_dispatch so an idle compositor still releases them, and 4 MB host blocks give large uploads their own block that is freed with them.

Modified file: crates/monolith/src/state.rs+2 additions@@ -6,6 +6,7 @@ use crate::wm::{Kind, Wm, configure};
 use monolith_config::Config;
 use monolith_layout::{Layout, OutputId, Rect, WindowId};
 use monolith_render_vk::VulkanRenderer;
+use smithay::backend::renderer::Renderer;
 use smithay::desktop::utils::under_from_surface_tree;
 use smithay::desktop::{Window, WindowSurfaceType};
 use smithay::input::keyboard::{Keycode, XkbConfig};
@@ -212,6 +213,7 @@ impl State {
             crate::backend::Backend::Starting => {}
         }
         self.wm.prune(now_ns());
+        let _ = self.renderer.cleanup_texture_cache();
         self.confirm_lock();
         self.complete_captures();
         if std::mem::take(&mut self.dirty.snapshot) {

Modified file: crates/render-vk/src/device.rs+4 additions−1 deletions@@ -1,5 +1,6 @@
 use crate::Error;
 use ash::vk;
+use gpu_allocator::AllocationSizes;
 use gpu_allocator::vulkan::{Allocator, AllocatorCreateDesc};
 use std::sync::Mutex;
 
@@ -200,7 +201,9 @@ impl Shared {
             physical_device: physical,
             debug_settings: Default::default(),
             buffer_device_address: false,
-            allocation_sizes: Default::default(),
+            // Host blocks are pinned system RAM that stays resident while any
+            // allocation lives in them, and the default 64 MB block is mostly idle.
+            allocation_sizes: AllocationSizes::new(256 << 20, 4 << 20),
         });
         let device = Device {
             _entry: entry,

Modified file: crates/render-vk/src/image.rs+31 additions−1 deletions@@ -9,6 +9,7 @@ use smithay::backend::renderer::{Texture, TextureMapping};
 use std::fmt;
 use std::marker::PhantomData;
 use std::sync::{Arc, Mutex};
+use std::time::{Duration, Instant};
 
 pub(crate) enum Memory {
     Allocated(Allocation),
@@ -200,10 +201,38 @@ pub(crate) struct Pooled {
     size: usize,
     usage: vk::BufferUsageFlags,
     location: MemoryLocation,
+    returned: Instant,
 }
 
 /// Pooled staging memory kept at most, past which dropped buffers are freed.
-const POOL_BYTES: usize = 96 * 1024 * 1024;
+const POOL_BYTES: usize = 32 * 1024 * 1024;
+
+/// How long a pooled buffer may go unused before it is freed.
+const POOL_IDLE: Duration = Duration::from_secs(2);
+
+/// Frees pooled staging buffers that have sat unused for [`POOL_IDLE`].
+pub(crate) fn trim_staging(shared: &Shared) {
+    let now = Instant::now();
+    let expired: Vec<Pooled> = {
+        let mut pool = shared
+            .staging_pool
+            .lock()
+            .unwrap_or_else(|e| e.into_inner());
+        let (stale, kept) = std::mem::take(&mut *pool)
+            .into_iter()
+            .partition(|p| now - p.returned >= POOL_IDLE);
+        *pool = kept;
+        stale
+    };
+    if expired.is_empty() {
+        return;
+    }
+    let mut allocator = shared.allocator.lock().unwrap_or_else(|e| e.into_inner());
+    for p in expired {
+        unsafe { shared.device.device.destroy_buffer(p.buffer, None) };
+        let _ = allocator.free(p.allocation);
+    }
+}
 
 impl Staging {
     pub fn new(
@@ -304,6 +333,7 @@ impl Drop for Staging {
                 size: self.size,
                 usage: self.usage,
                 location: self.location,
+                returned: Instant::now(),
             });
             return;
         }

Modified file: crates/render-vk/src/renderer/mod.rs+3 additions@@ -23,6 +23,7 @@ use smithay::backend::renderer::{
     Bind, ContextId, DebugFlags, ExportMem, ImportDma, ImportDmaWl, ImportMem, Offscreen, Renderer,
     RendererSuper, Texture, TextureFilter,
 };
+use smithay::reexports::wayland_server::Resource;
 use smithay::reexports::wayland_server::backend::ObjectId;
 use smithay::reexports::wayland_server::protocol::wl_buffer::WlBuffer;
 use smithay::utils::{Buffer, Physical, Rectangle, Size, Transform};
@@ -185,6 +186,8 @@ impl VulkanRenderer {
         });
         self.dmabuf_textures.retain(|k, _| !k.is_gone());
         self.dmabuf_targets.retain(|k, _| !k.is_gone());
+        self.staged.retain(|_, (b, _)| b.is_alive());
+        crate::image::trim_staging(&self.shared);
     }
 
     fn begin(&mut self) -> Result<vk::CommandBuffer, Error> {

monolith

Commit cacda79c0faa

Commit `cacda79c0faa`