monolith

public

Star0

Fork 0

Watch0

29 commits 1 branch 0 tags 0 releases1.5 MiB

Commit `48af562d968b`

tarball

atagen <boss@atagen.co>2026-10-16 12:43 UTC

6 files changed+219-59

render-vk, monolith: stop stalling the event loop on shm commits

Every shm commit copied the whole buffer twice, allocated a new image, and blocked the CPU on a fence until the upload finished, so clients that redraw during spawns and resizes made frames miss vblanks in bursts. Each surface now keeps one texture and only damaged rows are copied, straight from the pool, with the copy ordered against frames by its barrier instead of a wait. New windows also hold on their seed until their first buffer lands, glides scale the client instead of cropping it, and the float toggle takes a window out of its scratchpad.

Modified file: crates/layout/src/lib.rs+12 additions−1 deletions@@ -678,11 +678,22 @@ impl Layout {
         self.place(w);
     }
 
+    /// Switches a window between tiled and floating. A scratchpad window
+    /// leaves its scratchpad and tiles on the tag being viewed, since its own
+    /// tag may well be hidden.
     pub fn toggle_floating(&mut self, w: WindowId) {
         let Some(win) = self.windows.get(w) else {
             return;
         };
-        if win.scratchpad.is_some() {
+        if let Some(s) = win.scratchpad {
+            let o = win.output.or(self.active);
+            let tag = o.map_or(self.homeless, |o| self.launch_tag(o));
+            self.leave_scratchpad(s, w);
+            let win = &mut self.windows[w];
+            win.output = o;
+            win.tag = tag;
+            win.floating = false;
+            self.place(w);
             return;
         }
         self.unplace(w);

Modified file: crates/monolith/src/drm.rs+18 additions−1 deletions@@ -327,7 +327,19 @@ fn on_vblank(state: &mut State, crtc: crtc::Handle, meta: &mut Option<DrmEventMe
     }
     surface.queued = false;
     if let Some(DrmEventTime::Monotonic(t)) = meta.as_ref().map(|m| m.time) {
-        surface.last_vblank_ns = Some(t.as_nanos() as u64);
+        let t = t.as_nanos() as u64;
+        if let Some(last) = surface.last_vblank_ns
+            && surface.redraw
+            && t - last > surface.refresh_ns * 3 / 2
+        {
+            let missed = (t - last) / surface.refresh_ns - 1;
+            tracing::debug!(
+                output = surface.output.name(),
+                missed,
+                "missed vblanks while animating"
+            );
+        }
+        surface.last_vblank_ns = Some(t);
     }
     render_surface(state, crtc);
 }
@@ -381,6 +393,7 @@ fn render_surface(state: &mut State, crtc: crtc::Handle) {
     if surface.queued {
         return;
     }
+    let began = std::time::Instant::now();
     let now = surface.predict(now_ns());
     let Some(area) = layout.output(surface.id).map(|o| o.area) else {
         return;
@@ -413,6 +426,10 @@ fn render_surface(state: &mut State, crtc: crtc::Handle) {
         Ok(_) => {}
         Err(e) => tracing::warn!("rendering failed: {e}"),
     }
+    let took = began.elapsed();
+    if took.as_nanos() as u64 > surface.refresh_ns / 2 {
+        tracing::debug!(output = surface.output.name(), ?took, "slow frame");
+    }
     surface.redraw = animating;
     if animating && !surface.queued {
         let wait = Duration::from_nanos(surface.refresh_ns);

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

@@ -70,6 +70,7 @@ impl CompositorHandler for State {

7070 t.send_configure();

7171 }

7272 }

73+ self.on_buffer(surface);

7374 self.popups.commit(surface);

7475 if let Some(PopupKind::Xdg(popup)) = self.popups.find_popup(surface)

7576 && !popup.is_initial_configure_sent()

Modified file: crates/monolith/src/scene.rs+28 additions−10 deletions@@ -9,7 +9,7 @@ use smithay::backend::renderer::element::memory::MemoryRenderBufferRenderElement
 use smithay::backend::renderer::element::solid::{SolidColorBuffer, SolidColorRenderElement};
 use smithay::backend::renderer::element::surface::WaylandSurfaceRenderElement;
 use smithay::backend::renderer::element::texture::TextureRenderElement;
-use smithay::backend::renderer::element::utils::CropRenderElement;
+use smithay::backend::renderer::element::utils::{CropRenderElement, RescaleRenderElement};
 use smithay::backend::renderer::element::{AsRenderElements, Element, Id, Kind, RenderElement};
 use smithay::backend::renderer::utils::CommitCounter;
 use smithay::backend::renderer::utils::with_renderer_surface_state;
@@ -27,6 +27,7 @@ smithay::backend::renderer::element::render_elements! {
     Effect=EffectElement,
     Border=SolidColorRenderElement,
     Memory=MemoryRenderBufferRenderElement<VulkanRenderer>,
+    Rescaled=RescaleRenderElement<WaylandSurfaceRenderElement<VulkanRenderer>>,
 }
 
 /// Border strips per window, kept between frames so unchanged borders cause
@@ -67,28 +68,30 @@ pub fn build(
             continue;
         }
         match anim.gliding(p.window, now) {
-            Some(r) => above.push((p.window, local(r), true)),
+            Some(r) => above.push((p.window, local(r), true, true)),
             None => {
                 let r = anim.tiled(o, p.window, now).unwrap_or(p.rect);
-                tiled.push((p.window, local(r), true));
+                tiled.push((p.window, local(r), true, false));
             }
         }
     }
     for &(w, r) in &arr.floating {
-        above.push((w, local(anim.gliding(w, now).unwrap_or(r)), true));
+        let glide = anim.gliding(w, now);
+        above.push((w, local(glide.unwrap_or(r)), true, glide.is_some()));
     }
     if let Some(w) = arr.fullscreen {
-        above.push((w, local(anim.gliding(w, now).unwrap_or(area)), false));
+        let glide = anim.gliding(w, now);
+        above.push((w, local(glide.unwrap_or(area)), false, glide.is_some()));
     }
     borders.0.retain(|id, _| windows.contains_key(id));
     let focused = layout.focused();
     let mut out = Vec::new();
-    for (id, r, framed) in tiled.into_iter().chain(above).rev() {
+    for (id, r, framed, gliding) in tiled.into_iter().chain(above).rev() {
         let Some(window) = windows.get(&id) else {
             continue;
         };
         let effect = anim.effect(id, now);
-        window_elements(&mut out, renderer, window, r, effect);
+        window_elements(&mut out, renderer, window, r, effect, gliding);
         if framed && deco.border > 0 {
             let color = if focused == Some(id) {
                 deco.focused.0
@@ -120,15 +123,17 @@ pub fn build(
     out
 }
 
-/// Draws `window` filling `r`. A buffer bigger than `r` is cropped, and one
-/// smaller has its last row and column stretched over the rest, so a resize
-/// in flight never shows a scaled or missing client.
+/// Draws `window` filling `r`. In a planned move a buffer bigger than `r` is
+/// cropped and one smaller has its last row and column stretched over the
+/// rest, keeping content aligned with its neighbours. A gliding window is
+/// scaled instead, so the client resizing mid-glide does not jump.
 fn window_elements(
     out: &mut Vec<Draw>,
     renderer: &mut VulkanRenderer,
     window: &Window,
     r: Rect,
     effect: Option<Effect>,
+    scaled: bool,
 ) {
     let Some(((x, y), (w, h))) = pixels(r) else {
         return;
@@ -142,6 +147,19 @@ fn window_elements(
         effect_elements(out, renderer, window, elems, ((x, y), (w, h)), effect);
         return;
     }
+    if scaled && geo.size.w > 0 && geo.size.h > 0 {
+        let scale = Scale::from((
+            f64::from(w) / f64::from(geo.size.w),
+            f64::from(h) / f64::from(geo.size.h),
+        ));
+        let origin = Point::<i32, Physical>::from((x, y));
+        out.extend(
+            elems
+                .into_iter()
+                .map(|e| Draw::Rescaled(RescaleRenderElement::from_element(e, origin, scale))),
+        );
+        return;
+    }
     if (w, h) == (geo.size.w, geo.size.h) {
         out.extend(elems.into_iter().map(Draw::Surface));
         return;

Modified file: crates/monolith/src/state.rs+52 additions−4 deletions@@ -13,7 +13,9 @@ use smithay::desktop::{PopupManager, Space, Window, WindowSurfaceType};
 use smithay::input::keyboard::{Keycode, XkbConfig};
 use smithay::input::pointer::CursorImageStatus;
 use smithay::input::{Seat, SeatState};
+use smithay::reexports::calloop::LoopHandle;
 use smithay::reexports::calloop::generic::Generic;
+use smithay::reexports::calloop::timer::{TimeoutAction, Timer};
 use smithay::reexports::calloop::{EventLoop, Interest, LoopSignal, Mode, PostAction};
 use smithay::reexports::wayland_protocols::xdg::shell::server::xdg_toplevel::State as XdgState;
 use smithay::reexports::wayland_server::backend::{ClientData, ClientId, DisconnectReason};
@@ -28,7 +30,7 @@ use smithay::wayland::shell::xdg::decoration::XdgDecorationState;
 use smithay::wayland::shell::xdg::{XdgShellState, XdgToplevelSurfaceData};
 use smithay::wayland::shm::ShmState;
 use smithay::wayland::socket::ListeningSocketSource;
-use std::collections::HashMap;
+use std::collections::{HashMap, HashSet};
 use std::ffi::OsString;
 use std::path::PathBuf;
 use std::sync::Arc;
@@ -70,6 +72,8 @@ pub struct State {
     /// How each shown window was placed by the last layout pass, to spot
     /// switches between tiled, floating and fullscreen.
     pub last_kind: HashMap<WindowId, (Kind, Rect, OutputId)>,
+    pub awaiting: HashSet<WindowId>,
+    pub handle: LoopHandle<'static, State>,
 
     pub compositor_state: CompositorState,
     pub xdg_shell_state: XdgShellState,
@@ -85,7 +89,7 @@ pub struct State {
 
 impl State {
     pub fn new(
-        event_loop: &mut EventLoop<State>,
+        event_loop: &mut EventLoop<'static, State>,
         display: Display<State>,
         config_path: Option<PathBuf>,
     ) -> Result<Self, Box<dyn std::error::Error>> {
@@ -157,6 +161,8 @@ impl State {
             anim: Animator::new(animation),
             borders: Default::default(),
             last_kind: HashMap::new(),
+            awaiting: HashSet::new(),
+            handle: event_loop.handle(),
             compositor_state: CompositorState::new::<State>(&dh),
             xdg_shell_state: XdgShellState::new::<State>(&dh),
             _xdg_decoration_state: XdgDecorationState::new::<State>(&dh),
@@ -225,13 +231,44 @@ impl State {
             self.layout.scratchpad_add(id, name);
         }
         self.windows.insert(id, window);
-        self.anim.spawned(id, now_ns());
+        self.await_first_buffer(id);
         if self.layout.visible(id) {
             self.layout.focus(id);
         }
         self.apply_layout();
     }
 
+    /// Holds a new window on its seed until its first buffer lands, so the
+    /// spawn animation never plays over an empty slot. Clients that are slow
+    /// to draw get it anyway after a while.
+    fn await_first_buffer(&mut self, id: WindowId) {
+        self.awaiting.insert(id);
+        let timeout = Timer::from_duration(Duration::from_millis(300));
+        let _ = self.handle.insert_source(timeout, move |_, _, state| {
+            state.first_buffer(id);
+            TimeoutAction::Drop
+        });
+    }
+
+    /// Called on commits, starts the spawn of a window that now has a buffer.
+    pub fn on_buffer(&mut self, surface: &WlSurface) {
+        if self.awaiting.is_empty() {
+            return;
+        }
+        let has_buffer =
+            with_renderer_surface_state(surface, |s| s.buffer_size().is_some()).unwrap_or(false);
+        if has_buffer && let Some(id) = self.window_id(surface) {
+            self.first_buffer(id);
+        }
+    }
+
+    fn first_buffer(&mut self, id: WindowId) {
+        if self.awaiting.remove(&id) {
+            self.anim.spawned(id, now_ns());
+            self.apply_layout();
+        }
+    }
+
     pub fn unmap_window(&mut self, surface: &WlSurface) {
         self.unmapped
             .retain(|w| w.toplevel().is_some_and(|t| t.wl_surface() != surface));
@@ -321,8 +358,19 @@ impl State {
             if let Some(w) = arr.fullscreen {
                 shown.push((w, area, Kind::Fullscreen, o));
             }
+            let held: Vec<WindowId> = arr
+                .tiled
+                .iter()
+                .map(|p| p.window)
+                .filter(|w| self.awaiting.contains(w))
+                .collect();
+            let planned = if held.is_empty() {
+                arr.tiled.clone()
+            } else {
+                self.layout.arrange_hiding(o, &held).tiled
+            };
             let targets: Vec<(WindowId, Rect)> =
-                arr.tiled.iter().map(|p| (p.window, p.rect)).collect();
+                planned.iter().map(|p| (p.window, p.rect)).collect();
             tracks.push((o, targets));
         }
 

Modified file: crates/render-vk/src/renderer.rs+108 additions−43 deletions@@ -26,12 +26,13 @@ use smithay::wayland::shm::{shm_format_to_fourcc, with_buffer_contents};
 use std::collections::HashMap;
 use std::fmt;
 use std::marker::PhantomData;
-use std::sync::Arc;
+use std::sync::{Arc, Mutex};
 
 struct Pending {
     fence: Arc<FenceInner>,
     cmd: vk::CommandBuffer,
     _keep: Vec<Arc<ImageInner>>,
+    _staging: Option<Staging>,
 }
 
 pub struct VulkanRenderer {
@@ -365,10 +366,13 @@ impl VulkanRenderer {
             fence: fence.clone(),
             cmd,
             _keep: sampled,
+            _staging: None,
         });
         Ok(SyncPoint::from(VkFence(fence)))
     }
 
+    /// Copies `region` of a full-image `data` into `image`, rows top-down or
+    /// flipped.
     fn upload(
         &mut self,
         image: &Arc<ImageInner>,
@@ -376,35 +380,53 @@ impl VulkanRenderer {
         region: Rectangle<i32, Buffer>,
         flipped: bool,
     ) -> Result<(), Error> {
-        if image.external {
-            return Err(Error::ForeignTexture);
-        }
         let width = image.width as usize;
-        let needed = width * image.height as usize * BYTES_PER_PIXEL;
+        let rows = image.height as usize;
+        let needed = width * rows * BYTES_PER_PIXEL;
         if data.len() < needed {
             return Err(Error::BufferTooSmall {
                 needed,
                 got: data.len(),
             });
         }
+        let stride = width * BYTES_PER_PIXEL;
+        self.upload_with(image, region, |y| {
+            let from = if flipped { rows - 1 - y } else { y };
+            let start = from * stride + region.loc.x as usize * BYTES_PER_PIXEL;
+            &data[start..start + region.size.w as usize * BYTES_PER_PIXEL]
+        })
+    }
+
+    /// Uploads `region` of `image`, taking each image row `y` in the region
+    /// from `row(y)`. The CPU does not wait: the copy is ordered before later
+    /// frames by its barrier, and its staging memory lives until its fence.
+    fn upload_with<'a>(
+        &mut self,
+        image: &Arc<ImageInner>,
+        region: Rectangle<i32, Buffer>,
+        row: impl Fn(usize) -> &'a [u8],
+    ) -> Result<(), Error> {
+        if image.external {
+            return Err(Error::ForeignTexture);
+        }
+        self.reap();
+        let (w, h) = (region.size.w as usize, region.size.h as usize);
+        if w == 0 || h == 0 {
+            return Ok(());
+        }
+        let line = w * BYTES_PER_PIXEL;
         let mut staging = Staging::new(
             &self.shared,
-            needed,
+            line * h,
             vk::BufferUsageFlags::TRANSFER_SRC,
             MemoryLocation::CpuToGpu,
         )?;
-        let row = width * BYTES_PER_PIXEL;
-        let rows = image.height as usize;
         let dst = staging.bytes_mut();
-        for y in 0..rows {
-            let from = if flipped { rows - 1 - y } else { y };
-            dst[y * row..(y + 1) * row].copy_from_slice(&data[from * row..(from + 1) * row]);
+        for i in 0..h {
+            dst[i * line..(i + 1) * line].copy_from_slice(row(region.loc.y as usize + i));
         }
         let copy = vk::BufferImageCopy::default()
-            .buffer_offset(
-                ((region.loc.y as usize * width + region.loc.x as usize) * BYTES_PER_PIXEL) as u64,
-            )
-            .buffer_row_length(image.width)
+            .buffer_row_length(w as u32)
             .image_subresource(
                 vk::ImageSubresourceLayers::default()
                     .aspect_mask(vk::ImageAspectFlags::COLOR)
@@ -416,24 +438,19 @@ impl VulkanRenderer {
                 z: 0,
             })
             .image_extent(vk::Extent3D {
-                width: region.size.w as u32,
-                height: region.size.h as u32,
+                width: w as u32,
+                height: h as u32,
                 depth: 1,
             });
-        let buffer = staging.buffer;
-        let target = image.clone();
-        self.one_shot(|d, cmd, family| unsafe {
-            acquire(
-                d,
-                cmd,
-                family,
-                &target,
-                vk::ImageLayout::TRANSFER_DST_OPTIMAL,
-            );
+        let d = &self.shared.device.device;
+        let family = self.shared.device.queue_family;
+        let cmd = self.begin()?;
+        unsafe {
+            acquire(d, cmd, family, image, vk::ImageLayout::TRANSFER_DST_OPTIMAL);
             d.cmd_copy_buffer_to_image(
                 cmd,
-                buffer,
-                target.image,
+                staging.buffer,
+                image.image,
                 vk::ImageLayout::TRANSFER_DST_OPTIMAL,
                 &[copy],
             );
@@ -441,10 +458,18 @@ impl VulkanRenderer {
                 d,
                 cmd,
                 family,
-                &target,
+                image,
                 vk::ImageLayout::SHADER_READ_ONLY_OPTIMAL,
             );
-        })
+        }
+        let fence = self.end_and_submit(cmd)?;
+        self.pending.push(Pending {
+            fence,
+            cmd,
+            _keep: vec![image.clone()],
+            _staging: Some(staging),
+        });
+        Ok(())
     }
 
     fn read_back(
@@ -879,13 +904,20 @@ impl ExportMem for VulkanRenderer {
 }
 
 impl ImportMemWl for VulkanRenderer {
+    /// Keeps one texture per surface and uploads only the damaged rows into
+    /// it, straight from the client's shm pool.
     fn import_shm_buffer(
         &mut self,
         buffer: &WlBuffer,
-        _surface: Option<&SurfaceData>,
-        _damage: &[Rectangle<i32, Buffer>],
+        surface: Option<&SurfaceData>,
+        damage: &[Rectangle<i32, Buffer>],
     ) -> Result<VulkanTexture, Error> {
-        let (pixels, fourcc, size) = with_buffer_contents(buffer, |ptr, len, data| {
+        let cache = surface.map(|s| {
+            s.data_map
+                .insert_if_missing_threadsafe(|| ShmCache(Mutex::new(None)));
+            s.data_map.get::<ShmCache>().expect("just inserted")
+        });
+        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,
@@ -893,18 +925,51 @@ impl ImportMemWl for VulkanRenderer {
                 data.stride as usize,
                 data.offset as usize,
             );
-            let row = w * BYTES_PER_PIXEL;
-            if w == 0 || h == 0 || stride < row || offset + stride * (h - 1) + row > len {
+            let line = w * BYTES_PER_PIXEL;
+            if w == 0 || h == 0 || stride < line || offset + stride * (h - 1) + line > len {
                 return Err(Error::ShmAccess);
             }
-            let mut pixels = Vec::with_capacity(row * h);
-            for y in 0..h {
-                let line = unsafe { std::slice::from_raw_parts(ptr.add(offset + y * stride), row) };
-                pixels.extend_from_slice(line);
+            let size = Size::from((data.width, data.height));
+            let full = Rectangle::from_size(size);
+            let reused = cache
+                .and_then(|c| c.0.lock().unwrap_or_else(|e| e.into_inner()).clone())
+                .filter(|t| {
+                    t.0.fourcc == fourcc
+                        && t.size() == size
+                        && Arc::ptr_eq(&t.0.shared, &self.shared)
+                });
+            let (texture, region) = match reused {
+                Some(t) => {
+                    let dirty = damage
+                        .iter()
+                        .filter_map(|d| d.intersection(full))
+                        .reduce(|a, b| a.merge(b));
+                    (t, if damage.is_empty() { Some(full) } else { dirty })
+                }
+                None => {
+                    let usage = vk::ImageUsageFlags::SAMPLED
+                        | vk::ImageUsageFlags::TRANSFER_DST
+                        | vk::ImageUsageFlags::TRANSFER_SRC;
+                    let image =
+                        ImageInner::create(&self.shared, fourcc, w as u32, h as u32, usage)?;
+                    (VulkanTexture(image), Some(full))
+                }
+            };
+            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 {
+                    std::slice::from_raw_parts(ptr.add(offset + y * stride + x), rw)
+                })?;
             }
-            Ok((pixels, fourcc, Size::from((data.width, data.height))))
+            if let Some(c) = cache {
+                *c.0.lock().unwrap_or_else(|e| e.into_inner()) = Some(texture.clone());
+            }
+            Ok(texture)
         })
-        .map_err(|_| Error::ShmAccess)??;
-        self.import_memory(&pixels, fourcc, size, false)
+        .map_err(|_| Error::ShmAccess)?
     }
 }
+
+/// The texture last imported for a surface's shm buffers.
+struct ShmCache(Mutex<Option<VulkanTexture>>);

monolith

Commit 48af562d968b

Commit `48af562d968b`