Step core animation by the shell's clock and sleep to the next wake

A shell now answers Host.now, its monotonic clock in ns, and the pump
advances core animation to it: one .tick per whole 16 ms frame since core
time last stood still. The same animation therefore takes the same time at
60, 120 and 144 Hz, over ssh and after a slow frame (the GUI's re-armed
clock ran them ~25% slow at 144 Hz; the tty's post-frame sleep drifted).
nextWake() lists every core animation in one place: a frame from now while
anything moves, the end of the wait while something only waits (a message
lingering, the look-hover delay), null when idle. Shells sleep exactly that
long, and a wait is jumped to its end in one step, so an 800 ms linger
costs one frame instead of fifty. An overshoot under 1.5 ms after a step is
let go: at 60 and 120 Hz every display frame takes exactly one step (a 16 ms
frame against a 16.67 ms vsync would otherwise double-step every 24th).

The six tick drivers are gone: tty's timer thread only times the wait,
interruptibly (a newer, shorter request cuts short a sleep still timing a
longer one); the GUI's
AnimationClock, web's JS tick bank (pardes_tick now takes rAF's timestamp),
the detached server's and the board's ticks; grid mode steps a virtual
clock straight to each wake. PARDES_TEST_CLOCK, set by the snapshot
harness, gives tty and the detached server the same virtual clock.

Every stepped frame is drawn. The old pump never drew the last frame of a
fade (a .tick asks for no frame, and the fade was over by the check), so a
theme switch stopped at 9/10 of the way until the next input: theme.golden,
themesel.golden and the GUI's acme-light scene move to the theme's true
colours, and nothing else changes. The frozen previous grid is captured only
while a panel transition is chosen, not on every idle frame.

1 files changed, 91 insertions, 17 deletions

