From e91a3788752c63c2ed086c553f9861056172e8c0 Mon Sep 17 00:00:00 2001 From: Gabriel Schneider Date: Thu, 29 Oct 2026 11:10:32 -0300 Subject: tty: a pane flooded with output (`yes`) is read on to its end, not left blocked for good while keys still work vaxis's event queue woke one blocked writer, and only on the pop from full. The tty's loop has two writers on it: a pane's pty reader, and the input reader posting the wake for a frame's answered status request (FrameAck). Under `yes` both block on the full queue; the loop then takes a whole batch, its first pop wakes one of them, the rest wake no one, and the pty reader waits for good: the program in the pane blocks writing to its pty, the pane stops moving, and every key still works. It happened from about 400 KB of output, every time at 1 MB, through the snapshot harness's pty as through a terminal. build.zig patches vaxis's src/queue.zig at build time, count-checked as its Parser.zig and Vaxis.zig are: a pop that makes room wakes every blocked writer. A test (src/vaxis_input.zig) empties a full queue in one batch with two writers waiting and requires both to land. `yes | head -c N` through a bash pane in tty mode now finishes at 1 MB, 10 MB, 100 MB (16 s) and 1 GB (179 s, test/perf.zig --live). Co-Authored-By: Claude Opus 5.5 --- src/vaxis_input.zig | 31 +++++++++++++++++++++++++++++++ 1 file changed, 31 insertions(+) (limited to 'src/vaxis_input.zig') diff --git a/src/vaxis_input.zig b/src/vaxis_input.zig index 0e25dea1..59846d0f 100644 --- a/src/vaxis_input.zig +++ b/src/vaxis_input.zig @@ -75,3 +75,34 @@ test "F-keys, Insert and the keypad map to the core's keys" { try std.testing.expectEqual(pardes.Key.enter, keyEvent(.{ .codepoint = vaxis.Key.kp_enter }).key.cp); try std.testing.expectEqual(@as(u21, 'a'), mapKey('a')); } + +test "an event queue emptied in one batch lets every writer it held go on (build.zig's patch)" { + const io = std.testing.io; + const Q = vaxis.Queue(u8, 2); + var q: Q = .init(io); + try q.push(1); + try q.push(2); + const Writer = struct { + fn run(queue: *Q, byte: u8) !void { + try queue.push(byte); + } + }; + // Two writers waiting on the full queue, as a pane's pty reader and + // the frame ack's wake do under `yes`. + var a = try io.concurrent(Writer.run, .{ &q, 3 }); + defer a.cancel(io) catch {}; + var b = try io.concurrent(Writer.run, .{ &q, 4 }); + defer b.cancel(io) catch {}; + try io.sleep(.fromMilliseconds(20), .awake); + // The loop takes both at once: one pop from full, then one more. + try q.lock(); + _ = q.drain().?; + _ = q.drain().?; + q.unlock(); + var got: usize = 0; + var waited: usize = 0; + while (got < 2 and waited < 200) : (waited += 1) { + if (try q.tryPop() != null) got += 1 else try io.sleep(.fromMilliseconds(5), .awake); + } + try std.testing.expectEqual(@as(usize, 2), got); +} -- cgit v1.3