monolith

public

Star0

Fork 0

Watch0

251 commits 1 branch 0 tags 0 releases1.5 MiB

Commit `a1f375a8b4be`

tarball

atagen <boss@atagen.co>2026-10-19 09:49 UTC

8 files changed+258-0

timing: add wp_commit_timing_v1 against each output's vblank timeline

Proton and newer Mesa stamp commits with a target presentation time, and smithay only parks them behind a barrier that the compositor has to signal. Each stamped commit is released so the next render lands on the first vblank at or after its timestamp, using the DRM budget and last vblank or the host's frame callbacks when nested. Surfaces on no output and outputs without a timeline release at once, so a hidden client never waits on a clock nobody keeps.

Modified file: crates/monolith/src/backend.rs+10 additions@@ -3,6 +3,7 @@
 
 use crate::drm::Drm;
 use crate::nested::Host;
+use crate::timing::Timeline;
 use monolith_layout::{OutputId, Rect};
 use smithay::backend::drm::DrmNode;
 use smithay::output::Output;
@@ -54,6 +55,15 @@ impl Backend {
         }
     }
 
+    /// When `output` presents, if that is known yet.
+    pub fn timeline(&self, output: &Output) -> Option<Timeline> {
+        match self {
+            Backend::Drm(d) => d.timeline(output),
+            Backend::Nested(h) => (h.output == *output).then(|| h.timeline()).flatten(),
+            Backend::Starting => None,
+        }
+    }
+
     /// The node clients allocate dmabufs on, known on bare metal.
     pub fn render_node(&self) -> Option<DrmNode> {
         self.drm().map(|d| d.render_node)

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

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

2626

2727 fn new_surface(&mut self, surface: &WlSurface) {

2828 add_pre_commit_hook::<Self, _>(surface, |state, _dh, surface| {

29+ crate::timing::watch(state, surface);

2930 hold_until_readable(state, surface);

3031 });

3132 }

Modified file: crates/monolith/src/drm.rs+9 additions@@ -678,6 +678,15 @@ impl Drm {
             .find(|s| s.id == id)
             .map(|s| s.output.clone())
     }
+
+    pub fn timeline(&self, output: &Output) -> Option<crate::timing::Timeline> {
+        let s = self.surfaces.values().find(|s| s.output == *output)?;
+        Some(crate::timing::Timeline {
+            last: s.last_vblank_ns?,
+            refresh: if s.vrr_on { 0 } else { s.refresh_ns },
+            budget: s.budget.ns(),
+        })
+    }
 }
 
 fn on_vblank(state: &mut State, crtc: crtc::Handle, meta: &mut Option<DrmEventMetadata>) {

Modified file: crates/monolith/src/globals.rs+3 additions@@ -10,6 +10,7 @@ use smithay::backend::renderer::ImportDma;
 use smithay::reexports::wayland_protocols::xdg::shell::server::xdg_toplevel::WmCapabilities;
 use smithay::reexports::wayland_server::DisplayHandle;
 use smithay::utils::{ClockSource, Monotonic};
+use smithay::wayland::commit_timing::CommitTimingManagerState;
 use smithay::wayland::compositor::CompositorState;
 use smithay::wayland::cursor_shape::CursorShapeManagerState;
 use smithay::wayland::dmabuf::{DmabufFeedbackBuilder, DmabufGlobal, DmabufState};
@@ -78,6 +79,7 @@ pub struct Protocols {
     _relative_pointer: RelativePointerManagerState,
     _pointer_constraints: PointerConstraintsState,
     _fifo: FifoManagerState,
+    _commit_timing: CommitTimingManagerState,
 }
 
 impl Protocols {
@@ -146,6 +148,7 @@ impl Protocols {
             _relative_pointer: RelativePointerManagerState::new::<State>(dh),
             _pointer_constraints: PointerConstraintsState::new::<State>(dh),
             _fifo: FifoManagerState::new::<State>(dh),
+            _commit_timing: CommitTimingManagerState::new::<State>(dh),
         }
     }
 }

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

@@ -32,6 +32,7 @@ mod seat;

3232 mod signals;

3333 mod state;

3434 mod stats;

35+mod timing;

3536 mod toplevels;

3637 mod windows;

3738 mod wm;

Modified file: crates/monolith/src/nested/mod.rs+14 additions@@ -59,6 +59,7 @@ pub struct Host {
     /// The host clock is CLOCK_MONOTONIC, so its timestamps share our timeline.
     monotonic: bool,
     last_present_ns: Option<u64>,
+    last_frame_ns: Option<u64>,
     refresh_ns: u64,
     feedback: Vec<(u64, OutputPresentationFeedback)>,
     next_feedback: u64,
@@ -76,6 +77,17 @@ impl Host {
             None => now,
         }
     }
