summaryrefslogtreecommitdiff
path: root/test/replicas.zig
diff options
context:
space:
mode:
authorGabriel Schneider <[email protected]>2026-10-29 21:45:19 -0300
committerGabriel Schneider <[email protected]>2026-10-29 21:45:19 -0300
commit473bbaa838f290e932992ef625be2fdc05c952dc (patch)
tree3165ffa9af3e9c0c3e777d012228cc033c1bbf80 /test/replicas.zig
parent64184a16e58094f6b861cd1027920ddf21d9df0d (diff)
downloadpardes-473bbaa838f290e932992ef625be2fdc05c952dc.tar.gz
pardes-473bbaa838f290e932992ef625be2fdc05c952dc.zip
screen-state replicas: what a terminal's ingest tells the positions pardes keeps over it taped, the history a step reads sent before its unit, rows sent a blob once a message, and the rows cache out of the rollback copy
terminal.zig, tape.zig: ingestWithPositions tracks its rows only where an ingest happens; what the ingest told them (each tracked row's row after it and whether it was erased, a clear, whether the pages lived, a pin not made) is a taped value (Site.positions), which a screen-state replica, ingesting nothing, takes; the logic after it runs alike on both. On the stack, so the local path allocates nothing new. buildRows marks a terminal read (State.read) outside the render (terminal.drawing). screen_state.zig, replica.zig: the authority keeps each peer's holes as its replica does (Peer.holes, from the deltas it sent), and Screens.fill sends a peer the rows it lacks of every terminal a step read, after the step and before its unit, so a replay reads what the step read (a text-mode cursor moved into history the flood scrolled past diverged). encodeRows sends each distinct blob once a message and the rows as addresses (a fill after yes is a third). The rows cache is dropped when a copy is taken and emptied when it is put back, not saved. test/replicas.zig: Ctrl-b in the mix (a shell out of tty mode: text, cursors and selections over it), and a shell's session (prompts, titles, directories, clears) between the TUI and the flood. 4 seeds x 120 inputs x 3 clients at 30, 80, 207 ms: no divergence, every replica and terminal the authority's, 4,653 deltas checked. Co-Authored-By: Claude Opus 5.5 <[email protected]>
Diffstat (limited to 'test/replicas.zig')
-rw-r--r--test/replicas.zig58
1 files changed, 43 insertions, 15 deletions
diff --git a/test/replicas.zig b/test/replicas.zig
index 1acd1c11..9b5c3c3b 100644
--- a/test/replicas.zig
+++ b/test/replicas.zig
@@ -113,6 +113,8 @@ const Totals = struct {
flood_delta_bytes: u64 = 0,
flood_unit_bytes: u64 = 0,
fetched: u64 = 0,
+ /// Bytes of rows sent before a step's unit, the step having read them.
+ filled_bytes: u64 = 0,
resets: u64 = 0,
screens_wrong: u64 = 0,
screens_checked: u64 = 0,
@@ -141,7 +143,7 @@ const Totals = struct {
fn nextEvent(random: std.Random, buf: *[64]u8, wheel_at: ?[2]u16) pardes.Event {
const typed = "abcdefghijklmnopqrstuvwxyz0123456789 -_=+,:;()";
const normal = "hjklwbe0$xpuyoOiaAIdcv.nN%sC";
- switch (random.uintLessThan(u8, 42)) {
+ switch (random.uintLessThan(u8, 43)) {
0...15 => {
buf[0] = typed[random.uintLessThan(usize, typed.len)];
return .{ .key = .{ .cp = buf[0], .text = buf[0..1] } };
@@ -173,6 +175,9 @@ fn nextEvent(random: std.Random, buf: *[64]u8, wheel_at: ?[2]u16) pardes.Event {
37 => return .{ .resize = .{ .cols = @intCast(random.intRangeAtMost(u16, 60, 120)), .rows = @intCast(random.intRangeAtMost(u16, 16, 40)) } },
38 => return .{ .mouse = .{ .button = .left, .kind = .press, .col = random.uintLessThan(u16, 80), .row = random.uintLessThan(u16, 24) } },
39 => return .{ .mouse = .{ .button = .left, .kind = .release, .col = random.uintLessThan(u16, 80), .row = random.uintLessThan(u16, 24) } },
+ // Out of a shell's tty mode and back: its text, a cursor and
+ // selections over it.
+ 40 => return .{ .key = .{ .cp = 'b', .ctrl = true } },
else => {
const at = wheel_at orelse return .{ .key = .{ .cp = Key.escape } };
return .{ .mouse = .{ .button = if (random.uintLessThan(u8, 3) == 0) .wheel_down else .wheel_up, .kind = .press, .col = at[0], .row = at[1] } };
@@ -252,14 +257,18 @@ fn run(r: Run, dir: []const u8, totals: *Totals) !void {
const sr = a.core.rects[shell];
const wheel_at: ?[2]u16 = if (sr.h > 2) .{ sr.x + sr.w / 2, sr.y + sr.h / 2 } else null;
- // What the shell's program prints: a full-screen program, then a flood
- // of `yes`, read 4 KB at a time as a pty gives it.
+ // What the shell's program prints: a full-screen program, a shell's
+ // session (prompts, titles, directories, a clear now and then), then a
+ // flood of `yes`, read 4 KB at a time as a pty gives it.
const tui = try screen_state.tuiStream(gpa);
defer gpa.free(tui);
+ const session = try screen_state.shellStream(gpa);
+ defer gpa.free(session);
const yes = try screen_state.yesStream(gpa, @intCast(r.flood_mb * (1 << 20) / 3));
defer gpa.free(yes);
const tui_at: u64 = 400_000;
- const flood_at: u64 = 1_500_000;
+ const session_at: u64 = 1_000_000;
+ const flood_at: u64 = 2_500_000;
var flood_end: u64 = 0;
var program: struct { bytes: []const u8 = &.{}, at: usize = 0 } = .{};
// The authority's version of each terminal, as its screen showed then.
@@ -290,6 +299,7 @@ fn run(r: Run, dir: []const u8, totals: *Totals) !void {
// Each client's first input, soon; the programs; the first frame.
for (0..r.clients) |c| try push(&queue, &n, .{ .at = random.uintLessThan(u64, 200_000), .n = 0, .kind = .input, .who = @intCast(c + 1), .bytes = &.{} });
try push(&queue, &n, .{ .at = tui_at, .n = 0, .kind = .output, .who = 0, .bytes = &.{} });
+ try push(&queue, &n, .{ .at = session_at, .n = 0, .kind = .output, .who = 2, .bytes = &.{} });
try push(&queue, &n, .{ .at = flood_at, .n = 0, .kind = .output, .who = 1, .bytes = &.{} });
try push(&queue, &n, .{ .at = frame_us, .n = 0, .kind = .frame, .who = 0, .bytes = &.{} });
var frames_left: u32 = 0;
@@ -353,13 +363,17 @@ fn run(r: Run, dir: []const u8, totals: *Totals) !void {
// The program's next read, 4 KB, then the next a
// fraction of a millisecond on (ghostty's pace).
if (program.at == program.bytes.len) {
- program = .{ .bytes = if (m.who == 0) tui else yes };
+ program = .{ .bytes = switch (m.who) {
+ 0 => tui,
+ 1 => yes,
+ else => session,
+ } };
}
- const k = @min(program.bytes.len - program.at, if (m.who == 0) @as(usize, 700) else 4096);
+ const k = @min(program.bytes.len - program.at, if (m.who == 1) @as(usize, 4096) else 700);
const chunk = program.bytes[program.at..][0..k];
program.at += k;
if (program.at < program.bytes.len)
- try push(&queue, &n, .{ .at = m.at + if (m.who == 0) @as(u64, 3_000) else 450, .n = 0, .kind = .output, .who = m.who, .bytes = &.{} })
+ try push(&queue, &n, .{ .at = m.at + if (m.who == 1) @as(u64, 450) else 3_000, .n = 0, .kind = .output, .who = m.who, .bytes = &.{} })
else if (m.who == 1) flood_end = m.at;
if (m.who == 1) flood_units += 1;
a.output(.{ .output = .{ .pane = shell, .bytes = chunk } });
@@ -369,17 +383,17 @@ fn run(r: Run, dir: []const u8, totals: *Totals) !void {
// The authority's own steps since the last unit, and
// the terminals as they are: what the input's step
// reads, before it is stepped.
- if (try a.pending()) |batch| try sendUnit(&queue, &n, batch, m.at, down[0..r.clients], random, one_way, jitter, totals, m.at >= flood_at and flood_end == 0);
+ if (try a.pending()) |batch| try sendUnit(&queue, &n, batch, m.at, down[0..r.clients], random, one_way, jitter, totals, m.at >= flood_at and flood_end == 0, &screens, a.core, peers[0..r.clients]);
try flushAll(&screens, a.core, peers[0..r.clients], &owed, &queue, &n, m.at, &down, random, one_way, jitter, &versions, totals);
break :in try a.take(m.bytes);
},
};
- if (unit) |u| try sendUnit(&queue, &n, u, m.at, down[0..r.clients], random, one_way, jitter, totals, false);
+ if (unit) |u| try sendUnit(&queue, &n, u, m.at, down[0..r.clients], random, one_way, jitter, totals, false, &screens, a.core, peers[0..r.clients]);
for (host.echo.items) |e| try push(&queue, &n, .{ .at = m.at + 2_000, .n = 0, .kind = .echo, .who = e.pane, .bytes = e.bytes });
host.echo.clearRetainingCapacity();
},
.frame => {
- if (try a.pending()) |batch| try sendUnit(&queue, &n, batch, m.at, down[0..r.clients], random, one_way, jitter, totals, m.at >= flood_at and flood_end == 0);
+ if (try a.pending()) |batch| try sendUnit(&queue, &n, batch, m.at, down[0..r.clients], random, one_way, jitter, totals, m.at >= flood_at and flood_end == 0, &screens, a.core, peers[0..r.clients]);
const t0 = screens.encode_ns;
const before = totals.delta_bytes;
try flushAll(&screens, a.core, peers[0..r.clients], &owed, &queue, &n, m.at, &down, random, one_way, jitter, &versions, totals);
@@ -453,8 +467,21 @@ fn run(r: Run, dir: []const u8, totals: *Totals) !void {
}
}
-/// A unit of the authority's to every replica, down its link.
-fn sendUnit(q: *std.PriorityQueue(Msg, void, Msg.order), n: *u64, unit: []const u8, now: u64, down: []Link, random: std.Random, one_way: u64, jitter: u64, totals: *Totals, flooding: bool) !void {
+/// A unit of the authority's to every replica, down its link: first the
+/// rows of its terminals its step read that a replica holds as holes.
+fn sendUnit(q: *std.PriorityQueue(Msg, void, Msg.order), n: *u64, unit: []const u8, now: u64, down: []Link, random: std.Random, one_way: u64, jitter: u64, totals: *Totals, flooding: bool, screens: *replica.Screens, core: *pardes.Pardes, peers: []const u16) !void {
+ var rows: std.ArrayListUnmanaged([]u8) = .empty;
+ defer rows.deinit(gpa);
+ for (down, peers, 1..) |*l, peer, who| {
+ rows.clearRetainingCapacity();
+ try screens.fill(core, peer, &rows);
+ for (rows.items) |bytes| {
+ totals.filled_bytes += bytes.len;
+ try q.push(gpa, .{ .at = l.arrive(random, now, one_way, jitter), .n = n.*, .kind = .screen_down, .who = @intCast(who), .bytes = bytes });
+ n.* += 1;
+ }
+ }
+ screens.filled(core);
totals.unit_bytes += unit.len * down.len;
if (flooding) totals.flood_unit_bytes += unit.len * down.len;
for (down, 1..) |*l, who| {
@@ -523,7 +550,7 @@ pub fn main(init: std.process.Init) !void {
});
const flood_s = @as(f64, @floatFromInt(@max(1, t.flood_us))) / 1e6;
- try term_lines.print(gpa, "{d:>4} {d:>7.1} {d:>9.0} {d:>9.0} {d:>5}/{d:<5} {d:>5}/{d:<5} {d:>7} {d:>6} {d:>6}/{d:<6}\n", .{
+ try term_lines.print(gpa, "{d:>4} {d:>7.1} {d:>9.0} {d:>9.0} {d:>5}/{d:<5} {d:>5}/{d:<5} {d:>7} {d:>9} {d:>6} {d:>6}/{d:<6}\n", .{
rtt,
@as(f64, @floatFromInt(t.flood_deltas)) / flood_s / @as(f64, @floatFromInt(clients)),
@as(f64, @floatFromInt(t.flood_delta_bytes)) / flood_s / @as(f64, @floatFromInt(clients)),
@@ -533,13 +560,14 @@ pub fn main(init: std.process.Init) !void {
pct(t.apply_ns.items, 50) / 1000,
pct(t.apply_ns.items, 99) / 1000,
t.fetched,
+ t.filled_bytes / 1024,
t.resets,
t.screens_checked,
t.screens_wrong,
});
if (t.divergences > 0 or t.unequal > 0 or t.screens_wrong > 0) failed = true;
}
- std.debug.print("terminals: deltas a replica applied a second under the flood; a peer's bytes a second under the flood (deltas, units); encode a frame of the flood for every peer, apply a delta (us); rows fetched; resets; deltas checked/wrong\n", .{});
- std.debug.print(" rtt deltas/s delta B/s unit B/s encode p50/p99 apply p50/p99 fetched resets checked/wrong\n{s}", .{term_lines.items});
+ std.debug.print("terminals: deltas a replica applied a second under the flood; a peer's bytes a second under the flood (deltas, units); encode a frame of the flood for every peer, apply a delta (us); rows fetched, KB of rows sent before the step that read them; resets; deltas checked/wrong\n", .{});
+ std.debug.print(" rtt deltas/s delta B/s unit B/s encode p50/p99 apply p50/p99 fetched filled KB resets checked/wrong\n{s}", .{term_lines.items});
if (failed) std.process.exit(1);
}