monolith

public

Star0

Fork 0

Watch0

191 commits 1 branch 0 tags 0 releases1.5 MiB

Commit `e0b486d6097f`

tarball

atagen <boss@atagen.co>2026-10-19 07:56 UTC

6 files changed+204-193

render-vk: move the staging pool into its own module

Shared held a pool of image.rs types, so device.rs and image.rs depended on each other. The pool is now a StagingPool that owns an Arc<Shared> and that the renderer and ShmStager hold, and one destroy path replaces the three copies in Shared::drop, trim_staging and Staging::drop.

Modified file: crates/render-vk/src/device.rs−18 deletions@@ -8,27 +8,10 @@ use std::sync::Mutex;
 /// Fields drop in declaration order, so the allocator frees its memory before
 /// the device is destroyed.
 pub(crate) struct Shared {
-    /// Staging buffers kept for reuse, see `Staging`.
-    pub staging_pool: Mutex<Vec<crate::image::Pooled>>,
     pub allocator: Mutex<Allocator>,
     pub device: Device,
 }
 
-impl Drop for Shared {
-    fn drop(&mut self) {
-        let pool = std::mem::take(
-            self.staging_pool
-                .get_mut()
-                .unwrap_or_else(|e| e.into_inner()),
-        );
-        let allocator = self.allocator.get_mut().unwrap_or_else(|e| e.into_inner());
-        for p in pool {
-            unsafe { self.device.device.destroy_buffer(p.buffer, None) };
-            let _ = allocator.free(p.allocation);
-        }
-    }
-}
-
 /// Loaders for the extensions that dmabuf import, export and fence export
 /// need. Absent when the device lacks any of them.
 pub(crate) struct DmabufExt {
@@ -219,7 +202,6 @@ impl Shared {
             spare_fences: Mutex::new(Vec::new()),
         };
         Ok(Self {
-            staging_pool: Mutex::new(Vec::new()),
             allocator: Mutex::new(allocator?),
             device,
         })

Modified file: crates/render-vk/src/image.rs−163 deletions@@ -9,7 +9,6 @@ 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),
@@ -181,168 +180,6 @@ pub(crate) fn color_range() -> vk::ImageSubresourceRange {
         .layer_count(1)
 }
 
-/// A host-visible buffer for uploads and readbacks. Dropped ones go back to
-/// a pool on `Shared` instead of being freed. Allocating and freeing large
-/// host-visible memory takes a driver lock on NVIDIA that `vkQueueSubmit`
-/// also waits on, so a staging buffer made per upload on the import worker
-/// stalled the main thread's submits for 1 to 3 ms.
-pub(crate) struct Staging {
-    pub shared: Arc<Shared>,
-    pub buffer: vk::Buffer,
-    pub allocation: Option<Allocation>,
-    size: usize,
-    usage: vk::BufferUsageFlags,
-    location: MemoryLocation,
-}
-
-pub(crate) struct Pooled {
-    pub buffer: vk::Buffer,
-    pub allocation: Allocation,
-    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 = 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> = shared
-        .staging_pool
-        .lock()
-        .unwrap_or_else(|e| e.into_inner())
-        .extract_if(.., |p| now - p.returned >= POOL_IDLE)
-        .collect();
-    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(
-        shared: &Arc<Shared>,
-        size: usize,
-        usage: vk::BufferUsageFlags,
-        location: MemoryLocation,
-    ) -> Result<Self, Error> {
-        let reused = {
-            let mut pool = shared
-                .staging_pool
-                .lock()
-                .unwrap_or_else(|e| e.into_inner());
-            let fits = |p: &Pooled| {
-                p.usage == usage && p.location == location && p.size >= size && p.size <= size * 2
-            };
-            pool.iter().position(fits).map(|i| pool.swap_remove(i))
-        };
-        if let Some(p) = reused {
-            return Ok(Self {
-                shared: shared.clone(),
-                buffer: p.buffer,
-                allocation: Some(p.allocation),
-                size: p.size,
-                usage,
-                location,
-            });
-        }
-        let d = &shared.device.device;
-        let buffer = unsafe {
-            d.create_buffer(
-                &vk::BufferCreateInfo::default()
-                    .size(size as u64)
-                    .usage(usage),
-                None,
-            )?
-        };
-        let requirements = unsafe { d.get_buffer_memory_requirements(buffer) };
-        let allocation = shared
-            .allocator
-            .lock()
-            .unwrap_or_else(|e| e.into_inner())
-            .allocate(&AllocationCreateDesc {
-                name: "staging",
-                requirements,
-                location,
-                linear: true,
-                allocation_scheme: AllocationScheme::GpuAllocatorManaged,
-            });
-        let allocation = match allocation {
-            Ok(a) => a,
-            Err(e) => {
-                unsafe { d.destroy_buffer(buffer, None) };
-                return Err(e.into());
-            }
-        };
-        unsafe { d.bind_buffer_memory(buffer, allocation.memory(), allocation.offset())? };
-        Ok(Self {
-            shared: shared.clone(),
-            buffer,
-            allocation: Some(allocation),
-            size,
-            usage,
-            location,
-        })
-    }
-
-    pub fn bytes(&self) -> &[u8] {
-        self.allocation
-            .as_ref()
-            .and_then(|a| a.mapped_slice())
-            .unwrap_or(&[])
-    }
-
-    pub fn bytes_mut(&mut self) -> &mut [u8] {
-        self.allocation
-            .as_mut()
-            .and_then(|a| a.mapped_slice_mut())
-            .unwrap_or(&mut [])
-    }
-}
-
-impl Drop for Staging {
-    fn drop(&mut self) {
-        let Some(allocation) = self.allocation.take() else {
-            return;
-        };
-        let mut pool = self
-            .shared
-            .staging_pool
-            .lock()
-            .unwrap_or_else(|e| e.into_inner());
-        let pooled: usize = pool.iter().map(|p| p.size).sum();
-        if pooled + self.size <= POOL_BYTES {
-            pool.push(Pooled {
-                buffer: self.buffer,
-                allocation,
-                size: self.size,
-                usage: self.usage,
-                location: self.location,
-                returned: Instant::now(),
-            });
-            return;
-        }
-        drop(pool);
-        unsafe { self.shared.device.device.destroy_buffer(self.buffer, None) };
-        let _ = self
-            .shared
-            .allocator
-            .lock()
-            .unwrap_or_else(|e| e.into_inner())
-            .free(allocation);
-    }
-}
-
 /// A sampled texture.
 #[derive(Clone, Debug)]
 pub struct VulkanTexture(pub(crate) Arc<ImageInner>);

