monolith

public

Star0

Fork 0

Watch0

79 commits 1 branch 0 tags 0 releases1.5 MiB

Commit `ba17141501b4`

tarball

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

8 files changed+84-7

monolith: stop asking hidden surfaces to draw under fullscreen

Windows and lower layers covered by a fullscreen window kept getting frame callbacks, so any that animate kept committing and held the output at full refresh. Under VRR that defeats the point, since the panel should follow the fullscreen client alone. A debug line now names the clients committing most each second, and the frame rate line no longer invents a vblank count from the nominal refresh while VRR is on.

Modified file: crates/monolith/src/drm.rs+5 additions−2 deletions@@ -500,11 +500,14 @@ fn on_vblank(state: &mut State, crtc: crtc::Handle, meta: &mut Option<DrmEventMe
         surface.presented += 1;
         let window = t.saturating_sub(surface.stats_since);
         if window >= 1_000_000_000 {
-            let vblanks = window / surface.refresh_ns.max(1);
+            // Under VRR the panel waits for each flip, so the nominal refresh
+            // says nothing about how many vblanks there were.
+            let vblanks = (!surface.vrr_on).then(|| window / surface.refresh_ns.max(1));
             tracing::debug!(
                 output = surface.output.name(),
                 presented = surface.presented,
                 vblanks,
+                vrr = surface.vrr_on,
                 budget_us = surface.budget.ns() / 1000,
                 "frame rate"
             );
@@ -715,7 +718,7 @@ fn render_surface(state: &mut State, crtc: crtc::Handle, target: u64) -> bool {
     }
     surface.redraw = animating;
     let elapsed = core.start.elapsed();
-    crate::frame::send_frame_callbacks(wm, lock, &surface.output, elapsed);
+    crate::frame::send_frame_callbacks(wm, lock, surface.id, &surface.output, now, elapsed);
     animating && !surface.queued
 }
 

Modified file: crates/monolith/src/frame.rs+22 additions−3 deletions@@ -60,16 +60,35 @@ pub fn compose(
     elements
 }
 
-/// Lets clients shown on `output` draw their next frame.
-pub fn send_frame_callbacks(wm: &Wm, lock: &Lock, output: &Output, elapsed: Duration) {
+/// Lets clients shown on `output` draw their next frame. Under a fullscreen
+/// window at rest only it and the overlay layer are shown, and anything
+/// else that kept drawing would hold the output, or a VRR panel, at full
+/// refresh for frames nobody sees.
+pub fn send_frame_callbacks(
+    wm: &Wm,
+    lock: &Lock,
+    o: OutputId,
+    output: &Output,
+    now: u64,
+    elapsed: Duration,
+) {
     if lock.active() {
         crate::lock::send_frames(lock, output, elapsed);
         return;
     }
+    let covering = wm
+        .layout
+        .arrange(o)
+        .fullscreen
+        .filter(|&w| wm.anim.gliding(w, now).is_none())
+        .and_then(|w| wm.window(w));
     for window in wm.space.elements_for_output(output) {
+        if covering.is_some_and(|c| c != window) {
+            continue;
+        }
         window.send_frame(output, elapsed, Some(Duration::ZERO), |_, _| {
             Some(output.clone())
         });
     }
-    crate::layers::send_frames(output, elapsed);
+    crate::layers::send_frames(output, elapsed, covering.is_some());
 }

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

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

8383 if let Some(window) = window {

8484 window.on_commit();

8585 }

86+ self.count_commit(&root);

8687 if let Some(id) = self.window_id(&root) {

8788 self.refresh_identity(id);

8889 if self.services.captures.wants_damage() {

Modified file: crates/monolith/src/layers.rs+6 additions−1 deletions@@ -210,8 +210,13 @@ pub fn elements(out: &mut Vec<Draw>, renderer: &mut VulkanRenderer, output: &Out
     }
 }
 
-pub fn send_frames(output: &Output, elapsed: Duration) {
+/// With `covered`, a fullscreen window hides everything below the overlay
+/// layer, so only overlay surfaces are asked to draw.
+pub fn send_frames(output: &Output, elapsed: Duration, covered: bool) {
     for l in layer_map_for_output(output).layers() {
+        if covered && l.layer() != Layer::Overlay {
+            continue;
+        }
         l.send_frame(output, elapsed, Some(Duration::ZERO), |_, _| {
             Some(output.clone())
         });

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

@@ -19,6 +19,7 @@ mod lock;

1919 mod nested;

2020 mod scene;

2121 mod state;

22+mod stats;

2223 mod toplevels;

2324 mod wm;

2425 mod xwayland;

Modified file: crates/monolith/src/nested/mod.rs+1−1

@@ -259,7 +259,7 @@ pub fn render(state: &mut State) {

259259 dirty.redraw = wm.anim.active(now);

260260 lock.shown(&host.output);

261261 let elapsed = core.start.elapsed();

262- crate::frame::send_frame_callbacks(wm, lock, &host.output, elapsed);

262+ crate::frame::send_frame_callbacks(wm, lock, host.output_id, &host.output, now, elapsed);

263263 if damage.is_some() {

264264 captures.output_damaged(&host.output);

265265 }

Modified file: crates/monolith/src/state.rs+2 additions@@ -85,6 +85,7 @@ pub struct Services {
     pub launches: crate::launch::Launches,
     pub ipc: crate::ipc::Server,
     pub idle: crate::idle::Idle,
+    pub commits: crate::stats::CommitStats,
 }
 
 /// The config and what is derived from it, swapped whole on reload.
@@ -183,6 +184,7 @@ impl State {
                 launches: Default::default(),
                 ipc: Default::default(),
                 idle,
+                commits: Default::default(),
             },
         })
     }

Added file: crates/monolith/src/stats.rs+46 additions@@ -0,0 +1,46 @@
+//! Which clients commit most, logged once a second at debug level. Every
+//! visible commit costs a frame, so this names whoever keeps an idle
+//! desktop, or a VRR panel, at full refresh.
+
+use crate::state::{State, now_ns};
+use smithay::desktop::{WindowSurfaceType, layer_map_for_output};
+use smithay::reexports::wayland_server::protocol::wl_surface::WlSurface;
+use std::collections::HashMap;
+
+#[derive(Default)]
+pub struct CommitStats {
+    counts: HashMap<String, u32>,
+    since: u64,
+}
+
+impl State {
+    /// Counts a commit on `root` against the window or layer it belongs to.
+    pub fn count_commit(&mut self, root: &WlSurface) {
+        if !tracing::enabled!(tracing::Level::DEBUG) {
+            return;
+        }
+        let label = match self.wm.id_of(root).and_then(|id| self.wm.get(id)) {
+            Some(w) => w.app_id.clone(),
+            None => self
+                .wm
+                .space
+                .outputs()
+                .find_map(|o| {
+                    let map = layer_map_for_output(o);
+                    let layer = map.layer_for_surface(root, WindowSurfaceType::TOPLEVEL)?;
+                    Some(format!("layer:{}", layer.namespace()))
+                })
+                .unwrap_or_else(|| "other".into()),
+        };
+        let stats = &mut self.services.commits;
+        *stats.counts.entry(label).or_default() += 1;
+        let now = now_ns();
+        if now.saturating_sub(stats.since) >= 1_000_000_000 {
+            let mut top: Vec<(String, u32)> = stats.counts.drain().collect();
+            top.sort_by_key(|e| std::cmp::Reverse(e.1));
+            top.truncate(3);
+            tracing::debug!(?top, "commits per second");
+            stats.since = now;
+        }
+    }
+}

monolith

Commit ba17141501b4

Commit `ba17141501b4`