Merge pull request #307 from charliek/feature/plan-018-gtk-dirty-rows

Engine track E4 no-go + E3b: GTK dirty-row rebuild and real render_stats

Author: charliek

crates/roost-iced/src/perf.rs

@@ -26,95 +26,38 @@
 //!   tests don't construct. There is no per-tab equivalent of them for the
 //!   same reason — see [`TabRenderStats`].
 
-use std::sync::atomic::{AtomicU64, Ordering};
 use std::time::Duration;
 
-static REFRESH_CALLS: AtomicU64 = AtomicU64::new(0);
-static REFRESH_NANOS: AtomicU64 = AtomicU64::new(0);
-static ROWS_REBUILT: AtomicU64 = AtomicU64::new(0);
-static CELLS_WALKED: AtomicU64 = AtomicU64::new(0);
-static DRAW_CALLS: AtomicU64 = AtomicU64::new(0);
-static DRAW_NANOS: AtomicU64 = AtomicU64::new(0);
-static FILL_TEXT_CALLS: AtomicU64 = AtomicU64::new(0);
+/// `RenderStats` + `TabRenderStats` + the atomic aggregate machinery moved
+/// to `roost-ui-model::render_stats` once GTK needed the identical shape
+/// (plan 018 D4); re-exported here so every call site in this crate keeps
+/// compiling unchanged.
+pub use roost_ui_model::render_stats::{RenderStats, TabRenderStats};
 
-/// A read of the process-global aggregate at one instant. Every field is a
-/// running total since process start (or the last [`reset`]).
-#[derive(Debug, Clone, Copy, Default, PartialEq, Eq)]
-pub struct RenderStats {
-    pub refresh_calls: u64,
-    pub refresh_nanos: u64,
-    pub rows_rebuilt: u64,
-    pub cells_walked: u64,
-    pub draw_calls: u64,
-    pub draw_nanos: u64,
-    pub fill_text_calls: u64,
-}
-
-/// Per-tab counters, folded into the global aggregate on every refresh.
-/// There is deliberately no per-tab equivalent of `draw_calls` /
-/// `draw_nanos` / `fill_text_calls`: `TerminalWidget::draw` renders from a
-/// `TerminalSnapshot` clone handed to it by iced and has no way back to the
-/// `TerminalTab` that produced it, so those three counters only exist in
-/// the global aggregate.
-#[derive(Debug, Clone, Copy, Default, PartialEq, Eq)]
-pub struct TabRenderStats {
-    pub refresh_calls: u64,
-    pub refresh_nanos: u64,
-    pub rows_rebuilt: u64,
-    pub cells_walked: u64,
-}
+use roost_ui_model::render_stats::RenderStatsAggregate;
 
-impl TabRenderStats {
-    pub(crate) fn record_refresh(
-        &mut self,
-        elapsed: Duration,
-        rows_rebuilt: u64,
-        cells_walked: u64,
-    ) {
-        self.refresh_calls += 1;
-        self.refresh_nanos += elapsed.as_nanos() as u64;
-        self.rows_rebuilt += rows_rebuilt;
-        self.cells_walked += cells_walked;
-    }
-}
+/// This UI's process-global aggregate. GTK holds its own in
+/// `roost-linux::perf`; the two never mix.
+static AGGREGATE: RenderStatsAggregate = RenderStatsAggregate::new();
 
 /// Read the global aggregate. Backs the `app.render_stats` IPC op.
 pub fn snapshot() -> RenderStats {
-    RenderStats {
-        refresh_calls: REFRESH_CALLS.load(Ordering::Relaxed),
-        refresh_nanos: REFRESH_NANOS.load(Ordering::Relaxed),
-        rows_rebuilt: ROWS_REBUILT.load(Ordering::Relaxed),
-        cells_walked: CELLS_WALKED.load(Ordering::Relaxed),
-        draw_calls: DRAW_CALLS.load(Ordering::Relaxed),
-        draw_nanos: DRAW_NANOS.load(Ordering::Relaxed),
-        fill_text_calls: FILL_TEXT_CALLS.load(Ordering::Relaxed),
-    }
+    AGGREGATE.snapshot()
 }
 
 /// Zero the global aggregate. Useful before an operation known to skew it
 /// (see the screenshot trap above) so the next read is uncontaminated.
 /// Exposed over IPC as `app.render_stats` with `reset: true`.
 pub fn reset() {
-    REFRESH_CALLS.store(0, Ordering::Relaxed);
-    REFRESH_NANOS.store(0, Ordering::Relaxed);
-    ROWS_REBUILT.store(0, Ordering::Relaxed);
-    CELLS_WALKED.store(0, Ordering::Relaxed);
-    DRAW_CALLS.store(0, Ordering::Relaxed);
-    DRAW_NANOS.store(0, Ordering::Relaxed);
-    FILL_TEXT_CALLS.store(0, Ordering::Relaxed);
+    AGGREGATE.reset();
 }
 
 /// Fold one `refresh_snapshot` call into the global aggregate.
 pub(crate) fn record_refresh(elapsed: Duration, rows_rebuilt: u64, cells_walked: u64) {
-    REFRESH_CALLS.fetch_add(1, Ordering::Relaxed);
-    REFRESH_NANOS.fetch_add(elapsed.as_nanos() as u64, Ordering::Relaxed);
-    ROWS_REBUILT.fetch_add(rows_rebuilt, Ordering::Relaxed);
-    CELLS_WALKED.fetch_add(cells_walked, Ordering::Relaxed);
+    AGGREGATE.record_refresh(elapsed, rows_rebuilt, cells_walked);
 }
 
 /// Fold one `TerminalWidget::draw` call into the global aggregate.
 pub(crate) fn record_draw(elapsed: Duration, fill_text_calls: u64) {
-    DRAW_CALLS.fetch_add(1, Ordering::Relaxed);
-    DRAW_NANOS.fetch_add(elapsed.as_nanos() as u64, Ordering::Relaxed);
-    FILL_TEXT_CALLS.fetch_add(fill_text_calls, Ordering::Relaxed);
+    AGGREGATE.record_draw(elapsed, fill_text_calls);
 }