+
+    pub fn timeline(&self) -> Option<crate::timing::Timeline> {
+        Some(crate::timing::Timeline {
+            last: self
+                .last_present_ns
+                .filter(|_| self.monotonic)
+                .or(self.last_frame_ns)?,
+            refresh: self.refresh_ns,
+            budget: 0,
+        })
+    }
 }
 
 /// Destroys the host-side buffer when its swapchain slot goes away.
@@ -163,6 +175,7 @@ pub fn init(
         presentation,
         monotonic: false,
         last_present_ns: None,
+        last_frame_ns: None,
         refresh_ns: 16_666_667,
         feedback: Vec::new(),
         next_feedback: 0,
@@ -556,6 +569,7 @@ impl Dispatch<wl_callback::WlCallback, ()> for State {
                     Kind::empty(),
                 );
             }
+            host.last_frame_ns = Some(crate::state::now_ns());
             let output = host.output.clone();
             crate::fifo::presented(state, &output);
         }

Modified file: crates/monolith/src/state.rs+2 additions@@ -101,6 +101,7 @@ pub struct Services {
     pub power: crate::power::Power,
     pub commits: crate::stats::CommitStats,
     pub fifo: crate::fifo::Fifo,
+    pub timing: crate::timing::Timing,
 }
 
 /// The config and what is derived from it, swapped whole on reload.
@@ -222,6 +223,7 @@ impl State {
                 power: Default::default(),
                 commits: Default::default(),
                 fifo: Default::default(),
+                timing: Default::default(),
             },
         })
     }

