summaryrefslogtreecommitdiff
diff options
context:
space:
mode:
authorGabriel Schneider <[email protected]>2026-11-04 23:55:49 -0300
committerGabriel Schneider <[email protected]>2026-11-05 09:54:56 -0300
commite32f749c80468b9e2fc79eb068f7088527a9c504 (patch)
tree07c77ecd04a282efa301a04d1a0b8b718111dc6a
parentdcb5fede7b5b2ceda0d7015bb8088fa343728378 (diff)
downloadpardes-e32f749c80468b9e2fc79eb068f7088527a9c504.tar.gz
pardes-e32f749c80468b9e2fc79eb068f7088527a9c504.zip
benches out of the binary: screen_state's corpus soak, encode bench and floods (PARDES_SCREEN_STATE=<dir>, which nothing sets) are `zig build replicas -- --screen-state <dir>`, 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 <[email protected]> Claude-Session: https://claude.ai/code/session_016Y9MNAtZenFv4weoMD3cge
-rw-r--r--src/Store.zig61
-rw-r--r--src/replica.zig51
-rw-r--r--src/screen_state.zig179
-rw-r--r--test/replicas.zig180
-rw-r--r--test/rollback_bench.zig44
5 files changed, 222 insertions, 293 deletions
diff --git a/src/Store.zig b/src/Store.zig
index 2bb9fcf0..547e7bd6 100644
--- a/src/Store.zig
+++ b/src/Store.zig
@@ -1133,64 +1133,3 @@ test "store: a closed pane comes back where it was, its rows from the pane that
}
const panes_mod = @import("panes.zig");
-
-test "zz store timings on a 90 MiB store (STORE_TIMES=<dir>)" {
- const dir_z = std.c.getenv("STORE_TIMES") orelse return error.SkipZigTest;
- const gpa = testing.allocator;
- const path = try std.fs.path.join(gpa, &.{ std.mem.span(dir_z), "store" });
- defer gpa.free(path);
- // A store as another running session leaves it: 200 files, then 90
- // closed panes of 1 MiB each (this pid: alive, so a compaction keeps
- // what fits).
- {
- var bytes: std.ArrayList(u8) = .empty;
- defer bytes.deinit(gpa);
- try frame(gpa, &bytes, 'h', &.{magic ++ " 1"});
- var line: [64]u8 = undefined;
- for (0..200) |i| try frame(gpa, &bytes, 'r', &.{std.fmt.bufPrint(&line, "1 1 0 0 /w/file{d}.zig", .{i}) catch unreachable});
- const out = try std.Io.Dir.cwd().createFile(testing.io, path, .{});
- defer out.close(testing.io);
- try out.writePositionalAll(testing.io, bytes.items, 0);
- var off: u64 = bytes.items.len;
- const big = try gpa.alloc(u8, 1 << 20);
- defer gpa.free(big);
- @memset(big, 'z');
- for (0..90) |i| {
- bytes.clearRetainingCapacity();
- var meta: [128]u8 = undefined;
- const m = std.fmt.bufPrint(&meta, "{x:0>16} {d} {d} 1 0 0 0 10\t/w/closed{d}\n", .{ @as(u64, 0xfeed), std.c.getpid(), i + 1, i }) catch unreachable;
- try frame(gpa, &bytes, 'c', &.{ m, big });
- try out.writePositionalAll(testing.io, bytes.items, off);
- off += bytes.items.len;
- }
- }
- const t0 = nowNs();
- const p = try testWindow(path);
- defer p.deinit();
- const load_ns = nowNs() - t0;
- var t = nowNs();
- for (0..1000) |_| p.store.refresh(p);
- const refresh_ns = (nowNs() - t) / 1000;
- t = nowNs();
- var name: [32]u8 = undefined;
- for (0..100) |i| {
- const f = std.fmt.bufPrint(&name, "/w/new{d}.zig", .{i}) catch unreachable;
- p.recent.opened(p.recentGpa(), f);
- p.recent.closed(p.recentGpa(), f, 1, 1, 0, 0);
- p.saveRecent();
- }
- const flush_ns = (nowNs() - t) / 100;
- const before = fileSize(path);
- p.store.garbage = true;
- p.recent.opened(p.recentGpa(), "/w/last.zig");
- t = nowNs();
- p.saveRecent();
- const compact_ns = nowNs() - t;
- std.debug.print("store timings: load {d} us, refresh (unchanged) {d} ns, flush one record {d} us, compaction {d} -> {d} bytes {d} ms\n", .{
- load_ns / 1000, refresh_ns, flush_ns / 1000, before, fileSize(path), compact_ns / 1_000_000,
- });
-}
-
-fn nowNs() u64 {
- return @intCast(clockNs());
-}
diff --git a/src/replica.zig b/src/replica.zig
index 5c46f5c2..fa309648 100644
--- a/src/replica.zig
+++ b/src/replica.zig
@@ -3532,57 +3532,6 @@ test "pardes's own keys over a terminal's history apply at once: its view moves
try std.testing.expectEqual(terminal.viewOf(a.core.panes[shell].?), terminal.viewOf(r.core().panes[shell].?));
}
-/// p50 and p99 of `samples`, sorted in place.
-fn spread(samples: []u64) [2]u64 {
- std.mem.sort(u64, samples, {}, std.sort.asc(u64));
- return .{ samples[samples.len / 2], samples[@min(samples.len - 1, samples.len * 99 / 100)] };
-}
-
-test "the authority's units with a big file open: its blobs hashed once (PARDES_DIGEST_BENCH=<MB>)" {
- const arg = std.c.getenv("PARDES_DIGEST_BENCH") orelse return error.SkipZigTest;
- const mb = std.fmt.parseInt(usize, std.mem.span(arg), 10) catch 100;
- const gpa = std.heap.c_allocator;
- const tmp = std.mem.span(std.c.getenv("TMPDIR") orelse "/tmp");
- var path_buf: [256]u8 = undefined;
- const path = try std.fmt.bufPrintSentinel(&path_buf, "{s}/pardes-digest-bench.txt", .{tmp}, 0);
- {
- const fd = std.c.open(path, .{ .ACCMODE = .WRONLY, .CREAT = true, .TRUNC = true }, @as(std.c.mode_t, 0o644));
- if (fd < 0) return error.OpenFailed;
- defer _ = std.c.close(fd);
- var line: [80]u8 = undefined;
- var n: usize = 0;
- var i: usize = 0;
- while (n < mb << 20) : (i += 1) {
- const text = try std.fmt.bufPrint(&line, "line {d:0>9} of a big file, as a log or a dump is\n", .{i});
- if (std.c.write(fd, text.ptr, text.len) != @as(isize, @intCast(text.len))) return error.WriteFailed;
- n += text.len;
- }
- }
- defer _ = std.c.unlink(path);
- const a = try Authority.init(gpa, .{ .cols = 120, .rows = 40, .file = path }, TestHost.host(), 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| {
- // A key into the file: a unit as a replica is sent it.
- 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();
- _ = digestOf(a);
- d.* = nowNs() - t1;
- }
- const us = spread(&unit_ns);
- const ds = spread(&digest_ns);
- 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", us[0] / 1000, us[1] / 1000, ds[0] / 1000, ds[1] / 1000 });
- }
-}
-
test "a replica joined from the session's dump replays the units after it" {
const gpa = std.testing.allocator;
const a = try Authority.init(gpa, .{ .cols = 80, .rows = 24, .file = "mise.toml" }, TestHost.host(), false);
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 `-<cols>x<rows>` 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=<dir>)" {
- 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.
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 <dir>
//!
//! `--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 <dir>`: every recorded pty stream in `dir` (a
+/// `-<cols>x<rows>` 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);
}