crates/roost-linux/src/app.rs

@@ -1099,15 +1099,20 @@ impl App {
                         UiRequest::WindowMetrics { reply } => {
                             let _ = reply.send(app.ipc_window_metrics());
                         }
-                        UiRequest::AppRenderStats { reset: _, reply } => {
-                            // Deliberate placeholder: the GTK renderer has no
-                            // perf instrumentation yet (roadmap slice E3b).
-                            // Zeros keep the op's contract identical on both
-                            // Rust UIs — refusing here would make this the
-                            // first op one Rust UI answers and the other
-                            // doesn't, and there is no `unsupported` error
-                            // code to refuse with.
-                            let _ = reply.send(Ok(AppRenderStatsResult::default()));
+                        UiRequest::AppRenderStats { reset, reply } => {
+                            let stats = crate::perf::snapshot();
+                            if reset {
+                                crate::perf::reset();
+                            }
+                            let _ = reply.send(Ok(AppRenderStatsResult {
+                                refresh_calls: stats.refresh_calls as i64,
+                                refresh_nanos: stats.refresh_nanos as i64,
+                                rows_rebuilt: stats.rows_rebuilt as i64,
+                                cells_walked: stats.cells_walked as i64,
+                                draw_calls: stats.draw_calls as i64,
+                                draw_nanos: stats.draw_nanos as i64,
+                                fill_text_calls: stats.fill_text_calls as i64,
+                            }));
                         }
                         UiRequest::SidebarDump { reply } => {
                             let _ = reply.send(app.ipc_sidebar_dump());

crates/roost-linux/src/main.rs

@@ -26,6 +26,7 @@ mod notification_inbox;
 mod palette;
 mod palette_ui;
 mod paste_image;
+mod perf;
 mod provider;
 mod rollup;
 mod sprite;

crates/roost-linux/src/perf.rs

@@ -0,0 +1,53 @@
+//! GTK render performance instrumentation. Counters and timings only —
+//! the shapes and the atomic machinery live in
+//! [`roost_ui_model::render_stats`]; this module is just this UI's
+//! process-global instance plus thin shims. `roost-iced` has the exact
+//! same shape over its own aggregate; the two never mix.
+//!
+//! GTK counter semantics (they differ from iced's, so read this before
+//! comparing numbers across the two UIs):
+//!
+//! - GTK's `paint` is refresh *and* draw in one pass. The seam is
+//!   `TerminalViewState::refresh_cache` (renderer-free: `update` +
+//!   dirty-row walk + counters, no Cairo) — `refresh_*` counts that phase,
+//!   `draw_*` counts the Cairo phase that consumes its output. One
+//!   `paint` therefore folds in exactly one refresh and one draw, unlike
+//!   iced where a refresh (on PTY output) and a draw (on window redraw)
+//!   are independently scheduled.
+//! - `fill_text_calls` counts `pango_cairo::show_layout` calls **plus**
+//!   sprite draws, because a sprite *replaces* a glyph draw — the number
+//!   means "glyph draws the pass emitted". iced has no sprite path
+//!   (roadmap E5), so this field is not apples-to-apples across UIs.
+//! - `rows_rebuilt` / `cells_walked` mean the same as iced: rows visited
+//!   by the walk and cells handed to the per-cell callback.
+//!
+//! Per-tab counters live on `TerminalViewState::render_stats` (a
+//! non-atomic [`roost_ui_model::render_stats::TabRenderStats`]); the
+//! aggregate here is what the `app.render_stats` IPC op reads.
+
+use std::time::Duration;
+
+use roost_ui_model::render_stats::{RenderStats, RenderStatsAggregate};
+
+static AGGREGATE: RenderStatsAggregate = RenderStatsAggregate::new();
+
+/// Read the global aggregate. Backs the `app.render_stats` IPC op.
+pub(crate) fn snapshot() -> RenderStats {
+    AGGREGATE.snapshot()
+}
+
+/// Zero the global aggregate. Exposed over IPC as `app.render_stats`
+/// with `reset: true`.
+pub(crate) fn reset() {
+    AGGREGATE.reset();
+}
+
+/// Fold one `refresh_cache` call into the global aggregate.
+pub(crate) fn record_refresh(elapsed: Duration, rows_rebuilt: u64, cells_walked: u64) {
+    AGGREGATE.record_refresh(elapsed, rows_rebuilt, cells_walked);
+}
+
+/// Fold one `paint` Cairo phase into the global aggregate.
+pub(crate) fn record_draw(elapsed: Duration, fill_text_calls: u64) {
+    AGGREGATE.record_draw(elapsed, fill_text_calls);
+}