Modified file: crates/render-vk/src/lib.rs+1

@@ -18,6 +18,7 @@ mod frame;

1818 mod image;

1919 mod pipeline;

2020 mod renderer;

21+mod staging;

2122 mod sync;

2223 mod transform;

2324

Modified file: crates/render-vk/src/renderer/mod.rs+7 additions−4 deletions@@ -10,8 +10,9 @@ use crate::device::Shared;
 use crate::dmabuf::{self, DmabufCaps, RENDER_USAGE, SAMPLE_USAGE, VulkanAllocator};
 use crate::format::{BYTES_PER_PIXEL, SUPPORTED};
 use crate::frame::{Op, VulkanFrame};
-use crate::image::{ImageInner, Staging, VulkanImage, VulkanMapping, VulkanTarget, VulkanTexture};
+use crate::image::{ImageInner, VulkanImage, VulkanMapping, VulkanTarget, VulkanTexture};
 use crate::pipeline::Pipelines;
+use crate::staging::{Staging, StagingPool};
 use crate::sync::{FenceInner, VkFence};
 use ash::vk;
 use gpu_allocator::MemoryLocation;
@@ -55,6 +56,7 @@ pub struct VulkanRenderer {
     debug: DebugFlags,
     context: ContextId<VulkanTexture>,
     caps: Arc<DmabufCaps>,
+    staging_pool: Arc<StagingPool>,
     shared: Arc<Shared>,
     submissions: Cell<u64>,
     /// Shm uploads staged off the main thread, by buffer.
@@ -130,6 +132,7 @@ impl VulkanRenderer {
             debug: DebugFlags::empty(),
             context: ContextId::new(),
             caps: Arc::new(DmabufCaps::query(&shared)),
+            staging_pool: StagingPool::new(&shared),
             shared,
         })
     }
