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 --- test/replicas.zig | 180 +++++++++++++++++++++++++++++++++++++++++++++++- test/rollback_bench.zig | 44 +++++++++++- 2 files changed, 221 insertions(+), 3 deletions(-) (limited to 'test') diff --git a/test/replicas.zig b/test/replicas.zig index 4fcb9920..15dc89f1 100644 --- a/test/replicas.zig +++ b/test/replicas.zig @@ -14,10 +14,12 @@ //! //! zig build replicas -Dplatform=tui -- [--seeds N] [--steps M] [--clients C] [--rtt 30,80,207] [--first K] [--flood MB] [--shared] //! zig build replicas -Dplatform=tui -- --echo [--seeds N] [--rtt 30,80,207] [--first K] +//! zig build replicas -Dplatform=tui -Doptimize=ReleaseFast -- --screen-state //! //! `--echo` types a corpus into a shell instead, with and without the //! predicted echo (src/echo.zig), and gates what it draws: below, at -//! "predicted echo". +//! "predicted echo". `--screen-state` runs recorded pty streams through +//! screen_state's soak and measures its encoder: below, at screenState. //! //! Gates, per seed and RTT: no replica diverges (every confirmed unit's //! digests agree as it is replayed), and at quiescence every replica's @@ -1207,6 +1209,174 @@ fn pct(samples: []u64, p: usize) u64 { return samples[@min(samples.len - 1, samples.len * p / 100)]; } +/// `--screen-state `: every recorded pty stream in `dir` (a +/// `-x` in its name sizes it, 80x24 otherwise) through +/// screen_state's soak at three seeds, then the encode's cost and the bytes +/// floods put on the wire (numbers from a ReleaseFast build). +fn screenState(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 = screen_state.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 encodeBench(io, w); +} + +fn encodeBench(io: std.Io, w: *std.Io.Writer) !void { + const t = try gpa.create(screen_state.Terminal); + defer gpa.destroy(t); + t.* = try screen_state.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: screen_state.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: screen_state.Track = .init(gpa); + defer tr.deinit(gpa, t); + var peer: screen_state.Peer = .{}; + defer peer.deinit(gpa); + out.clearRetainingCapacity(); + var t0 = std.Io.Clock.awake.now(io).nanoseconds; + _ = try screen_state.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 screen_state.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. + try floods(io, w); +} + +fn floods(io: std.Io, w: *std.Io.Writer) !void { + var enc: screen_state.Encoder = .init(gpa); + defer enc.deinit(); + var out: std.Io.Writer.Allocating = .init(gpa); + defer out.deinit(); + const yes = try screen_state.yesStream(gpa, 1 << 16); + defer gpa.free(yes); + const shell = try screen_state.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 gpa.create(screen_state.Terminal); + defer gpa.destroy(a); + a.* = try screen_state.Terminal.init(io, gpa, .{ .cols = 200, .rows = 60, .max_scrollback_bytes = 16 << 20 }); + defer a.deinit(gpa); + var as = a.vtStream(); + defer as.deinit(); + var tr: screen_state.Track = .init(gpa); + defer tr.deinit(gpa, a); + var peers: [3]screen_state.Peer = @splat(.{}); + var reps: [3]screen_state.Replica = @splat(.{}); + var bs: [3]screen_state.Terminal = undefined; + for (bs[0..npeers]) |*b| b.* = try screen_state.Terminal.init(io, gpa, .{ .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(gpa); + r.deinit(gpa); + peer.deinit(gpa); + }; + 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 screen_state.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(gpa, 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(); +} + pub fn main(init: std.process.Init) !void { const args = try init.minimal.args.toSlice(init.arena.allocator()); var seeds: u64 = 4; @@ -1217,6 +1387,7 @@ pub fn main(init: std.process.Init) !void { var shared = false; var echo_mode = false; var flood_mb: u64 = 8; + var screen_dir: ?[]const u8 = null; var rtt_buf: [8]u64 = undefined; var i: usize = 1; while (i < args.len) : (i += 1) { @@ -1232,13 +1403,18 @@ pub fn main(init: std.process.Init) !void { if (i + 1 >= args.len) return error.MissingValue; i += 1; const value = args[i]; - if (std.mem.eql(u8, name, "--seeds")) seeds = try std.fmt.parseInt(u64, value, 10) else if (std.mem.eql(u8, name, "--first")) first = try std.fmt.parseInt(u64, value, 10) else if (std.mem.eql(u8, name, "--steps")) steps = try std.fmt.parseInt(usize, value, 10) else if (std.mem.eql(u8, name, "--clients")) clients = @min(8, try std.fmt.parseInt(u16, value, 10)) else if (std.mem.eql(u8, name, "--flood")) flood_mb = try std.fmt.parseInt(u64, value, 10) else if (std.mem.eql(u8, name, "--rtt")) { + if (std.mem.eql(u8, name, "--seeds")) seeds = try std.fmt.parseInt(u64, value, 10) else if (std.mem.eql(u8, name, "--first")) first = try std.fmt.parseInt(u64, value, 10) else if (std.mem.eql(u8, name, "--steps")) steps = try std.fmt.parseInt(usize, value, 10) else if (std.mem.eql(u8, name, "--clients")) clients = @min(8, try std.fmt.parseInt(u16, value, 10)) else if (std.mem.eql(u8, name, "--flood")) flood_mb = try std.fmt.parseInt(u64, value, 10) else if (std.mem.eql(u8, name, "--screen-state")) screen_dir = value else if (std.mem.eql(u8, name, "--rtt")) { var it = std.mem.tokenizeScalar(u8, value, ','); var k: usize = 0; while (it.next()) |v| : (k += 1) rtt_buf[k] = try std.fmt.parseInt(u64, v, 10); rtts = rtt_buf[0..k]; } else return error.UnknownOption; } + if (screen_dir) |d| { + var buf: [4096]u8 = undefined; + var out = std.Io.File.stderr().writer(init.io, &buf); + return screenState(init.io, d, &out.interface); + } trace = libc.getenv("PARDES_REPLICA_TRACE") != null; if (libc.getenv("PARDES_REPLICA_FILL")) |b| pardes.rollback.Epoch.fill = std.fmt.parseInt(u8, std.mem.span(b), 0) catch 0xff; var dir_buf: [256]u8 = undefined; diff --git a/test/rollback_bench.zig b/test/rollback_bench.zig index 659a73d3..fa40e0cc 100644 --- a/test/rollback_bench.zig +++ b/test/rollback_bench.zig @@ -7,7 +7,9 @@ //! - a key that edits a file (`x`) applied on top, as a speculation, and //! the copy put back: the apply's time and the restore's. //! Then a fork of the big one, child gone at once, and the authority's -//! copy-on-write after it. +//! copy-on-write after it. Last, a session's authority with a 100 MB file +//! open (src/replica.zig): a key into it, a unit as a replica is sent it, +//! and a digest, its blobs hashed whole and hashed once (src/walk.zig). //! //! zig build rollback-bench -Dplatform=tui -Doptimize=ReleaseFast const std = @import("std"); @@ -122,6 +124,45 @@ fn rssKb() usize { const reps = 15; +/// The `p`th percentile of `samples`, sorted in place. +fn pct(samples: []u64, p: usize) u64 { + std.mem.sort(u64, samples, {}, std.sort.asc(u64)); + return samples[@min(samples.len - 1, samples.len * p / 100)]; +} + +/// A unit of a key into a big file, and a digest, with its blobs hashed +/// whole and hashed once. +fn digestBench(dir: []const u8, mb: usize) !void { + var path_buf: [512]u8 = undefined; + const path = try std.fmt.bufPrint(&path_buf, "{s}/big-file.txt", .{dir}); + try writeFile(path, (mb << 20) / 60); + const NoHost = struct { + fn watched(_: ?*anyopaque) bool { + return false; + } + const vtable: pardes.Host.VTable = .{ .watched = watched }; + }; + const a = try pardes.replica.Authority.init(gpa, .{ .cols = 120, .rows = 40, .file = path }, .{ .vtable = &NoHost.vtable }, true); + defer a.deinit(); + _ = try a.unit(0, 0); + var unit_ns: [40]u64 = undefined; + var digest_ns: [40]u64 = undefined; + for ([_]bool{ false, true }) |on| { + walk.blob_words_on = on; + defer walk.blob_words_on = true; + walk.forgetAll(); + for (&unit_ns, &digest_ns, 0..) |*u, *d, k| { + const t0 = nowNs(); + _ = try a.local(.{ .key = .{ .cp = if (k % 2 == 0) 'j' else 'k', .text = if (k % 2 == 0) "j" else "k" } }); + u.* = nowNs() - t0; + const t1 = nowNs(); + _ = pardes.replica.digestOf(a); + d.* = nowNs() - t1; + } + std.debug.print("{d} MB file, blobs {s}: a unit p50 {d} us p99 {d} us; a digest p50 {d} us p99 {d} us\n", .{ mb, if (on) "hashed once" else "hashed whole", pct(&unit_ns, 50) / 1000, pct(&unit_ns, 99) / 1000, pct(&digest_ns, 50) / 1000, pct(&digest_ns, 99) / 1000 }); + } +} + pub fn main(init: std.process.Init) !void { var dir_buf: [256]u8 = undefined; const tmp = std.mem.span(libc.getenv("TMPDIR") orelse "/tmp"); @@ -223,4 +264,5 @@ pub fn main(init: std.process.Init) !void { std.debug.print("fork of the big session (max RSS {d} MB): {d:.3} ms; then 64 MB written under the child: {d:.3} ms\n", .{ rssKb() / 1024, @as(f64, @floatFromInt(median(&t))) / 1e6, @as(f64, @floatFromInt(median(&cow))) / 1e6, }); + try digestBench(dir, 100); } -- cgit v1.3