monolith

public

Star0

Fork 0

Watch0

84 commits 1 branch 0 tags 0 releases1.5 MiB

Commit `0f11410be91b`

tarball

atagen <boss@atagen.co>2026-10-17 04:03 UTC

5 files changed+264-42

monolith: copy large shm damage on the import worker

The spans log showed shm uploads of 1 to 3.5 ms inside the commit handler on the main thread, and the frames missed without a slow render each followed one: the render timer fired late. A commit whose damage is over 512 KiB now waits on a blocker while the worker copies those rows into staging memory, and the import only records the GPU copy. The client may not touch a committed buffer until it is released, so reading it before the commit applies is safe. Smaller damage stays inline, where the round trip would cost more than the copy.

Modified file: crates/monolith/src/handlers.rs+43 additions−2 deletions@@ -15,7 +15,7 @@ use smithay::reexports::wayland_server::{Client, Resource};
 use smithay::utils::Serial;
 use smithay::wayland::buffer::BufferHandler;
 use smithay::wayland::compositor::{
-    BufferAssignment, CompositorClientState, CompositorHandler, CompositorState,
+    BufferAssignment, CompositorClientState, CompositorHandler, CompositorState, Damage,
     SurfaceAttributes, add_blocker, add_pre_commit_hook, get_parent, is_sync_subsurface,
     with_states,
 };
@@ -38,7 +38,8 @@ use smithay::wayland::shell::xdg::{
     PopupSurface, PositionerState, ToplevelSurface, XdgShellHandler, XdgShellState,
 };
 use monolith_protocols::workspace::{Action, WorkspaceHandler, WorkspaceState};