Added file: crates/monolith/src/timing.rs+218 additions@@ -0,0 +1,218 @@
+//! wp_commit_timing_v1 timestamps. A commit holds until the first frame
+//! that can still be rendered and presents at or after its timestamp.
+
+use crate::pacing;
+use crate::state::{State, now_ns};
+use smithay::output::Output;
+use smithay::reexports::calloop::RegistrationToken;
+use smithay::reexports::calloop::timer::{TimeoutAction, Timer};
+use smithay::reexports::rustix::time::Timespec;
+use smithay::reexports::wayland_server::protocol::wl_surface::WlSurface;
+use smithay::reexports::wayland_server::{Resource, Weak};
+use smithay::utils::{Monotonic, Time};
+use smithay::wayland::commit_timing::{
+    CommitTimerBarrierStateUserData, CommitTimerStateUserData, Timestamp,
+};
+use smithay::wayland::compositor::with_states;
+use std::time::Duration;
+
+/// A timestamp may lie this fraction of a refresh past a vblank and still
+/// count for it. Clients aim at the vblank they computed, which our own
+/// estimate misses by microseconds.
+const SLACK_DIVISOR: u64 = 8;
+/// Past the start of the previous frame's render, so the wake never beats
+/// that frame's own timer to the commit.
+const AFTER_START_NS: u64 = 1_000_000;
+/// Timers for timestamps further out than this run again to recompute.
+const LONGEST_WAIT: Duration = Duration::from_secs(10);
+
+/// What a backend knows of one output's vblank timeline.
+#[derive(Clone, Copy)]
+pub struct Timeline {
+    pub last: u64,
+    /// Zero when vblanks are not on a fixed grid, as under VRR.
+    pub refresh: u64,
+    pub budget: u64,
+}
+
+#[derive(Default)]
+pub struct Timing {
+    waiting: Vec<Weak<WlSurface>>,
+    timer: Option<RegistrationToken>,
+}
+
+/// Notes a surface about to commit a timestamp, ahead of the smithay hook
+/// that turns it into a blocker.
+pub fn watch(state: &mut State, surface: &WlSurface) {
+    let stamped = with_states(surface, |s| {
+        s.data_map
+            .get::<CommitTimerStateUserData>()
+            .is_some_and(|t| t.borrow().timestamp.is_some())
+    });
+    if !stamped {
+        return;
+    }
+    let waiting = &mut state.services.timing.waiting;
+    if !waiting.iter().any(|w| w == surface) {
+        waiting.push(surface.downgrade());
+    }
+    wake(state, Duration::ZERO);
+}
+
+fn wake(state: &mut State, after: Duration) {
+    if let Some(token) = state.services.timing.timer.take() {
+        state.core.handle.remove(token);
+    }
+    let token = state
+        .core
+        .handle
+        .insert_source(Timer::from_duration(after), |_, _, state| {
+            state.services.timing.timer = None;
+            run(state);
+            TimeoutAction::Drop
+        });
+    match token {
+        Ok(token) => state.services.timing.timer = Some(token),
+        Err(e) => tracing::warn!("could not arm the commit timing timer: {e}"),
+    }
+}
+
+fn nanos(t: Timestamp) -> u64 {
+    let t = Timespec::from(Time::<Monotonic>::from(t));
+    let secs = u64::try_from(t.tv_sec).unwrap_or(0);
+    let sub = u64::try_from(t.tv_nsec).unwrap_or(0).min(999_999_999);
+    secs.saturating_mul(1_000_000_000).saturating_add(sub)
+}
+
+fn stamp(ns: u64) -> Timestamp {
+    Time::<Monotonic>::from(Timespec {
+        tv_sec: (ns / 1_000_000_000) as _,
+        tv_nsec: (ns % 1_000_000_000) as _,
+    })
+    .into()
+}
+
+fn output_of(state: &State, surface: &WlSurface) -> Option<Output> {
+    let root = crate::idle::root_surface(surface);
+    match state.wm.id_of(&root).and_then(|id| state.wm.window(id)) {
+        Some(window) => state
+            .wm
+            .space
+            .outputs_for_element(window)
+            .into_iter()
+            .next(),
+        None => state.wm.space.outputs().next().cloned(),
+    }
+}
+
+fn run(state: &mut State) {
+    let now = now_ns();
+    let mut clients = Vec::new();
+    let mut next: Option<u64> = None;
+    let mut still = Vec::new();
+    for weak in std::mem::take(&mut state.services.timing.waiting) {
+        let Ok(surface) = weak.upgrade() else {
+            continue;
+        };
+        let timeline = output_of(state, &surface).and_then(|o| state.backend.timeline(&o));
+        let pending = with_states(&surface, |s| {
+            let mut barriers = s
+                .data_map
+                .get::<CommitTimerBarrierStateUserData>()?
+                .lock()
+                .unwrap();
+            let mut signaled = false;
+            let mut wake = None;
+            while let Some(t) = barriers.next_deadline() {
+                match release(timeline, nanos(t), now) {
+                    Release::Now(covers) => signaled |= barriers.signal_until(stamp(covers)),
+                    Release::At(at) => {
+                        wake = Some(at);
+                        break;
+                    }
+                }
+            }
+            if signaled {
+                clients.extend(surface.client());
+            }
+            Some(wake)
+        });
+        if let Some(Some(at)) = pending {
+            next = Some(next.map_or(at, |n| n.min(at)));
+            still.push(weak);
+        }
+    }
+    state.services.timing.waiting.extend(still);
+    crate::fifo::unblock(state, clients);
+    if let Some(at) = next {
+        let after = Duration::from_nanos(at.saturating_sub(now_ns()).max(1_000_000));
+        wake(state, after.min(LONGEST_WAIT));
+    }
+}
+
+enum Release {
+    /// The commit may apply now, and so may every one stamped up to this time.
+    Now(u64),
+    /// The commit must wait until this time.
+    At(u64),
+}
+
+fn release(timeline: Option<Timeline>, target: u64, now: u64) -> Release {
+    let Some(tl) = timeline else {
+        return Release::Now(u64::MAX);
+    };
+    if tl.refresh == 0 {
+        let at = target.saturating_sub(tl.budget);
+        return if at <= now {
+            Release::Now(target)
+        } else {
+            Release::At(at)
+        };
+    }
+    let slack = tl.refresh / SLACK_DIVISOR;
+    let Some((reach, _)) = pacing::deadline(tl.last, tl.refresh, tl.budget, now) else {
+        return Release::Now(u64::MAX);
+    };
+    let aimed = target.saturating_sub(slack);
+    if aimed <= reach {
+        return Release::Now(reach + slack);
+    }
+    let first = (aimed - tl.last).div_ceil(tl.refresh);
+    let before = tl
+        .last
+        .saturating_add((first - 1).saturating_mul(tl.refresh));
+    Release::At(before.saturating_sub(tl.budget) + AFTER_START_NS)
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    const TL: Timeline = Timeline {
+        last: 1_000_000_000,
+        refresh: 10_000_000,
+        budget: 2_000_000,
+    };
+
+    #[test]
+    fn a_timestamp_waits_for_the_frame_after_the_one_being_drawn() {
+        let now = TL.last + 3_000_000;
+        let target = TL.last + 30_000_000;
+        let Release::At(at) = release(Some(TL), target, now) else {
+            panic!("a timestamp three frames out must wait");
+        };
+        assert_eq!(at, TL.last + 20_000_000 - TL.budget + AFTER_START_NS);
+        let Release::Now(covers) = release(Some(TL), target, at) else {
+            panic!("the wake must release it");
+        };
+        assert!(covers >= target);
+    }
+
+    #[test]
+    fn a_timestamp_a_hair_past_a_vblank_still_takes_it() {
+        let now = TL.last + 9_000_000;
+        let target = TL.last + 20_000_000 + TL.refresh / SLACK_DIVISOR;
+        assert!(matches!(release(Some(TL), target, now), Release::Now(_)));
+        assert!(matches!(release(Some(TL), target + 1, now), Release::At(_)));
+    }
+}

monolith

Commit a1f375a8b4be

Commit `a1f375a8b4be`