monolith

public

Star0

Fork 0

Watch0

32 commits 1 branch 0 tags 0 releases1.5 MiB

Commit `e4b186dffb77`

tarball

atagen <boss@atagen.co>2026-10-16 13:08 UTC

3 files changed+83-2

monolith: hold dmabuf commits until their buffers are ready

Clients get linux-drm-syncobj on GPUs whose syncobjs signal eventfds, and a commit with an acquire point is held on the event loop until that point signals. Implicitly synced dmabuf commits are held until their pending writes finish. Either way the renderer never samples a buffer the client GPU is still writing, and never waits on it, which sidesteps NVIDIA lacking timeline semaphore export to syncobjs.

Modified file: crates/monolith/src/drm.rs+6 additions@@ -30,6 +30,7 @@ use smithay::reexports::drm::control::{ModeTypeFlags, connector, crtc};
 use smithay::reexports::input::Libinput;
 use smithay::reexports::rustix::fs::OFlags;
 use smithay::utils::{DeviceFd, Point, Transform};
+use smithay::wayland::drm_syncobj::{DrmSyncobjState, supports_syncobj_eventfd};
 use smithay_drm_extras::drm_scanner::{DrmScanEvent, DrmScanner};
 use std::collections::{HashMap, VecDeque};
 use std::path::{Path, PathBuf};
@@ -158,6 +159,11 @@ pub fn init(
         .get_driver()
         .map(|d| d.name().to_string_lossy().to_lowercase().contains("nvidia"))
         .unwrap_or(false);
+    if supports_syncobj_eventfd(&fd) {
+        state.syncobj = Some(DrmSyncobjState::new::<State>(&state.display, fd.clone()));
+    } else {
+        tracing::info!("no syncobj eventfd support, clients stay on implicit sync");
+    }
     let gbm = GbmDevice::new(fd)?;
     let render_node = node
         .node_with_type(NodeType::Render)

Modified file: crates/monolith/src/handlers.rs+75 additions−2 deletions@@ -6,6 +6,7 @@ use smithay::desktop::{PopupKind, Window};
 use smithay::input::dnd::{DndGrabHandler, GrabType, Source};
 use smithay::input::pointer::CursorImageStatus;
 use smithay::input::{Seat, SeatHandler, SeatState};
+use smithay::reexports::calloop::Interest;
 use smithay::reexports::wayland_server::protocol::wl_buffer::WlBuffer;
 use smithay::reexports::wayland_protocols::xdg::decoration::zv1::server::zxdg_toplevel_decoration_v1::Mode as DecorationMode;
 use smithay::reexports::wayland_server::protocol::wl_output::WlOutput;
@@ -15,9 +16,14 @@ use smithay::reexports::wayland_server::{Client, Resource};
 use smithay::utils::Serial;
 use smithay::wayland::buffer::BufferHandler;
 use smithay::wayland::compositor::{
-    CompositorClientState, CompositorHandler, CompositorState, get_parent, is_sync_subsurface,
+    BufferAssignment, CompositorClientState, CompositorHandler, CompositorState,
+    SurfaceAttributes, add_blocker, add_pre_commit_hook, get_parent, is_sync_subsurface,
+    with_states,
+};
+use smithay::wayland::drm_syncobj::{DrmSyncobjCachedState, DrmSyncobjHandler, DrmSyncobjState};
+use smithay::wayland::dmabuf::{
+    DmabufGlobal, DmabufHandler, DmabufState, ImportNotifier, get_dmabuf,
 };
-use smithay::wayland::dmabuf::{DmabufGlobal, DmabufHandler, DmabufState, ImportNotifier};
 use smithay::wayland::output::OutputHandler;
 use smithay::wayland::selection::SelectionHandler;
 use smithay::wayland::selection::data_device::{
@@ -35,6 +41,12 @@ impl CompositorHandler for State {
         &mut self.compositor_state
     }
 
+    fn new_surface(&mut self, surface: &WlSurface) {
+        add_pre_commit_hook::<Self, _>(surface, |state, _dh, surface| {
+            hold_until_readable(state, surface);
+        });
+    }
+
     fn client_compositor_state<'a>(&self, client: &'a Client) -> &'a CompositorClientState {
         &client
             .get_data::<ClientState>()
@@ -218,6 +230,67 @@ impl smithay::wayland::pointer_constraints::PointerConstraintsHandler for State 
 
 smithay::delegate_dispatch2!(State);
 
+impl DrmSyncobjHandler for State {
+    fn drm_syncobj_state(&mut self) -> Option<&mut DrmSyncobjState> {
+        self.syncobj.as_mut()
+    }
+}
+
+/// Holds a dmabuf commit until the buffer can be read without the renderer
+/// 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) {
+    let (acquire, dmabuf) = with_states(surface, |s| {
+        let acquire = s
+            .cached_state
+            .get::<DrmSyncobjCachedState>()
+            .pending()
+            .acquire_point
+            .clone();
+        let dmabuf = match s
+            .cached_state
+            .get::<SurfaceAttributes>()
+            .pending()
+            .buffer
+            .as_ref()
+        {
+            Some(BufferAssignment::NewBuffer(buffer)) => get_dmabuf(buffer).cloned().ok(),
+            _ => None,
+        };
+        (acquire, dmabuf)
+    });
+    let (Some(dmabuf), Some(client)) = (dmabuf, surface.client()) else {
+        return;
+    };
+    if let Some(point) = acquire
+        && let Ok((blocker, source)) = point.generate_blocker()
+    {
+        let inserted = state.handle.insert_source(source, move |_, _, state| {
+            let dh = state.display.clone();
+            state
+                .client_compositor_state(&client)
+                .blocker_cleared(state, &dh);
+            Ok(())
+        });
+        if inserted.is_ok() {
+            add_blocker(surface, blocker);
+        }
+        return;
+    }
+    if let Ok((blocker, source)) = dmabuf.generate_blocker(Interest::READ) {
+        let inserted = state.handle.insert_source(source, move |_, _, state| {
+            let dh = state.display.clone();
+            state
+                .client_compositor_state(&client)
+                .blocker_cleared(state, &dh);
+            Ok(())
+        });
+        if inserted.is_ok() {
+            add_blocker(surface, blocker);
+        }
+    }
+}
+
 impl XdgDecorationHandler for State {
     fn new_decoration(&mut self, toplevel: ToplevelSurface) {
         server_side(&toplevel);

Modified file: crates/monolith/src/state.rs+2 additions@@ -46,6 +46,7 @@ pub struct State {
     pub popups: PopupManager,
     pub host: Option<Host>,
     pub drm: Option<crate::drm::Drm>,
+    pub syncobj: Option<smithay::wayland::drm_syncobj::DrmSyncobjState>,
     pub cursor: crate::cursor::Cursor,
     pub cursor_status: CursorImageStatus,
     pub needs_redraw: bool,
@@ -145,6 +146,7 @@ impl State {
             popups: PopupManager::default(),
             host: None,
             drm: None,
+            syncobj: None,
             cursor: crate::cursor::Cursor::load(),
             cursor_status: CursorImageStatus::default_named(),
             needs_redraw: true,

monolith

Commit e4b186dffb77

Commit `e4b186dffb77`