@@ -187,7 +190,7 @@ 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);
+        self.staging_pool.trim();
     }
 
     fn begin(&mut self) -> Result<vk::CommandBuffer, Error> {
@@ -467,7 +470,7 @@ impl VulkanRenderer {
         if region.size.w <= 0 || region.size.h <= 0 {
             return Ok(());
         }
-        let staging = stage_rows(&self.shared, region, row)?;
+        let staging = stage_rows(&self.staging_pool, region, row)?;
         self.copy_staged(image, region, staging)
     }
 
@@ -541,7 +544,7 @@ impl VulkanRenderer {
         let swap = needs_swizzle(image.fourcc, fourcc)?;
         let len = (w as usize * h as usize * BYTES_PER_PIXEL).max(BYTES_PER_PIXEL);
         let staging = Staging::new(
-            &self.shared,
+            &self.staging_pool,
             len,
             vk::BufferUsageFlags::TRANSFER_DST,
             MemoryLocation::GpuToCpu,

Modified file: crates/render-vk/src/renderer/shm.rs+8 additions−8 deletions@@ -1,8 +1,8 @@
 use super::VulkanRenderer;
 use crate::Error;
-use crate::device::Shared;
 use crate::format::BYTES_PER_PIXEL;
-use crate::image::{ImageInner, Staging, VulkanTexture};
+use crate::image::{ImageInner, VulkanTexture};
+use crate::staging::{Staging, StagingPool};
 use ash::vk;
 use gpu_allocator::MemoryLocation;
 use smithay::backend::allocator::Fourcc;
@@ -100,14 +100,14 @@ struct ShmCache(Mutex<Option<VulkanTexture>>);
 
 /// Copies `region` of a full-image `row` source into new staging memory.
 pub(super) fn stage_rows<'a>(
-    shared: &Arc<Shared>,
+    pool: &Arc<StagingPool>,
     region: Rectangle<i32, Buffer>,
     row: impl Fn(usize) -> &'a [u8],
 ) -> Result<Staging, Error> {
     let (w, h) = (region.size.w as usize, region.size.h as usize);
     let line = w * BYTES_PER_PIXEL;
     let mut staging = Staging::new(
-        shared,
+        pool,
         line * h,
         vk::BufferUsageFlags::TRANSFER_SRC,
         MemoryLocation::CpuToGpu,
@@ -132,7 +132,7 @@ pub struct StagedShm {
 /// it came from takes the result back with `adopt_staged`.
 #[derive(Clone)]
 pub struct ShmStager {
-    shared: Arc<Shared>,
+    staging_pool: Arc<StagingPool>,
 }
 
 impl ShmStager {
@@ -161,7 +161,7 @@ impl ShmStager {
             let rw = region.size.w as usize * BYTES_PER_PIXEL;
             // SAFETY: the bounds check above keeps every row inside the
             // `len` bytes smithay mapped at `ptr`.
-            let staging = stage_rows(&self.shared, region, |y| unsafe {
+            let staging = stage_rows(&self.staging_pool, region, |y| unsafe {
                 std::slice::from_raw_parts(ptr.add(offset + y * stride + x), rw)
             })?;
             Ok(StagedShm {
@@ -178,13 +178,13 @@ impl ShmStager {
 impl VulkanRenderer {
     pub fn shm_stager(&self) -> ShmStager {
         ShmStager {
-            shared: self.shared.clone(),
+            staging_pool: self.staging_pool.clone(),
         }
     }
 
     /// Hands back pixels a stager copied, used by the next import of `buffer`.
     pub fn adopt_staged(&mut self, buffer: &WlBuffer, staged: StagedShm) {
-        if Arc::ptr_eq(&staged.staging.shared, &self.shared) {
+        if Arc::ptr_eq(&staged.staging.pool, &self.staging_pool) {
             self.staged.insert(buffer.id(), (buffer.clone(), staged));
         }
     }

Added file: crates/render-vk/src/staging.rs+188 additions@@ -0,0 +1,188 @@
+use crate::Error;
+use crate::device::Shared;
+use ash::vk;
+use gpu_allocator::MemoryLocation;
+use gpu_allocator::vulkan::{Allocation, AllocationCreateDesc, AllocationScheme};
+use std::sync::{Arc, Mutex};
+use std::time::{Duration, Instant};
+
+/// Pooled staging memory kept at most, past which dropped buffers are freed.
+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);
+
+struct Pooled {
+    buffer: vk::Buffer,
+    allocation: Allocation,
+    size: usize,
+    usage: vk::BufferUsageFlags,
+    location: MemoryLocation,
+    returned: Instant,
+}
+
+/// Staging buffers kept for reuse, see [`Staging`].
+pub(crate) struct StagingPool {
+    shared: Arc<Shared>,
+    free: Mutex<Vec<Pooled>>,
+}
+
+impl StagingPool {
+    pub fn new(shared: &Arc<Shared>) -> Arc<Self> {
+        Arc::new(Self {
+            shared: shared.clone(),
+            free: Mutex::new(Vec::new()),
+        })
+    }
+
+    /// Frees pooled buffers that have sat unused for [`POOL_IDLE`].
+    pub fn trim(&self) {
+        let now = Instant::now();
+        let expired: Vec<Pooled> = self
+            .free
+            .lock()
+            .unwrap_or_else(|e| e.into_inner())
+            .extract_if(.., |p| now - p.returned >= POOL_IDLE)
+            .collect();
+        self.destroy(expired.into_iter().map(|p| (p.buffer, p.allocation)));
+    }
+
+    fn destroy(&self, buffers: impl IntoIterator<Item = (vk::Buffer, Allocation)>) {
+        let mut buffers = buffers.into_iter().peekable();
+        if buffers.peek().is_none() {
+            return;
+        }
+        let mut allocator = self
+            .shared
+            .allocator
+            .lock()
+            .unwrap_or_else(|e| e.into_inner());
+        for (buffer, allocation) in buffers {
+            unsafe { self.shared.device.device.destroy_buffer(buffer, None) };
+            let _ = allocator.free(allocation);
+        }
+    }
+}
+
+impl Drop for StagingPool {
+    fn drop(&mut self) {
+        let free = std::mem::take(self.free.get_mut().unwrap_or_else(|e| e.into_inner()));
+        self.destroy(free.into_iter().map(|p| (p.buffer, p.allocation)));
+    }
+}
+
+/// A host-visible buffer for uploads and readbacks. Dropped ones go back to
+/// a pool instead of being freed. Allocating and freeing large host-visible
+/// memory takes a driver lock on NVIDIA that `vkQueueSubmit` also waits on,
+/// so a staging buffer made per upload on the import worker stalled the main
+/// thread's submits for 1 to 3 ms.
+pub(crate) struct Staging {
+    pub pool: Arc<StagingPool>,
+    pub buffer: vk::Buffer,
+    allocation: Option<Allocation>,
+    size: usize,
+    usage: vk::BufferUsageFlags,
+    location: MemoryLocation,
+}
+
+impl Staging {
+    pub fn new(
+        pool: &Arc<StagingPool>,
+        size: usize,
+        usage: vk::BufferUsageFlags,
+        location: MemoryLocation,
+    ) -> Result<Self, Error> {
+        let reused = {
+            let mut free = pool.free.lock().unwrap_or_else(|e| e.into_inner());
+            let fits = |p: &Pooled| {
+                p.usage == usage && p.location == location && p.size >= size && p.size <= size * 2
+            };
+            free.iter().position(fits).map(|i| free.swap_remove(i))
+        };
+        if let Some(p) = reused {
+            return Ok(Self {
+                pool: pool.clone(),
+                buffer: p.buffer,
+                allocation: Some(p.allocation),
+                size: p.size,
+                usage,
+                location,
+            });
+        }
+        let d = &pool.shared.device.device;
+        let buffer = unsafe {
+            d.create_buffer(
+                &vk::BufferCreateInfo::default()
+                    .size(size as u64)
+                    .usage(usage),
+                None,
+            )?
+        };
+        let requirements = unsafe { d.get_buffer_memory_requirements(buffer) };
+        let allocation = pool
+            .shared
+            .allocator
+            .lock()
+            .unwrap_or_else(|e| e.into_inner())
+            .allocate(&AllocationCreateDesc {
+                name: "staging",
+                requirements,
+                location,
+                linear: true,
+                allocation_scheme: AllocationScheme::GpuAllocatorManaged,
+            });
+        let allocation = match allocation {
+            Ok(a) => a,
+            Err(e) => {
+                unsafe { d.destroy_buffer(buffer, None) };
+                return Err(e.into());
+            }
+        };
+        unsafe { d.bind_buffer_memory(buffer, allocation.memory(), allocation.offset())? };
+        Ok(Self {
+            pool: pool.clone(),
+            buffer,
+            allocation: Some(allocation),
+            size,
+            usage,
+            location,
+        })
+    }
+
+    pub fn bytes(&self) -> &[u8] {
+        self.allocation
+            .as_ref()
+            .and_then(|a| a.mapped_slice())
+            .unwrap_or(&[])
+    }
+
+    pub fn bytes_mut(&mut self) -> &mut [u8] {
+        self.allocation
+            .as_mut()
+            .and_then(|a| a.mapped_slice_mut())
+            .unwrap_or(&mut [])
+    }
+}
+
+impl Drop for Staging {
+    fn drop(&mut self) {
+        let Some(allocation) = self.allocation.take() else {
+            return;
+        };
+        let mut free = self.pool.free.lock().unwrap_or_else(|e| e.into_inner());
+        let pooled: usize = free.iter().map(|p| p.size).sum();
+        if pooled + self.size <= POOL_BYTES {
+            free.push(Pooled {
+                buffer: self.buffer,
+                allocation,
+                size: self.size,
+                usage: self.usage,
+                location: self.location,
+                returned: Instant::now(),
+            });
+            return;
+        }
+        drop(free);
+        self.pool.destroy([(self.buffer, allocation)]);
+    }
+}

monolith

Commit e0b486d6097f

Commit `e0b486d6097f`