summaryrefslogtreecommitdiff
path: root/src/replica.zig
diff options
context:
space:
mode:
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;