monolith

public

Star0

Fork 0

Watch0

56 commits 1 branch 0 tags 0 releases1.5 MiB

Commit `8956d017e879`

tarball

atagen <boss@atagen.co>2026-10-16 23:18 UTC

6 files changed+175-7

monolith: import dmabufs on a worker thread

A first dmabuf import takes 15 to 27 ms on NVIDIA and used to run on the main thread at buffer creation, dropping frames whenever a client allocated its swapchain. linux-dmabuf now answers once the worker is done, and a commit of a buffer still importing waits on a blocker instead of importing inline.

Modified file: crates/monolith/src/handlers.rs+4 additions−6 deletions@@ -1,6 +1,5 @@
 use crate::state::{ClientState, State};
 use smithay::backend::allocator::dmabuf::Dmabuf;
-use smithay::backend::renderer::ImportDma;
 use smithay::backend::renderer::utils::{import_surface_tree, on_commit_buffer_handler};
 use smithay::desktop::{PopupKind, Window};
 use smithay::input::dnd::{DndGrabHandler, GrabType, Source};
@@ -127,11 +126,7 @@ impl DmabufHandler for State {
         dmabuf: Dmabuf,
         notifier: ImportNotifier,
     ) {
-        if self.renderer.import_dmabuf(&dmabuf, None).is_ok() {
-            let _ = notifier.successful::<State>();
-        } else {
-            notifier.failed();
-        }
+        self.import_for(&dmabuf, notifier);
     }
 }
 
@@ -300,6 +295,9 @@ fn hold_until_readable(state: &mut State, surface: &WlSurface) {
     let (Some(dmabuf), Some(client)) = (dmabuf, surface.client()) else {
         return;
     };
+    if let Some(blocker) = state.import_blocker(&dmabuf, client.clone()) {
+        add_blocker(surface, blocker);
+    }
     if let Some(point) = acquire
         && let Ok((blocker, source)) = point.generate_blocker()
     {

Added file: crates/monolith/src/import.rs+133 additions@@ -0,0 +1,133 @@
+//! 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.
+
+use crate::state::State;
+use monolith_render_vk::{DmabufImporter, 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::wayland::compositor::{Blocker, BlockerState, CompositorHandler};
+use smithay::wayland::dmabuf::ImportNotifier;
+use std::collections::HashMap;
+use std::sync::Arc;
+use std::sync::atomic::{AtomicBool, Ordering};
+use std::sync::mpsc;
+
+pub struct Imports {
+    jobs: mpsc::Sender<Dmabuf>,
+    waiting: HashMap<WeakDmabuf, Waiters>,
+}
+
+#[derive(Default)]
+struct Waiters {
+    done: Arc<AtomicBool>,
+    notifiers: Vec<ImportNotifier>,
+    clients: Vec<Client>,
+}
+
+pub struct ImportBlocker(Arc<AtomicBool>);
+
+impl Blocker for ImportBlocker {
+    fn state(&self) -> BlockerState {
+        if self.0.load(Ordering::Acquire) {
+            BlockerState::Released
+        } else {
+            BlockerState::Pending
+        }
+    }
+}
+
+type Done = (Dmabuf, Result<VulkanTexture, String>);
+
+impl Imports {
+    pub fn new(
+        handle: &LoopHandle<'static, State>,
+        importer: DmabufImporter,
+    ) -> std::io::Result<Self> {
+        let (done, results) = channel::<Done>();
+        let (jobs, queue) = mpsc::channel::<Dmabuf>();
+        std::thread::Builder::new()
+            .name("dmabuf-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() {
+                        break;
+                    }
+                }
+            })?;
+        handle
+            .insert_source(results, |event, _, state| {
+                if let Event::Msg((buffer, result)) = event {
+                    state.imported(buffer, result);
+                }
+            })
+            .map_err(|e| std::io::Error::other(e.to_string()))?;
+        Ok(Self {
+            jobs,
+            waiting: 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());
+            Waiters::default()
+        })
+    }
+}
+
+impl State {
+    /// Answers a client's buffer creation once its dmabuf is imported.
+    pub fn import_for(&mut self, buffer: &Dmabuf, notifier: ImportNotifier) {
+        if self.renderer.has_dmabuf(buffer) {
+            let _ = notifier.successful::<State>();
+            return;
+        }
+        self.imports.start(buffer).notifiers.push(notifier);
+    }
+
+    /// A blocker for a commit whose dmabuf the renderer has not imported yet.
+    pub fn import_blocker(&mut self, buffer: &Dmabuf, client: Client) -> Option<ImportBlocker> {
+        if self.renderer.has_dmabuf(buffer) {
+            return None;
+        }
+        let waiters = self.imports.start(buffer);
+        waiters.clients.push(client);
+        Some(ImportBlocker(waiters.done.clone()))
+    }
+
+    fn imported(&mut self, buffer: Dmabuf, result: Result<VulkanTexture, String>) {
+        let Some(waiters) = self.imports.waiting.remove(&buffer.weak()) else {
+            return;
+        };
+        let result = result.and_then(|t| {
+            self.renderer
+                .adopt_dmabuf(&buffer, t)
+                .map_err(|e| e.to_string())
+        });
+        match result {
+            Ok(()) => {
+                for n in waiters.notifiers {
+                    let _ = n.successful::<State>();
+                }
+            }
+            Err(e) => {
+                tracing::warn!("dmabuf import failed: {e}");
+                for n in waiters.notifiers {
+                    n.failed();
+                }
+            }
+        }
+        waiters.done.store(true, Ordering::Release);
+        let dh = self.display.clone();
+        for client in waiters.clients {
+            self.client_compositor_state(&client)
+                .blocker_cleared(self, &dh);
+        }
+    }
+}

