summaryrefslogtreecommitdiff
path: root/src/replica.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 /src/replica.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 'src/replica.zig')
-rw-r--r--src/replica.zig59
1 files changed, 54 insertions, 5 deletions
diff --git a/src/replica.zig b/src/replica.zig
index 92ee7b37..cac8ed59 100644
--- a/src/replica.zig
+++ b/src/replica.zig
@@ -272,7 +272,10 @@ pub const Screens = struct {
/// `core` is the session's, its terminals still there.
pub fn deinit(s: *Screens, core: *Pardes) void {
for (&s.tracks, 0..) |*slot, id| if (slot.*) |*tr| tr.track.deinit(s.gpa, if (s.live(core, id, tr)) &tr.state.vt else null);
- for (s.peers.items) |p| s.gpa.destroy(p);
+ for (s.peers.items) |p| {
+ for (p) |*pp| pp.peer.deinit(s.gpa);
+ s.gpa.destroy(p);
+ }
s.peers.deinit(s.gpa);
s.out.deinit(s.gpa);
s.enc.deinit();
@@ -302,7 +305,10 @@ pub const Screens = struct {
const state = pane.terminal orelse continue;
const tr = try s.track(core, id);
const pp = &s.peers.items[peer][id];
- if (pp.serial != pane.serial) pp.* = .{ .serial = pane.serial };
+ if (pp.serial != pane.serial) {
+ pp.peer.reset();
+ pp.serial = pane.serial;
+ }
var marks: [terminal.marks_len]u8 = undefined;
s.out.clearRetainingCapacity();
try writeScreenHead(&s.out, s.gpa, @intCast(id), pane.serial, kind_delta);
@@ -313,6 +319,45 @@ pub const Screens = struct {
}
}
+ /// Rows a peer holds as holes of every terminal a step read (its rows,
+ /// history and all: text mode over a shell), each a rows message onto
+ /// `out` (owned): sent after the step and before its unit, so the
+ /// replica's replay reads what the authority's step read. A history row
+ /// never changes, so each goes once. Then `filled`.
+ // ponytail: a step that reads a terminal's rows reads all of them (its
+ // motion surface), so the first after a flood sends its whole history.
+ pub fn fill(s: *Screens, core: *Pardes, peer: u16, out: *std.ArrayListUnmanaged([]u8)) !void {
+ for (core.panes, 0..) |slot, id| {
+ const pane = slot orelse continue;
+ const state = pane.terminal orelse continue;
+ if (!state.read) continue;
+ const pp = &s.peers.items[peer][id];
+ if (pp.serial != pane.serial or pp.peer.holes.items.len == 0) continue;
+ const tr = try s.track(core, id);
+ for (pp.peer.holes.items) |hole| {
+ var lo = hole[0];
+ while (lo < hole[1]) {
+ const hi = @min(hole[1], lo + 512);
+ s.out.clearRetainingCapacity();
+ try writeScreenHead(&s.out, s.gpa, @intCast(id), pane.serial, kind_rows);
+ var w: std.Io.Writer.Allocating = .fromArrayList(s.gpa, &s.out);
+ defer s.out = w.toArrayList();
+ try screen_state.encodeRows(&s.enc, &tr.track, &state.vt, lo, hi, &w.writer);
+ try out.append(s.gpa, try s.gpa.dupe(u8, w.written()));
+ lo = hi;
+ }
+ }
+ pp.peer.holes.clearRetainingCapacity();
+ }
+ }
+
+ /// Every peer is filled: the steps' reads are forgotten.
+ pub fn filled(_: *Screens, core: *Pardes) void {
+ for (core.panes) |slot| if (slot) |pane| if (pane.terminal) |state| {
+ state.read = false;
+ };
+ }
+
fn track(s: *Screens, core: *Pardes, id: usize) !*Tracked {
const pane = core.panes[id].?;
if (s.tracks[id]) |*tr| {
@@ -571,9 +616,11 @@ pub const Replica = struct {
if (r.copy.held) {
r.copy.restore();
rollback.Epoch.select(null);
- // The copy's terminal rows are of a grid the deltas since moved
- // on from: a rollback never brings a terminal's past back.
- r.core().shell_rows.stale = true;
+ // The rows a terminal was read as are no copy's: what the
+ // speculation built was the epoch's, freed with it, and what
+ // was there before is of a grid the deltas since moved on
+ // from (a rollback never brings a terminal's past back).
+ r.core().shell_rows = .{};
}
r.applied = 0;
for (r.since.items) |u| if (tape.replayUnit(&r.t, u)) |why| return r.fail(why);
@@ -614,6 +661,8 @@ pub const Replica = struct {
const c = r.core();
if (!r.copy.held) {
const t0 = nowNs();
+ // A grid's worth of text the copy would save, and put back stale.
+ c.shell_rows.reset(c.gpa);
r.copy.take(&r.epoch, c) catch return false;
rollback.Epoch.select(&r.epoch);
r.stats.copy_ns.append(r.gpa, nowNs() - t0) catch {};