From e32f749c80468b9e2fc79eb068f7088527a9c504 Mon Sep 17 00:00:00 2001 From: Gabriel Schneider Date: Wed, 4 Nov 2026 23:55:49 -0300 Subject: benches out of the binary: screen_state's corpus soak, encode bench and floods (PARDES_SCREEN_STATE=, which nothing sets) are `zig build replicas -- --screen-state `, replica.zig's big-file digest bench (PARDES_DIGEST_BENCH) is the last of rollback-bench, and Store's timings (STORE_TIMES) go, no bench step taking a store Co-Authored-By: Claude Opus 5.5 Claude-Session: https://claude.ai/code/session_016Y9MNAtZenFv4weoMD3cge --- src/screen_state.zig | 179 +-------------------------------------------------- 1 file changed, 1 insertion(+), 178 deletions(-) (limited to 'src/screen_state.zig') diff --git a/src/screen_state.zig b/src/screen_state.zig index 8ae9149d..53288c7e 100644 --- a/src/screen_state.zig +++ b/src/screen_state.zig @@ -33,7 +33,7 @@ const std = @import("std"); const vt = @import("ghostty-vt"); const snapshot = vt.snapshot; -const Terminal = vt.Terminal; +pub const Terminal = vt.Terminal; const Page = vt.page.Page; const Row = vt.page.Row; const Pin = vt.Pin; @@ -1083,185 +1083,8 @@ pub fn soak(gpa: std.mem.Allocator, io: std.Io, bytes: []const u8, cols: u16, ro return s.stats; } -/// Every recorded pty stream in `dir` (a `-x` in its name sizes -/// it, 80x24 otherwise) through a soak at three seeds, then the encode's -/// cost and the bytes floods put on the wire: the test below, when -/// PARDES_SCREEN_STATE names the directory (numbers from a ReleaseFast -/// build: `zig build core-test -Doptimize=ReleaseFast -Dtest-filter=screen_state`). -fn perf(gpa: std.mem.Allocator, io: std.Io, dir_path: []const u8, w: *std.Io.Writer) !void { - var dir = try std.Io.Dir.cwd().openDir(io, dir_path, .{ .iterate = true }); - defer dir.close(io); - var it = dir.iterate(); - var files: usize = 0; - var failed: usize = 0; - while (try it.next(io)) |entry| { - if (entry.kind != .file) continue; - const bytes = try dir.readFileAlloc(io, entry.name, gpa, .unlimited); - defer gpa.free(bytes); - var cols: u16 = 80; - var rows: u16 = 24; - if (std.mem.lastIndexOfScalar(u8, entry.name, '-')) |dash| { - const size = std.mem.sliceTo(entry.name[dash + 1 ..], '.'); - if (std.mem.indexOfScalar(u8, size, 'x')) |x| { - cols = std.fmt.parseInt(u16, size[0..x], 10) catch cols; - rows = std.fmt.parseInt(u16, size[x + 1 ..], 10) catch rows; - } - } - files += 1; - for (0..3) |seed| { - const st = soak(gpa, io, bytes, cols, rows, 128 * 1024, seed, seed != 0) catch |err| { - try w.print("screen-state {s} seed {d}: {s}\n", .{ entry.name, seed, @errorName(err) }); - failed += 1; - continue; - }; - if (seed == 0) try w.print("screen-state {s} {d}x{d}: {d} bytes, {d} deltas ({d} lost, {d} refused, {d} in flight at most), {d} wire bytes, {d} history rows checked, {d} fetched\n", .{ entry.name, cols, rows, bytes.len, st.deltas, st.lost, st.refused, st.most_in_flight, st.bytes, st.history_checked, st.fetched }); - } - } - try w.print("screen-state corpus: {d} streams x 3 seeds, {d} failed\n", .{ files, failed }); - try w.flush(); - try bench(gpa, io, w); -} - -fn bench(gpa: std.mem.Allocator, io: std.Io, w: *std.Io.Writer) !void { - const t = try gpa.create(Terminal); - defer gpa.destroy(t); - t.* = try Terminal.init(io, gpa, .{ .cols = 200, .rows = 60, .max_scrollback_bytes = 16 << 20 }); - defer t.deinit(gpa); - var stream = t.vtStream(); - defer stream.deinit(); - var enc: Encoder = .init(gpa); - defer enc.deinit(); - var out: std.Io.Writer.Allocating = .init(gpa); - defer out.deinit(); - var line: [1024]u8 = undefined; - // A full 200x60 screen, every row new to the peer: each a blob. - var full: [200]u64 = undefined; - var same: [200]u64 = undefined; - var full_bytes: usize = 0; - var same_bytes: usize = 0; - var changes: u32 = 0; - for (&full, &same, 0..) |*f, *u, rep| { - for (0..60) |y| { - var lw: std.Io.Writer = .fixed(&line); - try lw.print("\x1b[{d};1H\x1b[0;3{d};4{d}m{d} {d} ", .{ y + 1, rep % 8, y % 8, rep, y }); - while (lw.end < 190) try lw.writeAll("\x1b[1mbold\x1b[22m text "); - stream.nextSlice(lw.buffered()); - } - changes += 1; - var tr: Track = .init(gpa); - defer tr.deinit(gpa, t); - var peer: Peer = .{}; - defer peer.deinit(gpa); - out.clearRetainingCapacity(); - var t0 = std.Io.Clock.awake.now(io).nanoseconds; - _ = try encode(&enc, &tr, &peer, t, changes, "", &out.writer); - f.* = @intCast(std.Io.Clock.awake.now(io).nanoseconds - t0); - full_bytes = out.written().len; - // The same screen again as a new version: every row held. - out.clearRetainingCapacity(); - t0 = std.Io.Clock.awake.now(io).nanoseconds; - _ = try encode(&enc, &tr, &peer, t, changes + 1, "", &out.writer); - u.* = @intCast(std.Io.Clock.awake.now(io).nanoseconds - t0); - same_bytes = out.written().len; - } - std.mem.sort(u64, &full, {}, std.sort.asc(u64)); - std.mem.sort(u64, &same, {}, std.sort.asc(u64)); - try w.print("screen-state encode 200x60, every row new: p50 {d} us p99 {d} us, {d} bytes\n", .{ full[100] / 1000, full[198] / 1000, full_bytes }); - try w.print("screen-state encode 200x60, nothing new: p50 {d} us p99 {d} us, {d} bytes\n", .{ same[100] / 1000, same[198] / 1000, same_bytes }); - try w.flush(); - - // Floods: a second of output as fast as ghostty takes it, a frame every - // 16 ms: one version, a delta for each peer (the same bytes for peers - // at the same base), each replica applying its own at once. Under the C - // allocator, as a replica's (the checking one costs an apply 4x). - try floods(gpa, std.heap.c_allocator, io, w); -} - -fn floods(gpa: std.mem.Allocator, ca: std.mem.Allocator, io: std.Io, w: *std.Io.Writer) !void { - var enc: Encoder = .init(ca); - defer enc.deinit(); - var out: std.Io.Writer.Allocating = .init(ca); - defer out.deinit(); - const yes = try yesStream(gpa, 1 << 16); - defer gpa.free(yes); - const shell = try shellStream(gpa); - defer gpa.free(shell); - for ([_]struct { name: []const u8, bytes: []const u8 }{ .{ .name = "yes", .bytes = yes }, .{ .name = "varied text", .bytes = shell } }) |flood| for ([_]usize{ 1, 3 }) |npeers| { - const a = try ca.create(Terminal); - defer ca.destroy(a); - a.* = try Terminal.init(io, ca, .{ .cols = 200, .rows = 60, .max_scrollback_bytes = 16 << 20 }); - defer a.deinit(ca); - var as = a.vtStream(); - defer as.deinit(); - var tr: Track = .init(ca); - defer tr.deinit(ca, a); - var peers: [3]Peer = @splat(.{}); - var reps: [3]Replica = @splat(.{}); - var bs: [3]Terminal = undefined; - for (bs[0..npeers]) |*b| b.* = try Terminal.init(io, ca, .{ .cols = 2, .rows = 2, .max_scrollback_bytes = 32 << 20 }); - defer for (bs[0..npeers], reps[0..npeers], peers[0..npeers]) |*b, *r, *peer| { - b.deinit(ca); - r.deinit(ca); - peer.deinit(ca); - }; - var applies: std.ArrayList(u64) = .empty; - defer applies.deinit(gpa); - var frames: std.ArrayList(u64) = .empty; - defer frames.deinit(gpa); - const start = std.Io.Clock.awake.now(io).nanoseconds; - var next = start; - var fed: u64 = 0; - var deltas: u64 = 0; - var wire: u64 = 0; - var version: u32 = 0; - while (true) { - const now = std.Io.Clock.awake.now(io).nanoseconds; - if (now - start >= std.time.ns_per_s) break; - as.nextSlice(flood.bytes); - version += 1; - fed += flood.bytes.len; - if (now < next) continue; - next += 16 * std.time.ns_per_ms; - var frame_ns: u64 = 0; - for (peers[0..npeers], reps[0..npeers], bs[0..npeers]) |*peer, *rep, *b| { - out.clearRetainingCapacity(); - const e0 = std.Io.Clock.awake.now(io).nanoseconds; - if (!try encode(&enc, &tr, peer, a, version, "", &out.writer)) continue; - frame_ns += @intCast(std.Io.Clock.awake.now(io).nanoseconds - e0); - const a0 = std.Io.Clock.awake.now(io).nanoseconds; - peer.ack((try rep.apply(ca, io, b, out.written())).seq); - try applies.append(gpa, @intCast(std.Io.Clock.awake.now(io).nanoseconds - a0)); - deltas += 1; - wire += out.written().len; - } - try frames.append(gpa, frame_ns); - } - std.mem.sort(u64, applies.items, {}, std.sort.asc(u64)); - std.mem.sort(u64, frames.items, {}, std.sort.asc(u64)); - const p = struct { - fn at(s: []const u64, q: usize) u64 { - return if (s.len == 0) 0 else s[@min(s.len - 1, s.len * q / 100)] / 1000; - } - }.at; - try w.print("screen-state flood of {s}, {d} peer(s): {d} MB/s of output, {d} deltas/s a peer, {d} wire bytes/s a peer ({d} a delta); encode a frame, all peers: p50 {d} us p99 {d} us; apply a delta p50 {d} us p99 {d} us\n", .{ - flood.name, npeers, fed / 1_000_000, deltas / npeers, wire / npeers, - wire / @max(1, deltas), p(frames.items, 50), p(frames.items, 99), p(applies.items, 50), - p(applies.items, 99), - }); - }; - try w.flush(); -} - const testing = std.testing; -test "recorded streams through replicas, and the encode's cost (PARDES_SCREEN_STATE=)" { - const dir = std.c.getenv("PARDES_SCREEN_STATE") orelse return error.SkipZigTest; - var buf: [4096]u8 = undefined; - // stderr: a test's stdout is the build runner's. - var out = std.Io.File.stderr().writer(testing.io, &buf); - try perf(testing.allocator, testing.io, std.mem.span(dir), &out.interface); -} - /// A shell's: prompts marked (OSC 133), colours of the three kinds, wide /// and combined graphemes, hyperlinks, tabs, a title and a directory, long /// lines that wrap, and a clear (ED2, ED3) now and then. -- cgit v1.3