Modified file: crates/monolith/src/main.rs+1

@@ -7,6 +7,7 @@ mod drm;

77 mod focus;

88 mod handlers;

99 mod idle;

10+mod import;

1011 mod input;

1112 mod ipc;

1213 mod launch;

Modified file: crates/monolith/src/state.rs+3 additions@@ -97,6 +97,7 @@ pub struct State {
     pub xwayland: Option<crate::xwayland::Xwayland>,
     pub xwayland_shell_state: XWaylandShellState,
     pub captures: crate::capture::Captures,
+    pub imports: crate::import::Imports,
     /// The render node clients get dmabufs for, known on bare metal.
     pub render_node: Option<smithay::backend::drm::DrmNode>,
     pub lock: crate::lock::Lock,
@@ -177,6 +178,7 @@ impl State {
         let binds = Binds::new(&config);
         let animation = config.animation.clone();
         let primary_selection_state = PrimarySelectionState::new::<State>(&dh);
+        let imports = crate::import::Imports::new(&handle, renderer.dmabuf_importer())?;
         Ok(Self {
             start: Instant::now(),
             socket_name,
@@ -214,6 +216,7 @@ impl State {
             xwayland: None,
             xwayland_shell_state: XWaylandShellState::new::<State>(&dh),
             captures: Default::default(),
+            imports,
             render_node: None,
             lock: Default::default(),
             inhibitors: HashSet::new(),

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::VulkanRenderer;

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

Modified file: crates/render-vk/src/renderer.rs+33 additions@@ -975,6 +975,39 @@ impl ImportDma for VulkanRenderer {
 
 impl ImportDmaWl for VulkanRenderer {}
 
+/// Imports dmabufs on another thread. The textures it makes belong to the
+/// renderer it came from, which takes them back with `adopt_dmabuf`.
+#[derive(Clone)]
+pub struct DmabufImporter {
+    shared: Arc<Shared>,
+    caps: Arc<DmabufCaps>,
+}
+
+impl DmabufImporter {
+    pub fn import(&self, buffer: &Dmabuf) -> Result<VulkanTexture, Error> {
+        dmabuf::import(&self.shared, &self.caps, buffer, SAMPLE_USAGE).map(VulkanTexture)
+    }
+}
+
+impl VulkanRenderer {
+    pub fn dmabuf_importer(&self) -> DmabufImporter {
+        DmabufImporter {
+            shared: self.shared.clone(),
+            caps: self.caps.clone(),
+        }
+    }
+
+    pub fn has_dmabuf(&self, buffer: &Dmabuf) -> bool {
+        self.dmabuf_textures.contains_key(&buffer.weak())
+    }
+
+    pub fn adopt_dmabuf(&mut self, buffer: &Dmabuf, texture: VulkanTexture) -> Result<(), Error> {
+        self.own(&texture.0)?;
+        self.dmabuf_textures.insert(buffer.weak(), texture);
+        Ok(())
+    }
+}
+
 impl ExportMem for VulkanRenderer {
     type TextureMapping = VulkanMapping;

monolith

Commit 8956d017e879

Commit `8956d017e879`