monolith

public

Star0

Fork 0

Watch0

250 commits 1 branch 0 tags 0 releases1.5 MiB

Commit `df646f6621c6`

tarball

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

9 files changed+199-6

fifo: add wp_fifo_v1 with barriers cleared on presentation

Mesa's FIFO present mode and Proton wait on wp_fifo_v1 for pacing, and without the global they fall back to frame callbacks alone. A render latches the barriers of the surfaces it shows and the output's vblank or the host frame callback clears them. A held barrier is cleared after 100 ms regardless, since hidden or covered surfaces are never latched and the protocol lets the compositor release them.

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

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

104104 }

105105 self.layer_commit(surface);

106106 self.send_scale_once(surface);

107+ crate::fifo::applied(self, surface);

107108 self.dirty.redraw = true;

108109 }

109110 }

Modified file: crates/monolith/src/drm.rs+11 additions@@ -681,6 +681,14 @@ impl Drm {
 }
 
 fn on_vblank(state: &mut State, crtc: crtc::Handle, meta: &mut Option<DrmEventMetadata>) {
+    let presented = state
+        .backend
+        .drm()
+        .and_then(|d| d.surfaces.get(&crtc))
+        .map(|s| s.output.clone());
+    if let Some(output) = presented {
+        crate::fifo::presented(state, &output);
+    }
     let Some(surface) = state
         .backend
         .drm_mut()
@@ -1118,6 +1126,9 @@ fn render_surface(state: &mut State, crtc: crtc::Handle, target: u64) -> bool {
     }
     surface.failures = if failed { surface.failures + 1 } else { 0 };
     surface.redraw = animating || failed;
+    if !surface.queued {
+        crate::fifo::release_idle(&core.handle, &surface.output);
+    }
     let elapsed = core.start.elapsed();
     crate::frame::send_frame_callbacks(
         wm,

Added file: crates/monolith/src/fifo.rs+165 additions@@ -0,0 +1,165 @@
+//! wp_fifo_v1 barriers. The first render that shows a commit holding a
+//! barrier latches it on the output, and presenting that frame clears it.
+
+use crate::state::{State, now_ns};
+use smithay::output::Output;
+use smithay::reexports::calloop::timer::{TimeoutAction, Timer};
+use smithay::reexports::calloop::{LoopHandle, RegistrationToken};
+use smithay::reexports::wayland_server::protocol::wl_surface::WlSurface;
+use smithay::reexports::wayland_server::{Client, Resource, Weak};
+use smithay::wayland::compositor::{Barrier, CompositorHandler, SurfaceData, with_states};
+use smithay::wayland::fifo::FifoBarrierCachedState;
+use std::sync::Mutex;
+use std::time::Duration;
+
+/// How long a barrier may outlive its commit before it is cleared anyway. A
+/// surface no render shows, hidden or covered or on a dark output, never
+/// gets its barrier latched, and the protocol lets the compositor clear it
+/// so the client keeps making progress.
+const HELD_NS: u64 = 100_000_000;
+const SWEEP: Duration = Duration::from_millis(50);
+
+#[derive(Default)]
+pub struct Fifo {
+    held: Vec<(Weak<WlSurface>, u64)>,
+    sweeping: Option<RegistrationToken>,
+}
+
+#[derive(Default)]
+struct Latched(Mutex<Vec<(Barrier, Client)>>);
+
+/// The primary scanout choice for frame callbacks on `output`, which also
+/// latches the barriers of every surface it visits.
+pub fn scanout(
+    output: &Output,
+) -> impl FnMut(&WlSurface, &SurfaceData) -> Option<Output> + Copy + '_ {
+    move |surface, states| {
+        latch(output, surface, states);
+        Some(output.clone())
+    }
+}
+
+fn latch(output: &Output, surface: &WlSurface, states: &SurfaceData) {
+    if !states.cached_state.has::<FifoBarrierCachedState>() {
+        return;
+    }
+    let barrier = states
+        .cached_state
+        .get::<FifoBarrierCachedState>()
+        .current()
+        .barrier
+        .clone()
+        .filter(|b| !b.is_signaled());
+    let (Some(barrier), Some(client)) = (barrier, surface.client()) else {
+        return;
+    };
+    let latched = output
+        .user_data()
+        .get_or_insert_threadsafe(Latched::default);
+    let mut held = latched.0.lock().unwrap();
+    held.retain(|(b, _)| !b.is_signaled());
+    if !held.iter().any(|(b, _)| *b == barrier) {
+        held.push((barrier, client));
+    }
+}
+
+/// Clears what the last frame on `output` latched.
+pub fn presented(state: &mut State, output: &Output) {
+    let Some(latched) = output.user_data().get::<Latched>() else {
+        return;
+    };
+    let released = std::mem::take(&mut *latched.0.lock().unwrap());
+    unblock(
+        state,
+        released.into_iter().map(|(barrier, client)| {
+            barrier.signal();
+            client
+        }),
+    );
+}
+
+/// For a render that queued nothing, so no flip will report it presented.
+pub fn release_idle(handle: &LoopHandle<'static, State>, output: &Output) {
+    let output = output.clone();
+    handle.insert_idle(move |state| presented(state, &output));
+}
+
+/// Lets the commits of `clients` that were waiting on a signaled blocker apply.
+pub fn unblock(state: &mut State, clients: impl IntoIterator<Item = Client>) {
+    let dh = state.core.display.clone();
+    let mut done = Vec::new();
+    for client in clients {
+        if done.contains(&client.id()) {
+            continue;
+        }
+        done.push(client.id());
+        state
+            .client_compositor_state(&client)
+            .blocker_cleared(state, &dh);
+    }
+}
+
+/// Starts the clock on a barrier a commit just made current.
+pub fn applied(state: &mut State, surface: &WlSurface) {
+    let held = with_states(surface, |s| {
+        s.cached_state.has::<FifoBarrierCachedState>()
+            && s.cached_state
+                .get::<FifoBarrierCachedState>()
+                .current()
+                .barrier
+                .as_ref()
+                .is_some_and(|b| !b.is_signaled())
+    });
+    if !held {
+        return;
+    }
+    let now = now_ns();
+    let fifo = &mut state.services.fifo;
+    match fifo.held.iter_mut().find(|(s, _)| s == surface) {
+        Some((_, since)) => *since = now,
+        None => fifo.held.push((surface.downgrade(), now)),
+    }
+    if fifo.sweeping.is_none() {
+        match state
+            .core
+            .handle
+            .insert_source(Timer::from_duration(SWEEP), |_, _, state| sweep(state))
+        {
+            Ok(token) => fifo.sweeping = Some(token),
+            Err(e) => tracing::warn!("could not arm the fifo sweep: {e}"),
+        }
+    }
+}
+
+fn sweep(state: &mut State) -> TimeoutAction {
+    let now = now_ns();
+    let mut clients = Vec::new();
+    state.services.fifo.held.retain(|(weak, since)| {
+        let Ok(surface) = weak.upgrade() else {
+            return false;
+        };
+        with_states(&surface, |s| {
+            let barrier = s
+                .cached_state
+                .get::<FifoBarrierCachedState>()
+                .current()
+                .barrier
+                .clone();
+            let Some(barrier) = barrier.filter(|b| !b.is_signaled()) else {
+                return false;
+            };
+            if now.saturating_sub(*since) < HELD_NS {
+                return true;
+            }
+            barrier.signal();
+            clients.extend(surface.client());
+            false
+        })
+    });
+    unblock(state, clients);
+    if state.services.fifo.held.is_empty() {
+        state.services.fifo.sweeping = None;
+        return TimeoutAction::Drop;
+    }
+    TimeoutAction::ToDuration(SWEEP)
+}

Modified file: crates/monolith/src/frame.rs+6 additions−3 deletions@@ -109,9 +109,12 @@ pub fn send_frame_callbacks(
     }
     let (windows, covered) = shown_windows(wm, o, output, now);
     for window in windows {
-        window.send_frame(output, elapsed, Some(Duration::ZERO), |_, _| {
-            Some(output.clone())
-        });
+        window.send_frame(
+            output,
+            elapsed,
+            Some(Duration::ZERO),
+            crate::fifo::scanout(output),
+        );
     }
     crate::layers::send_frames(output, elapsed, covered);
     if let Some(geo) = wm.space.output_geometry(output) {

Modified file: crates/monolith/src/globals.rs+3 additions@@ -13,6 +13,7 @@ use smithay::utils::{ClockSource, Monotonic};
 use smithay::wayland::compositor::CompositorState;
 use smithay::wayland::cursor_shape::CursorShapeManagerState;
 use smithay::wayland::dmabuf::{DmabufFeedbackBuilder, DmabufGlobal, DmabufState};
+use smithay::wayland::fifo::FifoManagerState;
 use smithay::wayland::foreign_toplevel_list::ForeignToplevelListState;
 use smithay::wayland::fractional_scale::FractionalScaleManagerState;
 use smithay::wayland::idle_inhibit::IdleInhibitManagerState;
@@ -76,6 +77,7 @@ pub struct Protocols {
     _presentation: PresentationState,
     _relative_pointer: RelativePointerManagerState,
     _pointer_constraints: PointerConstraintsState,
+    _fifo: FifoManagerState,
 }
 
 impl Protocols {
@@ -143,6 +145,7 @@ impl Protocols {
             _presentation: PresentationState::new::<State>(dh, Monotonic::ID as u32),
             _relative_pointer: RelativePointerManagerState::new::<State>(dh),
             _pointer_constraints: PointerConstraintsState::new::<State>(dh),
+            _fifo: FifoManagerState::new::<State>(dh),
         }
     }
 }

Modified file: crates/monolith/src/layers.rs+6 additions−3 deletions@@ -303,9 +303,12 @@ pub fn send_frames(output: &Output, elapsed: Duration, covered: bool) {
         if covered && l.layer() != Layer::Overlay {
             continue;
         }
-        l.send_frame(output, elapsed, Some(Duration::ZERO), |_, _| {
-            Some(output.clone())
-        });
+        l.send_frame(
+            output,
+            elapsed,
+            Some(Duration::ZERO),
+            crate::fifo::scanout(output),
+        );
     }
 }
 

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

@@ -8,6 +8,7 @@ mod constraints;

88 mod cursor;

99 mod devices;

1010 mod drm;

11+mod fifo;

1112 mod focus;

1213 mod frame;

1314 mod globals;

Modified file: crates/monolith/src/nested/mod.rs+4 additions@@ -329,6 +329,8 @@ pub fn render(state: &mut State) {
             host.surface.commit();
             host.frame_pending = true;
             let _ = host.conn.flush();
+        } else {
+            crate::fifo::release_idle(&core.handle, &host.output);
         }
         return;
     };
@@ -554,6 +556,8 @@ impl Dispatch<wl_callback::WlCallback, ()> for State {
                     Kind::empty(),
                 );
             }
+            let output = host.output.clone();
+            crate::fifo::presented(state, &output);
         }
     }
 }

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

monolith

Commit df646f6621c6

Commit `df646f6621c6`