-use smithay::wayland::shm::{ShmHandler, ShmState};
+use smithay::utils::{Rectangle, Transform};
+use smithay::wayland::shm::{ShmHandler, ShmState, with_buffer_contents};
 
 impl CompositorHandler for State {
     fn compositor_state(&mut self) -> &mut CompositorState {
@@ -294,6 +295,7 @@ impl DrmSyncobjHandler for State {
 /// stalling on the client's GPU work: until its explicit acquire point
 /// signals, or for implicitly synced buffers until their writes finish.
 fn hold_until_readable(state: &mut State, surface: &WlSurface) {
+    stage_shm(state, surface);
     let (acquire, dmabuf) = with_states(surface, |s| {
         let acquire = s
             .cached_state
@@ -348,6 +350,45 @@ fn hold_until_readable(state: &mut State, surface: &WlSurface) {
     }
 }
 
+/// Copies a committed shm buffer's damage on the worker, holding the commit
+/// until it is staged. Surface damage equals buffer damage at scale 1 with no
+/// transform, otherwise the whole buffer is staged so it covers whatever the
+/// import uploads.
+fn stage_shm(state: &mut State, surface: &WlSurface) {
+    let job = with_states(surface, |s| {
+        let mut cached = s.cached_state.get::<SurfaceAttributes>();
+        let attrs = cached.pending();
+        let Some(BufferAssignment::NewBuffer(buffer)) = attrs.buffer.as_ref() else {
+            return None;
+        };
+        if get_dmabuf(buffer).is_ok() {
+            return None;
+        }
+        let plain = attrs.buffer_scale == 1 && attrs.buffer_transform == Transform::Normal.into();
+        let region = attrs
+            .damage
+            .iter()
+            .map(|d| match d {
+                Damage::Buffer(r) => *r,
+                Damage::Surface(r) => {
+                    Rectangle::new((r.loc.x, r.loc.y).into(), (r.size.w, r.size.h).into())
+                }
+            })
+            .reduce(|a, b| a.merge(b))
+            .filter(|_| plain);
+        Some((buffer.clone(), region))
+    });
+    let (Some((buffer, region)), Some(client)) = (job, surface.client()) else {
+        return;
+    };
+    let Ok(size) = with_buffer_contents(&buffer, |_, _, d| (d.width, d.height)) else {
+        return;
+    };
+    if let Some(blocker) = state.stage_blocker(&buffer, region, size, client) {
+        add_blocker(surface, blocker);
+    }
+}
+
 impl XdgDecorationHandler for State {
     fn new_decoration(&mut self, toplevel: ToplevelSurface) {
         server_side(&toplevel);

Modified file: crates/monolith/src/import.rs+94 additions−24 deletions@@ -1,14 +1,18 @@
-//! Dmabuf imports on a worker thread. A first import takes 15 to 27 ms on
-//! NVIDIA, which on the main thread drops frames. Buffer creation answers
-//! once the import is done, and commits of buffers still importing wait on
-//! a blocker.
+//! Buffer work on a worker thread. A first dmabuf import takes 15 to 27 ms
+//! on NVIDIA, and copying a large shm damage takes 1 to 3.5 ms, either of
+//! which on the main thread makes frames miss. Buffer creation answers once
+//! an import is done, and commits wait on a blocker until their buffer is
+//! ready.
 
 use crate::state::State;
-use monolith_render_vk::{DmabufImporter, VulkanTexture};
+use monolith_render_vk::{DmabufImporter, ShmStager, StagedShm, VulkanTexture};
 use smithay::backend::allocator::dmabuf::{Dmabuf, WeakDmabuf};
 use smithay::reexports::calloop::LoopHandle;
 use smithay::reexports::calloop::channel::{Event, channel};
-use smithay::reexports::wayland_server::Client;
+use smithay::reexports::wayland_server::backend::ObjectId;
+use smithay::reexports::wayland_server::protocol::wl_buffer::WlBuffer;
+use smithay::reexports::wayland_server::{Client, Resource};
+use smithay::utils::{Buffer, Rectangle};
 use smithay::wayland::compositor::{Blocker, BlockerState, CompositorHandler};
 use smithay::wayland::dmabuf::ImportNotifier;
 use std::collections::HashMap;
@@ -16,9 +20,14 @@ use std::sync::Arc;
 use std::sync::atomic::{AtomicBool, Ordering};
 use std::sync::mpsc;
 
+/// Below this many damaged bytes a copy is cheaper than the round trip to
+/// the worker and back.
+const OFFLOAD_BYTES: i64 = 512 * 1024;
+
 pub struct Imports {
-    jobs: mpsc::Sender<Dmabuf>,
-    waiting: HashMap<WeakDmabuf, Waiters>,
+    jobs: mpsc::Sender<Job>,
+    dmabufs: HashMap<WeakDmabuf, Waiters>,
+    shm: HashMap<ObjectId, Waiters>,
 }
 
 #[derive(Default)]
@@ -40,42 +49,61 @@ impl Blocker for ImportBlocker {
     }
 }
 
-type Done = (Dmabuf, Result<VulkanTexture, String>);
+enum Job {
+    Dmabuf(Dmabuf),
+    Shm(WlBuffer, Option<Rectangle<i32, Buffer>>),
+}
+
+enum Done {
+    Dmabuf(Dmabuf, Result<VulkanTexture, String>),
+    Shm(WlBuffer, Result<StagedShm, String>),
+}
 
 impl Imports {
     pub fn new(
         handle: &LoopHandle<'static, State>,
         importer: DmabufImporter,
+        stager: ShmStager,
     ) -> std::io::Result<Self> {
         let (done, results) = channel::<Done>();
-        let (jobs, queue) = mpsc::channel::<Dmabuf>();
+        let (jobs, queue) = mpsc::channel::<Job>();
         std::thread::Builder::new()
-            .name("dmabuf-import".into())
+            .name("buffer-import".into())
             .spawn(move || {
-                for buffer in queue {
-                    let result = importer.import(&buffer).map_err(|e| e.to_string());
-                    if done.send((buffer, result)).is_err() {
+                for job in queue {
+                    let result = match job {
+                        Job::Dmabuf(b) => {
+                            let r = importer.import(&b).map_err(|e| e.to_string());
+                            Done::Dmabuf(b, r)
+                        }
+                        Job::Shm(b, region) => {
+                            let r = stager.stage(&b, region).map_err(|e| e.to_string());
+                            Done::Shm(b, r)
+                        }
+                    };
+                    if done.send(result).is_err() {
                         break;
                     }
                 }
             })?;
         handle
-            .insert_source(results, |event, _, state| {
-                if let Event::Msg((buffer, result)) = event {
-                    state.imported(buffer, result);
-                }
+            .insert_source(results, |event, _, state| match event {
+                Event::Msg(Done::Dmabuf(buffer, result)) => state.imported(buffer, result),
+                Event::Msg(Done::Shm(buffer, result)) => state.staged(buffer, result),
+                Event::Closed => {}
             })
             .map_err(|e| std::io::Error::other(e.to_string()))?;
         Ok(Self {
             jobs,
-            waiting: HashMap::new(),
+            dmabufs: HashMap::new(),
+            shm: HashMap::new(),
         })
     }
 
     fn start(&mut self, buffer: &Dmabuf) -> &mut Waiters {
         let jobs = &self.jobs;
-        self.waiting.entry(buffer.weak()).or_insert_with(|| {
-            let _ = jobs.send(buffer.clone());
+        self.dmabufs.entry(buffer.weak()).or_insert_with(|| {
+            let _ = jobs.send(Job::Dmabuf(buffer.clone()));
             Waiters::default()
         })
     }
@@ -101,8 +129,33 @@ impl State {
         Some(ImportBlocker(waiters.done.clone()))
     }
 
+    /// A blocker for a commit of an shm buffer with enough damage to copy on
+    /// the worker. `region` is the damage, `None` for all of it.
+    pub fn stage_blocker(
+        &mut self,
+        buffer: &WlBuffer,
+        region: Option<Rectangle<i32, Buffer>>,
+        size: (i32, i32),
+        client: Client,
+    ) -> Option<ImportBlocker> {
+        let area = region.map_or(i64::from(size.0) * i64::from(size.1), |r| {
+            i64::from(r.size.w) * i64::from(r.size.h)
+        });
+        if area * 4 < OFFLOAD_BYTES {
+            return None;
+        }
+        let imports = &mut self.services.imports;
+        let jobs = &imports.jobs;
+        let waiters = imports.shm.entry(buffer.id()).or_insert_with(|| {
+            let _ = jobs.send(Job::Shm(buffer.clone(), region));
+            Waiters::default()
+        });
+        waiters.clients.push(client);
+        Some(ImportBlocker(waiters.done.clone()))
+    }
+
     fn imported(&mut self, buffer: Dmabuf, result: Result<VulkanTexture, String>) {
-        let Some(waiters) = self.services.imports.waiting.remove(&buffer.weak()) else {
+        let Some(mut waiters) = self.services.imports.dmabufs.remove(&buffer.weak()) else {
             return;
         };
         let result = result.and_then(|t| {
@@ -110,19 +163,36 @@ impl State {
                 .adopt_dmabuf(&buffer, t)
                 .map_err(|e| e.to_string())
         });
+        let notifiers = std::mem::take(&mut waiters.notifiers);
         match result {
             Ok(()) => {
-                for n in waiters.notifiers {
+                for n in notifiers {
                     let _ = n.successful::<State>();
                 }
             }
             Err(e) => {
                 tracing::warn!("dmabuf import failed: {e}");
-                for n in waiters.notifiers {
+                for n in notifiers {
                     n.failed();
                 }
             }
         }
+        self.release(waiters);
+    }
+
+    /// A failed copy only costs the import doing it on the main thread.
+    fn staged(&mut self, buffer: WlBuffer, result: Result<StagedShm, String>) {
+        let Some(waiters) = self.services.imports.shm.remove(&buffer.id()) else {
+            return;
+        };
+        match result {
+            Ok(staged) => self.renderer.adopt_staged(&buffer, staged),
+            Err(e) => tracing::debug!("staging an shm buffer failed: {e}"),
+        }
+        self.release(waiters);
+    }
+
+    fn release(&mut self, waiters: Waiters) {
         waiters.done.store(true, Ordering::Release);
         let dh = self.core.display.clone();
         for client in waiters.clients {

Modified file: crates/monolith/src/state.rs+5 additions−1 deletions@@ -142,7 +142,11 @@ impl State {
         let mut layout = Layout::default();
         layout.gaps = gaps(&config);
         let animation = config.animation.clone();
-        let imports = crate::import::Imports::new(&handle, renderer.dmabuf_importer())?;
+        let imports = crate::import::Imports::new(
+            &handle,
+            renderer.dmabuf_importer(),
+            renderer.shm_stager(),
+        )?;
         let idle = crate::idle::Idle::new(&dh, handle.clone());
         Ok(Self {
             protocols: Protocols::new(&dh, &renderer),

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

@@ -18,4 +18,4 @@ pub use dmabuf::VulkanAllocator;

1818 pub use error::Error;

1919 pub use frame::{Effect, Transition, VulkanFrame};

2020 pub use image::{VulkanImage, VulkanMapping, VulkanTarget, VulkanTexture};

21-pub use renderer::{DmabufImporter, VulkanRenderer};

21+pub use renderer::{DmabufImporter, ShmStager, StagedShm, VulkanRenderer};

Modified file: crates/render-vk/src/renderer.rs+121 additions−14 deletions@@ -19,6 +19,8 @@ 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};
 use smithay::wayland::compositor::SurfaceData;
@@ -53,6 +55,8 @@ pub struct VulkanRenderer {
     caps: Arc<DmabufCaps>,
     shared: Arc<Shared>,
     submissions: Cell<u64>,
+    /// Shm uploads staged off the main thread, by buffer.
+    staged: HashMap<ObjectId, (WlBuffer, StagedShm)>,
     stall: Cell<StallPhase>,
 }
 
@@ -149,6 +153,7 @@ impl VulkanRenderer {
             pool,
             spare_cmds: Vec::new(),
             submissions: Cell::new(0),
+            staged: HashMap::new(),
             stall: Cell::new(StallPhase {
                 // Measured on an RTX 3060, see research/nvidia.md.
                 phase: shared.device.name.contains("NVIDIA").then_some(1015),
@@ -513,21 +518,21 @@ impl VulkanRenderer {
             return Err(Error::ForeignTexture);
         }
         self.reap();
-        let (w, h) = (region.size.w as usize, region.size.h as usize);
-        if w == 0 || h == 0 {
+        if region.size.w <= 0 || region.size.h <= 0 {
             return Ok(());
         }
-        let line = w * BYTES_PER_PIXEL;
-        let mut staging = Staging::new(
-            &self.shared,
-            line * h,
-            vk::BufferUsageFlags::TRANSFER_SRC,
-            MemoryLocation::CpuToGpu,
-        )?;
-        let dst = staging.bytes_mut();
-        for i in 0..h {
-            dst[i * line..(i + 1) * line].copy_from_slice(row(region.loc.y as usize + i));
-        }
+        let staging = stage_rows(&self.shared, region, row)?;
+        self.copy_staged(image, region, staging)
+    }
+
+    /// Copies staged pixels into `region` of `image` on the GPU.
+    fn copy_staged(
+        &mut self,
+        image: &Arc<ImageInner>,
+        region: Rectangle<i32, Buffer>,
+        staging: Staging,
+    ) -> Result<(), Error> {
+        let (w, h) = (region.size.w as usize, region.size.h as usize);
         let copy = vk::BufferImageCopy::default()
             .buffer_row_length(w as u32)
             .image_subresource(
@@ -1050,6 +1055,8 @@ impl ImportMemWl for VulkanRenderer {
         surface: Option<&SurfaceData>,
         damage: &[Rectangle<i32, Buffer>],
     ) -> Result<VulkanTexture, Error> {
+        self.staged.retain(|_, (b, _)| b.is_alive());
+        let staged = self.staged.remove(&buffer.id()).map(|(_, s)| s);
         let cache = surface.map(|s| {
             s.data_map
                 .insert_if_missing_threadsafe(|| ShmCache(Mutex::new(None)));
@@ -1093,7 +1100,15 @@ impl ImportMemWl for VulkanRenderer {
                     (VulkanTexture(image), Some(full))
                 }
             };
-            if let Some(region) = region {
+            let staged = staged.filter(|s| {
+                s.fourcc == fourcc
+                    && s.size == size
+                    && region.is_some_and(|r| s.region.contains_rect(r))
+            });
+            if let Some(s) = staged {
+                tracing::trace!(region = ?s.region, "uploading a staged shm copy");
+                self.copy_staged(&texture.0, s.region, s.staging)?;
+            } else if let Some(region) = region {
                 let x = region.loc.x as usize * BYTES_PER_PIXEL;
                 let rw = region.size.w as usize * BYTES_PER_PIXEL;
                 self.upload_with(&texture.0, region, |y| unsafe {
@@ -1111,3 +1126,95 @@ impl ImportMemWl for VulkanRenderer {
 
 /// The texture last imported for a surface's shm buffers.
 struct ShmCache(Mutex<Option<VulkanTexture>>);
+
+/// Copies `region` of a full-image `row` source into new staging memory.
+fn stage_rows<'a>(
+    shared: &Arc<Shared>,
+    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,
+        line * h,
+        vk::BufferUsageFlags::TRANSFER_SRC,
+        MemoryLocation::CpuToGpu,
+    )?;
+    let dst = staging.bytes_mut();
+    for i in 0..h {
+        dst[i * line..(i + 1) * line].copy_from_slice(row(region.loc.y as usize + i));
+    }
+    Ok(staging)
+}
+
+/// Shm pixels copied off the main thread, waiting for the import of the
+/// commit that shows them.
+pub struct StagedShm {
+    staging: Staging,
+    region: Rectangle<i32, Buffer>,
+    fourcc: Fourcc,
+    size: Size<i32, Buffer>,
+}
+
+/// Copies shm buffers into staging memory on another thread. The renderer
+/// it came from takes the result back with `adopt_staged`.
+#[derive(Clone)]
+pub struct ShmStager {
+    shared: Arc<Shared>,
+}
+
+impl ShmStager {
+    /// Stages `region` of `buffer`, all of it when the region is `None`.
+    pub fn stage(
+        &self,
+        buffer: &WlBuffer,
+        region: Option<Rectangle<i32, Buffer>>,
+    ) -> Result<StagedShm, Error> {
+        with_buffer_contents(buffer, |ptr, len, data| {
+            let fourcc = shm_format_to_fourcc(data.format).ok_or(Error::ShmAccess)?;
+            let (w, h, stride, offset) = (
+                data.width as usize,
+                data.height as usize,
+                data.stride as usize,
+                data.offset as usize,
+            );
+            let line = w * BYTES_PER_PIXEL;
+            if w == 0 || h == 0 || stride < line || offset + stride * (h - 1) + line > len {
+                return Err(Error::ShmAccess);
+            }
+            let size = Size::from((data.width, data.height));
+            let full = Rectangle::from_size(size);
+            let region = region.and_then(|r| r.intersection(full)).unwrap_or(full);
+            let x = region.loc.x as usize * BYTES_PER_PIXEL;
+            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 {
+                std::slice::from_raw_parts(ptr.add(offset + y * stride + x), rw)
+            })?;
+            Ok(StagedShm {
+                staging,
+                region,
+                fourcc,
+                size,
+            })
+        })
+        .map_err(|_| Error::ShmAccess)?
+    }
+}
+
+impl VulkanRenderer {
+    pub fn shm_stager(&self) -> ShmStager {
+        ShmStager {
+            shared: self.shared.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) {
+            self.staged.insert(buffer.id(), (buffer.clone(), staged));
+        }
+    }
+}

monolith

Commit 0f11410be91b

Commit `0f11410be91b`