diff --git a/src/tty/tty.zig b/src/tty/tty.zig
index 66e551b1..6083f609 100644
--- a/src/tty/tty.zig
+++ b/src/tty/tty.zig
@@ -76,7 +76,8 @@ pub const Command = struct {
     pub var value: union(enum) {
         nop,
         quit,
-        tick,
+        /// A timed wait ran out: the core's next wake has come.
+        wake,
         key_press: vaxis.Key,
         pty_read: struct { id: usize, gen: u32, bytes: []u8 },
         pty_eof: struct { id: usize, gen: u32 },
@@ -728,6 +729,7 @@ fn localSession(
         .paste_buf = paste_buf,
         .inotify_fd = file_watch.init(false),
         .fs = fs,
+        .test_clock = host_io.testClock(),
     };
     pardes.lsp.setStatusSink(&sh, lspStatusSink);
     defer {
@@ -775,7 +777,7 @@ fn localSession(
     try startInput(loop, input_cache);
     defer if (attached.* == null) stopInput(loop);
     (try std.Thread.spawn(.{}, winchWatch, .{ loop, vx, tty })).detach();
-    (try std.Thread.spawn(.{}, tickWatch, .{ io, loop })).detach();
+    (try std.Thread.spawn(.{}, wakeWatch, .{ io, loop })).detach();
     if (fs) |f| try f.watch(loop, wakeFs);
     try vx.queryTerminalSend(tty.writer());
 
@@ -900,6 +902,10 @@ const Shell = struct {
     check_files: bool = false,
     in_paste: bool = false,
     tracks: []const pardes.animation.Track = &.{},
+    /// PARDES_TEST_CLOCK's virtual time (host_io.testClock), and where the
+    /// running-out wait moves it: the core's next wake.
+    test_clock: ?u64 = null,
+    wake_to: u64 = 0,
 
     fn of(ctx: ?*anyopaque) *Shell {
         return @ptrCast(@alignCast(ctx.?));
@@ -911,12 +917,14 @@ const Shell = struct {
 
     const isolated_vtable: host_io.Host.VTable = .{
         .wait_input = waitInput,
+        .now = clockNow,
         .present = present,
         .post_present = postPresent,
     };
 
     const vtable: host_io.Host.VTable = .{
         .wait_input = waitInput,
+        .now = clockNow,
         .present = present,
         .post_present = postPresent,
         .poll_frame = pollFrame,
@@ -939,12 +947,20 @@ const Shell = struct {
         .pipe = pipe,
     };
 
+    fn clockNow(ctx: ?*anyopaque) u64 {
+        const s = of(ctx);
+        return s.test_clock orelse host_io.monotonicNs();
+    }
+
     fn waitInput(ctx: ?*anyopaque, timeout_ms: u32) void {
         const s = of(ctx);
         var batch: usize = 0;
-        // The wait is the 9P connections' turn with the core. Animating, the
-        // frame's tick arrives through the same queue (`tickWatch`).
-        if (timeout_ms != 0) tick_request.set(s.io);
+        // The wait is the 9P connections' turn with the core. A timeout (the
+        // core's next wake) arrives through the same queue (`wakeWatch`).
+        if (timeout_ms != 0) {
+            s.wake_to = s.core.nextWake() orelse 0;
+            requestWake(s.io, timeout_ms);
+        }
         pardes.turn.rest();
         const first = s.loop.nextEvent() catch {
             pardes.turn.wake();
@@ -984,7 +1000,9 @@ const Shell = struct {
         defer tz_event.end();
         switch (event) {
             .nop => {},
-            .tick => core.update(.tick),
+            .wake => if (s.test_clock) |*virtual| {
+                virtual.* = @max(virtual.*, s.wake_to);
+            },
             .quit => {
                 core.quit = true;
                 return true;
@@ -1523,21 +1541,77 @@ fn winchWatch(loop: *Loop, vx: *vaxis.Vaxis, tty: *vaxis.Tty) void {
     }
 }
 
-/// Set by an animating frame's wait: post one `.tick` a frame from now. The
-/// tick joins the input queue, so a key or a click that lands inside the
-/// frame is handled at once instead of after a blind sleep.
-var tick_request: std.Io.Event = .unset;
+/// A wait with a timeout: post one `.wake` when it runs out. The wake joins
+/// the input queue, so a key or a click that lands first is handled at once
+/// instead of after a blind sleep; vaxis's queue has no timed wait. Each
+/// request bumps `wake_gen`, which cuts short a sleep still timing an
+/// earlier, longer request (an 800 ms linger interrupted by a key that
+/// starts a 16 ms fall) and times the new one instead.
+var wake_gen: std.atomic.Value(u32) = .init(0);
+var wake_ms: std.atomic.Value(u32) = .init(0);
 
-fn tickWatch(io: std.Io, loop: *Loop) void {
+fn requestWake(io: std.Io, ms: u32) void {
+    wake_ms.store(ms, .release);
+    _ = wake_gen.fetchAdd(1, .acq_rel);
+    io.futexWake(u32, &wake_gen.raw, 1);
+}
+
+fn wakeWatch(io: std.Io, loop: *Loop) void {
+    var seen = wake_gen.load(.acquire);
     while (true) {
-        tick_request.waitUncancelable(io);
-        tick_request.reset();
-        var ts: libc.timespec = .{ .sec = 0, .nsec = @as(isize, pardes.animation.Animation.frame_ms) * std.time.ns_per_ms };
-        _ = libc.nanosleep(&ts, null);
-        loop.postEvent(.tick) catch {};
+        // Asleep until a request.
+        while (wake_gen.load(.acquire) == seen) io.futexWaitUncancelable(u32, &wake_gen.raw, seen);
+        seen = wake_gen.load(.acquire);
+        if (timeWake(io, &seen)) loop.postEvent(.wake) catch {};
     }
 }
 
+/// Sleep out the latest request; true when it ran its course, false when
+/// none is pending. A newer request met on the way restarts the timing.
+fn timeWake(io: std.Io, seen: *u32) bool {
+    while (true) {
+        const ms = wake_ms.load(.acquire);
+        const deadline = host_io.monotonicNs() + @as(u64, ms) * std.time.ns_per_ms;
+        while (true) {
+            const now = host_io.monotonicNs();
+            if (now >= deadline) return true;
+            io.futexWaitTimeout(u32, &wake_gen.raw, seen.*, .{ .duration = .{
+                .raw = .fromNanoseconds(@intCast(deadline - now)),
+                .clock = .awake,
+            } }) catch {};
+            const gen = wake_gen.load(.acquire);
+            if (gen != seen.*) {
+                seen.* = gen;
+                break;
+            }
+        }
+    }
+}
+
+test "a short wake request cuts short a long one still sleeping" {
+    const io = std.testing.io;
+    var seen = wake_gen.load(.acquire);
+    requestWake(io, 800);
+    seen = wake_gen.load(.acquire);
+    const Timer = struct {
+        fn run(timer_io: std.Io, start_seen: u32, done: *std.atomic.Value(u64)) void {
+            var local = start_seen;
+            _ = timeWake(timer_io, &local);
+            done.store(host_io.monotonicNs(), .release);
+        }
+    };
+    var done: std.atomic.Value(u64) = .init(0);
+    const start = host_io.monotonicNs();
+    const thread = try std.Thread.spawn(.{}, Timer.run, .{ io, seen, &done });
+    var pause: std.c.timespec = .{ .sec = 0, .nsec = 50 * std.time.ns_per_ms };
+    _ = std.c.nanosleep(&pause, null);
+    requestWake(io, 16);
+    thread.join();
+    // The 16 ms request lands about 66 ms in: well before the 800 ms one
+    // would have, however loaded the machine.
+    try std.testing.expect(done.load(.acquire) - start < 700 * std.time.ns_per_ms);
+}
+
 fn wakeFs(ctx: ?*anyopaque) void {
     const loop: *Loop = @ptrCast(@alignCast(ctx.?));
     _ = loop.tryPostEvent(.fs_ready) catch {};
@@ -1822,7 +1896,7 @@ const Attach = struct {
 
     fn apply(a: *Attach, event: @TypeOf(Command.value)) ?AttachEnd {
         switch (event) {
-            .nop, .tick, .fs_ready, .lsp_done, .lsp_status, .pipe_done, .pty_read, .pty_eof, .files_changed => {},
+            .nop, .wake, .fs_ready, .lsp_done, .lsp_status, .pipe_done, .pty_read, .pty_eof, .files_changed => {},
             .quit => return .none,
             .focus_in => {},
             .focus_out => return a.send(.pointer_leave),