summaryrefslogtreecommitdiff
path: root/src/replica.zig
diff options
context:
space:
mode:
authorGabriel Schneider <[email protected]>2026-10-29 21:03:38 -0300
committerGabriel Schneider <[email protected]>2026-10-29 21:20:55 -0300
commite89ee60270267cb268ce642d79fb3fb277e84463 (patch)
tree7d699d277e2a23d51a77dec2d8a0e298bad02549 /src/replica.zig
parent10a7e8768304478555dfe0b619423f5a4ad47d76 (diff)
downloadpardes-e89ee60270267cb268ce642d79fb3fb277e84463.tar.gz
pardes-e89ee60270267cb268ce642d79fb3fb277e84463.zip
phase 5 part B, terminals: a replica's terminal fed by screen-state deltas, several in flight against the version last sent, its history the authority's to the row, and the authority's own steps batched into a unit a frame
screen_state.zig: each state the authority sends is a version of its terminal (Track), made once for every peer; a peer's delta is against the version it was last sent (the stream is ordered and loses nothing), up to 32 in flight, a peer at the bound waiting for an acknowledgement and then getting the newest; peers at one base are sent the same bytes. A replica refuses a delta against another base and is started afresh. It keeps the authority's history extent to the row (no byte limit of its own, trimmed to the authority's count), takes its viewport and its cursor's semantic content, and grows a flood's rows in bulk. The soak now keeps several in flight, lands them late in order, loses one now and then, and checks the history extent and the viewport too. replica.zig: Screens (the authority's tracks and peers) and Replica.screen/screenRequest, messages of u8 pane, u32 serial, u8 kind (a delta, rows; an ack, a row request, a reset). Deltas are applied with the replica's epoch paused, so an emulator outlives a rollback. Authority.output/pending: its own steps (a pty's output) go into one unit, sent before any other input it steps and at a frame, with one digest; under screen state a digest is one word. tape.zig, terminal.zig: under screen state an output is recorded without its bytes, pty writes are off the tape on both sides, no digest covers an emulator, and a replica's core never ingests or resizes one (a resize's own core work, the pointer selections cleared, still runs). A terminal counts its writes (State.changes); its MarkedHandler cycle rides in each delta. test/replicas.zig: the session's shell runs a TUI, then 8 MB of yes read 4 KB at a time, while three clients type; deltas go out before each input the authority steps and once a frame, acknowledgements and row requests come back over the links, every applied delta is checked against the authority's screen at that version and every terminal at quiescence. Co-Authored-By: Claude Opus 5.5 <[email protected]>
Diffstat (limited to 'src/replica.zig')
-rw-r--r--src/replica.zig291
1 files changed, 282 insertions, 9 deletions
diff --git a/src/replica.zig b/src/replica.zig
index 42d94503..e229bad5 100644
--- a/src/replica.zig
+++ b/src/replica.zig
@@ -28,6 +28,8 @@ const tape = @import("tape.zig");
const rollback = @import("rollback.zig");
const walk = @import("walk.zig");
const wire = @import("detached/wire.zig");
+const screen_state = @import("screen_state.zig");
+const terminal = pardes.panes.terminal;
const Allocator = std.mem.Allocator;
const Pardes = pardes.Pardes;
@@ -97,10 +99,15 @@ pub const Authority = struct {
/// Each client's view (src/views.zig): its own layout, focus and
/// cursors over the session's text. The first client has the session's.
view_of: [64]u8 = @splat(0),
+ /// Steps of its own taken since the last unit (`output`): one unit,
+ /// `pending`, sent before the next input it steps and at a frame.
+ batched: u32 = 0,
/// A session booted with `opts`; `unit` is its first, which a replica
/// is made from.
- pub fn init(gpa: Allocator, options: pardes.Options, host: pardes.Host) !*Authority {
+ /// `screens`: its terminals cross as screen state (`Screens`), not as
+ /// their pty's bytes.
+ pub fn init(gpa: Allocator, options: pardes.Options, host: pardes.Host, screens: bool) !*Authority {
// A replay gives its core every allocator (tape.zig), and a digest
// tells an allocator from none.
var opts = options;
@@ -111,6 +118,9 @@ pub const Authority = struct {
const a = try gpa.create(Authority);
errdefer gpa.destroy(a);
a.* = .{ .gpa = gpa, .t = tape.memory(gpa), .core = undefined, .host = host };
+ a.t.screen_state = screens;
+ // One word a digest: every pty read is a unit.
+ a.t.whole_digest = screens and std.c.getenv("PARDES_REPLICA_TRACE") == null;
const was = Stepping.begin(&a.t, null);
defer was.end();
a.core = try Pardes.init(gpa, opts);
@@ -150,13 +160,38 @@ pub const Authority = struct {
/// One of the authority's own inputs, as its unit.
pub fn local(a: *Authority, ev: pardes.Event) ![]const u8 {
+ std.debug.assert(a.batched == 0); // `pending` first: units keep the order steps took
a.apply(ev);
a.seq += 1;
return a.unit(0, a.seq);
}
+ /// A step of its own (a pty's output) into the open batch: under a
+ /// flood a replica gets a unit a frame, not one a read (each unit of the
+ /// authority's rolls back a replica's pending inputs), and its digest
+ /// once a unit.
+ pub fn output(a: *Authority, ev: pardes.Event) void {
+ a.t.no_digest = true;
+ defer a.t.no_digest = false;
+ a.apply(ev);
+ a.batched += 1;
+ }
+
+ /// The open batch as a unit, or null: what the host sends before it
+ /// steps any other input, and once a frame.
+ pub fn pending(a: *Authority) !?[]const u8 {
+ if (a.batched == 0) return null;
+ a.batched = 0;
+ const was = Stepping.begin(&a.t, null);
+ tape.digestHere(&a.t);
+ was.end();
+ a.seq += 1;
+ return try a.unit(0, a.seq);
+ }
+
/// A view of its own for `client`, as its unit; which it is.
pub fn openView(a: *Authority, client: u16) !struct { view: u8, unit: []const u8 } {
+ std.debug.assert(a.batched == 0);
const was = Stepping.begin(&a.t, null);
const k = a.core.openView() orelse {
was.end();
@@ -172,6 +207,7 @@ pub const Authority = struct {
/// One client's input, applied in the order it came, in its view: the
/// unit every replica takes.
pub fn take(a: *Authority, msg: []const u8) ![]const u8 {
+ std.debug.assert(a.batched == 0);
const in = parseInput(msg) orelse return error.BadInput;
const was = Stepping.begin(&a.t, null);
a.core.toView(a.view_of[in.client]);
@@ -182,6 +218,140 @@ pub const Authority = struct {
}
};
+// ---- terminals as screen state (src/screen_state.zig) ----
+//
+// A message of either side is u8 pane, u32 the pane's serial (a slot's
+// next pane is another), u8 kind, and the kind's bytes:
+// to a replica: kind 1, a delta; kind 2, rows it asked for (encodeRows);
+// to the authority: kind 1, an acknowledgement (u32 seq); kind 2, a
+// request for rows (u64 lo, u64 hi, absolute); kind 3, a
+// delta refused: start this terminal afresh.
+// The authority sends a peer what it is owed (`Screens.flush`) before it
+// steps any input but a pty's output, and once a frame; a replica takes
+// them in that order between units (`Replica.screen`). So a step a replica
+// replays reads the terminal its authority's read.
+
+const kind_delta = 1;
+const kind_rows = 2;
+const kind_ack = 1;
+const kind_reset = 3;
+
+const ScreenMsg = struct { pane: u8, serial: u32, kind: u8, payload: []const u8 };
+
+fn parseScreen(msg: []const u8) ?ScreenMsg {
+ if (msg.len < 6) return null;
+ return .{ .pane = msg[0], .serial = std.mem.readInt(u32, msg[1..5], .little), .kind = msg[5], .payload = msg[6..] };
+}
+
+fn writeScreenHead(out: *std.ArrayListUnmanaged(u8), gpa: Allocator, pane: u8, serial: u32, kind: u8) !void {
+ var head: [6]u8 = undefined;
+ head[0] = pane;
+ std.mem.writeInt(u32, head[1..5], serial, .little);
+ head[5] = kind;
+ try out.appendSlice(gpa, &head);
+}
+
+/// The authority's side of its replicas' terminals: a track each terminal
+/// pane, and what each peer was sent of it.
+pub const Screens = struct {
+ gpa: Allocator,
+ enc: screen_state.Encoder,
+ tracks: [pardes.MAX_PANES]?Tracked = @splat(null),
+ peers: std.ArrayListUnmanaged(*[pardes.MAX_PANES]PeerOf) = .empty,
+ out: std.ArrayListUnmanaged(u8) = .empty,
+ /// Nanoseconds: what each flush spent encoding, for every peer.
+ encode_ns: u64 = 0,
+
+ const Tracked = struct { serial: u32, state: *terminal.State, track: screen_state.Track };
+ const PeerOf = struct { serial: u32 = 0, peer: screen_state.Peer = .{} };
+
+ pub fn init(gpa: Allocator) Screens {
+ return .{ .gpa = gpa, .enc = .init(gpa) };
+ }
+
+ /// `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);
+ s.peers.deinit(s.gpa);
+ s.out.deinit(s.gpa);
+ s.enc.deinit();
+ }
+
+ fn live(_: *const Screens, core: *Pardes, id: usize, tr: *const Tracked) bool {
+ const pane = core.panes[id] orelse return false;
+ return pane.serial == tr.serial and pane.terminal == tr.state;
+ }
+
+ /// A new peer, with nothing yet: its first delta of each terminal
+ /// starts it afresh.
+ pub fn addPeer(s: *Screens) !u16 {
+ const p = try s.gpa.create([pardes.MAX_PANES]PeerOf);
+ p.* = @splat(.{});
+ try s.peers.append(s.gpa, p);
+ return @intCast(s.peers.items.len - 1);
+ }
+
+ /// What `peer` is owed of every terminal, each a message onto `out`
+ /// (owned): nothing for one it has as it is, or with `bound` in flight.
+ pub fn flush(s: *Screens, core: *Pardes, peer: u16, out: *std.ArrayListUnmanaged([]u8)) !void {
+ const t0 = nowNs();
+ defer s.encode_ns += nowNs() - t0;
+ for (core.panes, 0..) |slot, id| {
+ const pane = slot orelse continue;
+ 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 };
+ var marks: [terminal.marks_len]u8 = undefined;
+ s.out.clearRetainingCapacity();
+ try writeScreenHead(&s.out, s.gpa, @intCast(id), pane.serial, kind_delta);
+ var w: std.Io.Writer.Allocating = .fromArrayList(s.gpa, &s.out);
+ defer s.out = w.toArrayList();
+ if (!try screen_state.encode(&s.enc, &tr.track, &pp.peer, &state.vt, state.changes, terminal.marksOf(state, &marks), &w.writer)) continue;
+ try out.append(s.gpa, try s.gpa.dupe(u8, w.written()));
+ }
+ }
+
+ fn track(s: *Screens, core: *Pardes, id: usize) !*Tracked {
+ const pane = core.panes[id].?;
+ if (s.tracks[id]) |*tr| {
+ if (s.live(core, id, tr)) return tr;
+ // Its pane closed (its emulator, the pin with it, gone).
+ tr.track.deinit(s.gpa, null);
+ }
+ s.tracks[id] = .{ .serial = pane.serial, .state = pane.terminal.?, .track = .init(s.gpa) };
+ return &s.tracks[id].?;
+ }
+
+ /// A peer's message (`Replica.screen`'s, `Replica.screenRequest`'s):
+ /// an answer for it (owned), or null.
+ pub fn take(s: *Screens, core: *Pardes, peer: u16, msg: []const u8) !?[]u8 {
+ const m = parseScreen(msg) orelse return null;
+ const pane = core.panes[m.pane] orelse return null;
+ if (pane.serial != m.serial) return null;
+ const state = pane.terminal orelse return null;
+ const pp = &s.peers.items[peer][m.pane];
+ if (pp.serial != m.serial) return null;
+ switch (m.kind) {
+ kind_ack => if (m.payload.len == 4) pp.peer.ack(std.mem.readInt(u32, m.payload[0..4], .little)),
+ kind_reset => pp.peer.reset(),
+ kind_rows => {
+ if (m.payload.len != 16) return null;
+ const tr = try s.track(core, m.pane);
+ s.out.clearRetainingCapacity();
+ try writeScreenHead(&s.out, s.gpa, m.pane, m.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, std.mem.readInt(u64, m.payload[0..8], .little), std.mem.readInt(u64, m.payload[8..16], .little), &w.writer);
+ return try s.gpa.dupe(u8, w.written());
+ },
+ else => {},
+ }
+ return null;
+ }
+};
+
// ---- a replica ----
pub const Stats = struct {
@@ -207,11 +377,14 @@ pub const Stats = struct {
rollback_ns: std.ArrayListUnmanaged(u64) = .empty,
copy_bytes: u64 = 0,
copies: u32 = 0,
+ /// Nanoseconds: a terminal's delta applied.
+ apply_ns: std.ArrayListUnmanaged(u64) = .empty,
pub fn deinit(s: *Stats, gpa: Allocator) void {
s.spec_ns.deinit(gpa);
s.copy_ns.deinit(gpa);
s.rollback_ns.deinit(gpa);
+ s.apply_ns.deinit(gpa);
}
};
@@ -242,11 +415,26 @@ pub const Replica = struct {
out: std.ArrayListUnmanaged(u8) = .empty,
/// Nanoseconds of the rollback being made, until its reapply.
recovering: ?u64 = null,
+ /// Its terminals' screen state, as the authority's deltas made it.
+ screens: [pardes.MAX_PANES]?ScreenOf = @splat(null),
+ screen_out: std.ArrayListUnmanaged(u8) = .empty,
+
+ const ScreenOf = struct {
+ serial: u32,
+ rep: screen_state.Replica = .{},
+ /// A delta was refused, and a reset asked for: those in flight
+ /// before it are refused unasked.
+ refused: bool = false,
+ /// The rows asked for and not yet answered.
+ asked: ?[2]u64 = null,
+ };
- /// A replica of the session whose first unit is `first`.
- pub fn init(gpa: Allocator, id: u16, first: []const u8) !*Replica {
+ /// A replica of the session whose first unit is `first`; `screens`
+ /// as the authority's (its terminals fed by `screen`).
+ pub fn init(gpa: Allocator, id: u16, first: []const u8, screens: bool) !*Replica {
const r = try gpa.create(Replica);
r.* = .{ .gpa = gpa, .id = id, .t = tape.memory(gpa) };
+ r.t.screen_state = screens;
r.t.core_gpa = r.epoch.allocator();
r.confirm(first);
if (r.t.core == null) {
@@ -257,6 +445,7 @@ pub const Replica = struct {
}
pub fn deinit(r: *Replica) void {
+ for (&r.screens) |*slot| if (slot.*) |*sc| sc.rep.deinit(r.coreGpa());
if (r.t.core) |c| {
const was = Stepping.begin(&r.t, &r.epoch);
if (r.copy.held) r.copy.restore();
@@ -269,6 +458,7 @@ pub const Replica = struct {
for (r.since.items) |u| r.gpa.free(u);
r.since.deinit(r.gpa);
r.out.deinit(r.gpa);
+ r.screen_out.deinit(r.gpa);
r.stats.deinit(r.gpa);
tape.release(&r.t);
if (r.diverged) |why| r.gpa.free(why);
@@ -471,6 +661,89 @@ pub const Replica = struct {
return r.pending.items.len == 0 and r.applied == 0 and !r.copy.held;
}
+ fn coreGpa(r: *Replica) Allocator {
+ return r.epoch.allocator();
+ }
+
+ /// One of the authority's terminal messages (`Screens.flush`, or an
+ /// answer to `screenRequests`), taken between units in stream order: a
+ /// delta written into its pane's emulator, or fetched rows. The
+ /// message for the authority (an acknowledgement, or a request to start
+ /// afresh), valid until the next call, or null.
+ pub fn screen(r: *Replica, msg: []const u8) ?[]const u8 {
+ const m = parseScreen(msg) orelse return null;
+ const c = r.t.core orelse return null;
+ const pane = c.panes[m.pane] orelse return null;
+ if (pane.serial != m.serial) return null; // a pane gone: its slot's next is another
+ const state = pane.terminal orelse return null;
+ const slot = &r.screens[m.pane];
+ if (slot.* == null or slot.*.?.serial != m.serial) {
+ if (slot.*) |*old| old.rep.deinit(r.coreGpa());
+ slot.* = .{ .serial = m.serial };
+ }
+ const sc = &slot.*.?;
+ // The emulator is the authority's, outside every rollback copy:
+ // what it allocates now must outlive one.
+ const was = r.epoch.pause();
+ defer r.epoch.unpause(was);
+ switch (m.kind) {
+ kind_delta => {
+ const t0 = nowNs();
+ const applied = sc.rep.apply(r.coreGpa(), terminal.terminalIo(), &state.vt, m.payload) catch |err| {
+ if (err != error.BaseMismatch) r.fail("a terminal's delta did not apply");
+ if (sc.refused) return null;
+ sc.refused = true;
+ return r.screenMessage(m.pane, m.serial, kind_reset, &.{});
+ };
+ r.stats.apply_ns.append(r.gpa, nowNs() - t0) catch {};
+ sc.refused = false;
+ terminal.takeMarks(state, applied.extra);
+ var seq: [4]u8 = undefined;
+ std.mem.writeInt(u32, &seq, applied.seq, .little);
+ return r.screenMessage(m.pane, m.serial, kind_ack, &seq);
+ },
+ kind_rows => {
+ sc.asked = null;
+ sc.rep.applyRows(r.coreGpa(), &state.vt, m.payload) catch r.fail("a terminal's rows did not apply");
+ return null;
+ },
+ else => return null,
+ }
+ }
+
+ /// A request for the rows a terminal shows here and does not hold (its
+ /// holes in view, after a scroll back), one a terminal at a time; null
+ /// when none is owed. Until the answer, a hole shows blank.
+ pub fn screenRequest(r: *Replica) ?[]const u8 {
+ const c = r.t.core orelse return null;
+ for (&r.screens, 0..) |*slot, id| {
+ const sc: *ScreenOf = if (slot.*) |*x| x else continue;
+ if (sc.asked != null) continue;
+ const pane = c.panes[id] orelse continue;
+ if (pane.serial != sc.serial) continue;
+ const state = pane.terminal orelse continue;
+ const shown = sc.rep.shown(&state.vt);
+ var holes: std.ArrayList([2]u64) = .empty;
+ defer holes.deinit(r.gpa);
+ sc.rep.missing(shown[0], shown[1], &holes, r.gpa) catch return null;
+ if (holes.items.len == 0) continue;
+ const want: [2]u64 = .{ holes.items[0][0], holes.items[holes.items.len - 1][1] };
+ sc.asked = want;
+ var range: [16]u8 = undefined;
+ std.mem.writeInt(u64, range[0..8], want[0], .little);
+ std.mem.writeInt(u64, range[8..16], want[1], .little);
+ return r.screenMessage(@intCast(id), sc.serial, kind_rows, &range);
+ }
+ return null;
+ }
+
+ fn screenMessage(r: *Replica, pane: u8, serial: u32, kind: u8, payload: []const u8) ?[]const u8 {
+ r.screen_out.clearRetainingCapacity();
+ writeScreenHead(&r.screen_out, r.gpa, pane, serial, kind) catch return null;
+ r.screen_out.appendSlice(r.gpa, payload) catch return null;
+ return r.screen_out.items;
+ }
+
pub fn digest(r: *Replica) u64 {
const was = Stepping.begin(&r.t, &r.epoch);
defer was.end();
@@ -484,7 +757,7 @@ fn terminalDigests(p: *const Pardes, out: *[pardes.MAX_PANES]u64) void {
const pane = slot orelse continue;
const state = pane.terminal orelse continue;
var h = walk.Hasher.init(0);
- state.digest(&h);
+ state.digestScreen(&h);
d.* = h.final();
}
}
@@ -513,9 +786,9 @@ fn key(r: *Replica, cp: u21, sent: *std.ArrayListUnmanaged([]u8)) !void {
test "a replica's own keys apply at once, confirm on the fast path, and end at the authority's digest" {
const gpa = std.testing.allocator;
- const a = try Authority.init(gpa, .{ .cols = 80, .rows = 24, .file = "mise.toml" }, TestHost.host());
+ const a = try Authority.init(gpa, .{ .cols = 80, .rows = 24, .file = "mise.toml" }, TestHost.host(), false);
defer a.deinit();
- const r = try Replica.init(gpa, 1, try a.unit(0, 0));
+ const r = try Replica.init(gpa, 1, try a.unit(0, 0), false);
defer r.deinit();
try std.testing.expectEqual(digestOf(a), r.digest());
var sent: std.ArrayListUnmanaged([]u8) = .empty;
@@ -539,13 +812,13 @@ test "a replica's own keys apply at once, confirm on the fast path, and end at t
test "another client's input first: a replica rolls back, replays it and applies its own again" {
const gpa = std.testing.allocator;
- const a = try Authority.init(gpa, .{ .cols = 80, .rows = 24, .file = "mise.toml" }, TestHost.host());
+ const a = try Authority.init(gpa, .{ .cols = 80, .rows = 24, .file = "mise.toml" }, TestHost.host(), false);
defer a.deinit();
const first = try gpa.dupe(u8, try a.unit(0, 0));
defer gpa.free(first);
- const r1 = try Replica.init(gpa, 1, first);
+ const r1 = try Replica.init(gpa, 1, first, false);
defer r1.deinit();
- const r2 = try Replica.init(gpa, 2, first);
+ const r2 = try Replica.init(gpa, 2, first, false);
defer r2.deinit();
var s1: std.ArrayListUnmanaged([]u8) = .empty;
var s2: std.ArrayListUnmanaged([]u8) = .empty;