//! A session's replicas (docs/next-daemon.md, phase 5 part A): the authority //! orders every input and records what its core consumed (src/tape.zig); //! each replica runs a core of its own, applies its own inputs at once, and //! takes the authority's stream as the truth. //! //! A replica's state is the confirmed position plus its own pending inputs, //! applied on top (a speculation, recorded as the authority would record //! it). For each unit of the authority's stream, in order: //! - its own pending head, recorded the same (inputs, host calls and //! answers): the head goes, nothing is redone (the fast path); //! - else the rollback copy is put back (src/rollback.zig), the confirmed //! units since it are replayed, then this one, and the pending inputs //! are applied again. //! A speculation that reaches a host call or a syscall (a Host function, //! a `tape.site`) or an emulator (the authority's) stops: the copy is put //! back and the input waits for the authority's answer, one RTT late but //! never wrong. Clock and environment reads (`tape.value`) are made here, //! and the comparison catches a guess the authority did not share. //! //! No transport: messages are bytes in and out. A client's input is its //! id, a sequence number and the event as wire.zig frames it; a //! unit is the input's origin (0 for the authority's own: a pty's output, a //! tick), its sequence number and the authority's tape of it. const std = @import("std"); const builtin = @import("builtin"); const pardes = @import("pardes.zig"); const tape = @import("tape.zig"); const rollback = @import("rollback.zig"); const walk = @import("walk.zig"); const wire = @import("wire.zig"); const daemon = @import("daemon.zig"); const writeAll = daemon.writeAll; const screen_state = @import("screen_state.zig"); const c_heap = @import("c_heap"); const terminal = pardes.panes.terminal; const Allocator = std.mem.Allocator; const Pardes = pardes.Pardes; const checked = builtin.mode == .debug or builtin.mode == .safe; const head_len = 6; // origin or client: u16le, seq: u32le /// A `stamp` frame (wire.zig): its header and the two clocks. const stamp_len = wire.header_len + 16; /// Confirmed units fast-pathed under one copy before it is taken afresh: /// a rollback replays them all. const rebase_after = 32; fn header(buf: []u8, who: u16, seq: u32) void { std.mem.writeInt(u16, buf[0..2], who, .little); std.mem.writeInt(u32, buf[2..6], seq, .little); } /// A unit's head: its origin and seq, then the authority's clocks when it /// was made (realtime and monotonic, ns), which a replica's guesses of the /// session's clock start from. const unit_head = head_len + 16; pub const Unit = struct { origin: u16, seq: u32, real_ns: i64 = 0, mono_ns: i64 = 0, tape: []const u8 }; pub fn parseUnit(msg: []const u8) ?Unit { if (msg.len < unit_head) return null; return .{ .origin = std.mem.readInt(u16, msg[0..2], .little), .seq = std.mem.readInt(u32, msg[2..6], .little), .real_ns = std.mem.readInt(i64, msg[6..14], .little), .mono_ns = std.mem.readInt(i64, msg[14..22], .little), .tape = msg[unit_head..], }; } fn clockNs(id: std.c.clockid_t) i64 { var ts: std.c.timespec = undefined; if (std.c.clock_gettime(id, &ts) != 0) return 0; return @as(i64, ts.sec) * std.time.ns_per_s + ts.nsec; } fn unitHeader(buf: []u8, origin: u16, seq: u32) void { header(buf, origin, seq); std.mem.writeInt(i64, buf[6..14], clockNs(.REALTIME), .little); std.mem.writeInt(i64, buf[14..22], clockNs(.MONOTONIC), .little); } pub const Input = struct { client: u16, seq: u32, event: pardes.Event, stamp: ?[2]i64 = null }; /// A client's input message: its head, a `stamp` frame (when its client /// guessed the session's clocks), and its event's frame, which the event /// borrows. pub fn parseInput(msg: []const u8) ?Input { if (msg.len < head_len) return null; var rest = msg[head_len..]; var f = (wire.framed(rest) catch return null) orelse return null; var stamp: ?[2]i64 = null; if (f.tag == @backingInt(wire.ClientTag.stamp)) { stamp = (wire.decodeClient(f.tag, f.payload) catch return null).stamp; rest = rest[f.total..]; f = (wire.framed(rest) catch return null) orelse return null; } const ev = switch (wire.decodeClient(f.tag, f.payload) catch return null) { .event => |ev| ev, else => return null, }; return .{ .client = std.mem.readInt(u16, msg[0..2], .little), .seq = std.mem.readInt(u32, msg[2..6], .little), .event = ev, .stamp = stamp }; } /// An input's stamp as the authority takes it: the client's guess of its /// clocks, so the guess its speculation recorded is the step's own; none /// from a client a second or more off (a stall, a bad round trip), whose /// step reads the clocks here. fn stampOf(in: Input) ?tape.Guess { const s = in.stamp orelse return null; if (@abs(s[0] - clockNs(.REALTIME)) >= std.time.ns_per_s or @abs(s[1] - clockNs(.MONOTONIC)) >= std.time.ns_per_s) return null; return .{ .real_ns = s[0], .mono_ns = s[1], .gmtoff = gmtoff() }; } /// The core whose tape is `t`, stepped: tape.on is process-wide, and so /// are syntax.zig's held trees, so one process can step several. const Stepping = struct { tape: ?*tape.Tape, trees: ?*pardes.syntax.HeldTrees, fn begin(t: *tape.Tape, epoch: ?*rollback.Epoch) Stepping { const was: Stepping = .{ .tape = tape.on, .trees = pardes.syntax.held_trees }; tape.on = t; rollback.Epoch.select(epoch); return was; } fn end(was: Stepping) void { tape.on = was.tape; pardes.syntax.held_trees = was.trees; } }; const nowNs = pardes.FrameStats.nowNs; /// With PARDES_REPLICA_TRACE, a line on stderr, each of `tapes` described /// after it. fn trace(gpa: Allocator, comptime fmt: []const u8, args: anytype, tapes: []const []const u8) void { if (std.c.getenv("PARDES_REPLICA_TRACE") == null) return; var w: std.Io.Writer.Allocating = .init(gpa); defer w.deinit(); w.writer.print(fmt, args) catch {}; for (tapes) |t| tape.describe(t, &w.writer); std.debug.print("{s}", .{w.written()}); } /// The `p`th percentile of `samples` (sorted here); 100 is the worst. fn pctOf(samples: []u64, p: usize) u64 { if (samples.len == 0) return 0; std.mem.sort(u64, samples, {}, std.sort.asc(u64)); return samples[@min(samples.len - 1, samples.len * p / 100)]; } // ---- the authority ---- pub const Authority = struct { gpa: Allocator, t: tape.Tape, core: *Pardes, host: pardes.Host, out: std.ArrayListUnmanaged(u8) = .empty, seq: u32 = 0, /// 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. /// `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; opts.image_allocator = opts.image_allocator orelse gpa; opts.pdf_allocator = opts.pdf_allocator orelse gpa; opts.tree_sitter_allocator = opts.tree_sitter_allocator orelse gpa; opts.frame_allocator = opts.frame_allocator orelse gpa; 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); a.core.host = host; a.core.pump(host) catch {}; return a; } pub fn deinit(a: *Authority) void { const was = Stepping.begin(&a.t, null); a.core.deinit(); was.end(); tape.release(&a.t); a.out.deinit(a.gpa); a.gpa.destroy(a); } /// What was recorded since the last unit, as one (the boot's, a setup's /// done straight on the core). pub fn unit(a: *Authority, origin: u16, seq: u32) ![]const u8 { a.out.clearRetainingCapacity(); try a.out.appendNTimes(a.gpa, 0, unit_head); unitHeader(a.out.items, origin, seq); try a.out.appendSlice(a.gpa, a.t.buf.items); a.t.buf.clearRetainingCapacity(); return a.out.items; } /// An input of the authority's own (a pty's output, a tick, a setup's /// command), recorded into the unit being made. pub fn apply(a: *Authority, ev: pardes.Event) void { const was = Stepping.begin(&a.t, null); a.core.update(ev); a.core.pump(a.host) catch {}; was.end(); } /// 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.recordDigest(&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(); return error.TooManyViews; }; a.core.pump(a.host) catch {}; was.end(); a.view_of[client] = k; a.seq += 1; return .{ .view = k, .unit = try a.unit(0, a.seq) }; } /// Client `client`'s view gone (its link ended), as its unit. pub fn closeView(a: *Authority, client: u16) ![]const u8 { std.debug.assert(a.batched == 0); const was = Stepping.begin(&a.t, null); a.core.closeView(a.view_of[client]); was.end(); a.seq += 1; return a.unit(0, a.seq); } /// 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]); a.t.stamp = stampOf(in); a.core.update(in.event); a.core.step(); a.t.stamp = null; was.end(); return a.unit(in.client, in.seq); } }; // ---- 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 (encodeRows): asked for, // or a step read them; // 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. // In the authority's stream to a peer, before it steps any input but a // pty's output, and once a frame: its own steps since the last unit, as one // (`Authority.pending`), then what the peer is owed of the terminals // (`Screens.flush`). After a step, before its unit: the rows it read that // the peer holds as holes (`Screens.fill`, then `filled`). A replica takes // them in that order between units (`Replica.screen`), so a step it replays // reads the terminal its authority's step 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, free_peers: std.ArrayListUnmanaged(u16) = .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| { for (p) |*pp| pp.peer.deinit(s.gpa); s.gpa.destroy(p); } s.peers.deinit(s.gpa); s.free_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 { if (s.free_peers.pop()) |again| return again; 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); } /// Peer `peer` gone: what it was sent forgotten, its number free for /// the next `addPeer` (a socket's clients come and go). pub fn dropPeer(s: *Screens, peer: u16) void { for (s.peers.items[peer]) |*pp| pp.peer.deinit(s.gpa); s.peers.items[peer].* = @splat(.{}); s.free_peers.append(s.gpa, peer) catch {}; } /// 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.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); 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())); } } /// 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| { 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 { inputs: u32 = 0, /// Applied at once and clean. speculated: u32 = 0, /// Stopped at a host call, a syscall or an emulator: waits one RTT. stopped: u32 = 0, /// Not tried: an event of the view's (a resize, the pointer), phase 4's. unspeculated: u32 = 0, /// The authority's unit was the pending head, recorded the same. fast: u32 = 0, /// The copy put back: the head recorded otherwise (a guess of the clock /// the authority did not share), or another's unit first. mispredicted: u32 = 0, foreign: u32 = 0, rebases: u32 = 0, units: u32 = 0, /// The samples below kept: an in-process harness's replica, or a /// client's with PARDES_REPLICA_STATS. Without, nothing is: a client /// runs for days, and they grew a word an input and a delta. samples: bool = false, /// Nanoseconds: one speculative apply, a copy taken, a rollback (the /// copy put back, the confirmed units replayed, the pending reapplied). spec_ns: std.ArrayListUnmanaged(u64) = .empty, copy_ns: std.ArrayListUnmanaged(u64) = .empty, 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, /// What stopped them (`Tape.poisoned_by`), a count a name. stops: [16]Stop = @splat(.{}), const Stop = struct { name: []const u8 = "", n: u32 = 0 }; fn stop(s: *Stats, name: []const u8) void { for (&s.stops) |*st| if (st.n == 0 or std.mem.eql(u8, st.name, name)) { st.name = name; st.n += 1; return; }; } /// `name:n,...` (spaces as dashes), or `-`. fn writeStops(s: *const Stats, w: *std.Io.Writer) !void { var any = false; for (s.stops) |st| if (st.n > 0) { if (any) try w.writeByte(','); any = true; for (st.name) |ch| try w.writeByte(if (ch == ' ') '-' else ch); try w.print(":{d}", .{st.n}); }; if (!any) try w.writeByte('-'); } 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); } }; /// `terminal`: its speculation read a terminal or moved one's view (or a /// terminal had the keyboard), so what it did depends on the emulator. const Pending = struct { seq: u32, msg: []u8, spec: ?[]u8 = null, sent_ns: u64 = 0, terminal: bool = false, guess: ?tape.Guess = null }; /// A terminal's view as the authority's was once `after` of the units /// since the copy were taken (`Replica.since`): a delta's comes after the /// units it shows, so those before it are not replayed over it. const View = struct { at: ?usize = null, after: usize = 0 }; pub const Replica = struct { gpa: Allocator, id: u16, /// Its own view of the session (Authority.openView's). view: u8 = 0, /// The core's allocator; its tapes and the engine's own lists are not. epoch: rollback.Epoch = .{}, t: tape.Tape, copy: rollback.Copy = .{}, pending: std.ArrayListUnmanaged(Pending) = .empty, /// pending[0..applied] are applied on top of the confirmed position. applied: usize = 0, /// The pending input that waits for the authority (it stopped at a host /// call, or is the view's), and those after it with it. blocked: ?u32 = null, /// Confirmed units fast-pathed since the copy was taken. since: std.ArrayListUnmanaged([]u8) = .empty, /// Pending inputs to apply again (after a rollback). dirty: bool = false, next_seq: u32 = 1, stats: Stats = .{}, diverged: ?[]const u8 = null, out: std.ArrayListUnmanaged(u8) = .empty, /// Nanoseconds of the rollback being made, until its reapply. recovering: ?u64 = null, /// The digest the last confirmed unit ended on (its last record's /// bytes): a unit of another's that ends on it again (the session's /// pump that took this replica's input in, and moved nothing) leaves /// the speculation on top as it was. last_digest: std.ArrayListUnmanaged(u8) = .empty, /// Units of another's taken so, no rollback made. neutral: u32 = 0, /// What it shows changed since the host last drew it: a unit replayed /// on it, a rollback (a unit that confirmed what it applied, or moved /// nothing, changes nothing to draw). moved: bool = false, /// A client of a session elsewhere (`initDump`): the session's clock is /// guessed, never read here -- its last unit's reading, plus the time /// since it came, plus a round trip (the input reaches the session that /// much later). In process, both read one clock. guess: bool = false, stamp: struct { real_ns: i64 = 0, mono_ns: i64 = 0, at_ns: u64 = 0 } = .{}, rtt_ns: u64 = 0, gmtoff: i32 = 0, /// Its terminals' screen state, as the authority's deltas made it. screens: [pardes.MAX_PANES]?ScreenOf = @splat(null), /// Each terminal's view (`terminal.viewOf`) as the copy was taken, or /// as the last delta since set it: the copy holds no emulator, and a /// speculation may move a view, so a rollback puts these back. views: [pardes.MAX_PANES]View = @splat(.{}), screen_out: std.ArrayListUnmanaged(u8) = .empty, /// Its predicted echo (src/echo.zig), drawn over its core's terminals: /// fed by its keys, its units and its deltas here, and by `echoFrame`. echo: pardes.echo.Echo = .{}, 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`; `screens` /// as the authority's (its terminals fed by `screen`). In process, its /// timing samples kept for the harness that reads them. 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), .stats = .{ .samples = true } }; r.t.screen_state = screens; r.t.core_gpa = r.epoch.allocator(); r.confirm(first); if (r.t.core == null) { r.deinit(); return error.NoCore; } if (screens) r.core().echo = &r.echo; return r; } /// A replica of a session elsewhere, as its walker dump (src/dump.zig) /// is: what a client of a socket joins with. `opts` are this process's /// (a replica's own allocators and names); its core's allocator is the /// rollback epoch's, but for images and PDFs, whose workers allocate on /// threads of their own. ponytail: a picture's pixels freed while a copy /// is held are not put off; a rollback over one shows an image a frame /// late at worst... or reads freed pixels, which no test session has. pub fn initDump(gpa: Allocator, id: u16, view: u8, bytes: []const u8, opts: pardes.Options) !*Replica { const r = try gpa.create(Replica); r.* = .{ .gpa = gpa, .id = id, .view = view, .t = tape.memory(gpa), .guess = true }; r.t.headless = true; // Its terminals are the session's deltas (Peers sends them). r.t.screen_state = true; errdefer { tape.release(&r.t); r.epoch.deinit(); gpa.destroy(r); } const epoch = r.epoch.allocator(); r.t.core_gpa = epoch; var o = opts; o.frame_allocator = epoch; o.tree_sitter_allocator = epoch; o.image_allocator = o.image_allocator orelse std.heap.c_allocator; o.pdf_allocator = o.pdf_allocator orelse std.heap.c_allocator; // The session's store and Recent are the authority's. o.store_path = null; // Its emulators off the epoch, as `terminal.create` makes a screen // replica's: deltas write them while a copy is held. pardes.dump.terminal_gpa = terminal.emulator_gpa; defer pardes.dump.terminal_gpa = null; const c = try pardes.dump.load(epoch, o, bytes, null); // What loading queued (a watch, a theme asked for) is the // authority's errand, done there already: the session was dumped // between steps, with nothing queued. c.effects_len = 0; c.effects_head = 0; c.in_len = 0; c.in_head = 0; tape.adoptCore(&r.t, c); // Its keys into a terminal drawn at once (src/echo.zig). c.echo = &r.echo; return r; } pub fn deinit(r: *Replica) void { for (&r.screens) |*slot| if (slot.*) |*sc| sc.rep.deinit(terminal.emulator_gpa); if (r.t.core) |c| { const was = Stepping.begin(&r.t, &r.epoch); if (r.copy.held) r.copy.restore(); c.deinit(); was.end(); } r.copy.deinit(); for (r.pending.items) |p| r.freePending(p); r.pending.deinit(r.gpa); 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.last_digest.deinit(r.gpa); r.stats.deinit(r.gpa); tape.release(&r.t); if (r.diverged) |why| r.gpa.free(why); r.epoch.deinit(); r.gpa.destroy(r); } pub fn core(r: *const Replica) *Pardes { return r.t.core.?; } fn freePending(r: *Replica, p: Pending) void { r.gpa.free(p.msg); if (p.spec) |s| r.gpa.free(s); } /// The replica's own input: applied at once when it can be, and the /// message for the authority returned (valid until the next call). pub fn input(r: *Replica, ev: pardes.Event) ![]const u8 { r.stats.inputs += 1; const seq = r.next_seq; r.next_seq += 1; // Its time, as the session's clocks will read when it steps it (a // round trip on from the last unit's, the clocks here in process): // the step's clock reads, here and there (`stampOf`). const g: tape.Guess = if (r.guess) guess: { const since: i64 = @intCast(nowNs() -| r.stamp.at_ns + r.rtt_ns); break :guess .{ .real_ns = r.stamp.real_ns + since, .mono_ns = r.stamp.mono_ns + since, .gmtoff = r.gmtoff }; } else .{ .real_ns = clockNs(.REALTIME), .mono_ns = clockNs(.MONOTONIC), .gmtoff = gmtoff() }; const room = try r.gpa.alloc(u8, head_len + stamp_len + wire.clientBound(.{ .event = ev })); defer r.gpa.free(room); _ = try wire.encodeClient(room[head_len..][0..stamp_len], .{ .stamp = .{ g.real_ns, g.mono_ns } }); const n = (try wire.encodeClient(room[head_len + stamp_len ..], .{ .event = ev })).len; header(room, r.id, seq); const msg = try r.gpa.dupe(u8, room[0 .. head_len + stamp_len + n]); try r.pending.append(r.gpa, .{ .seq = seq, .msg = msg, .sent_ns = nowNs(), .guess = g }); r.dirty = true; r.settle(); if (r.t.screen_state and r.diverged == null) r.echo.typed(r.core(), r.view, ev, seq, r.applied == r.pending.items.len); r.out.clearRetainingCapacity(); try r.out.appendSlice(r.gpa, msg); return r.out.items; } /// One unit of the authority's stream, in its order. pub fn confirm(r: *Replica, msg: []const u8) void { if (r.diverged != null) return; const u = parseUnit(msg) orelse return r.fail("a unit too short to read"); r.stats.units += 1; if (u.origin == r.id) if (r.t.core) |c| r.echo.confirmed(c, u.seq); // A copy taken ahead (`ready`), nothing on top: the unit moves the // state it was of. if (r.applied == 0 and r.copy.held) { r.copy.release(); rollback.Epoch.select(null); r.clearSince(); } if (r.guess) { r.stamp = .{ .real_ns = u.real_ns, .mono_ns = u.mono_ns, .at_ns = nowNs() }; if (u.origin == r.id) for (r.pending.items) |p| if (p.seq == u.seq) { // Sent to confirmed: what reaching the session takes, and back. if (p.sent_ns != 0) r.rtt_ns = nowNs() -| p.sent_ns; break; }; } const was = Stepping.begin(&r.t, &r.epoch); defer was.end(); if (u.origin == r.id and r.pending.items.len > 0 and r.pending.items[0].seq == u.seq and r.applied > 0 and tape.sameRecords(r.pending.items[0].spec.?, u.tape)) { r.stats.fast += 1; if (r.pending.items[0].terminal and r.applied > 1) { // Right, but what it did read a terminal: replayed later (a // rollback's `since`) it would read the deltas that came // after it. So it is taken now, over the emulator its step // read, and the ones on top applied again over it. r.toConfirmed(); if (tape.replayUnit(&r.t, u.tape)) |why| return r.fail(why); if (lastDigest(u.tape)) |d| { r.last_digest.clearRetainingCapacity(); r.last_digest.appendSlice(r.gpa, d) catch {}; } r.freePending(r.pending.orderedRemove(0)); r.dirty = true; return; } r.freePending(r.pending.orderedRemove(0)); r.applied -= 1; if (r.applied == 0) { // Nothing speculative on top any more: the state is the // confirmed one, which its digest says. A step of its own // that read what the session's did not (a frame's, a // derived field's) shows here, at the input that did it, // not at some later unit replayed. if (lastDigest(u.tape)) |d| { r.t.check(d); if (r.t.diverged) |why| { trace(r.gpa, "replica {d}: its input {d} came to another state than the session's: {s}\n", .{ r.id, u.seq, why }, &.{u.tape}); return r.fail(why); } } r.copy.release(); rollback.Epoch.select(null); r.clearSince(); return; } return r.keepSince(u.tape); } const ends = lastDigest(u.tape); defer if (ends) |d| { r.last_digest.clearRetainingCapacity(); r.last_digest.appendSlice(r.gpa, d) catch {}; }; if (r.applied > 0 and u.origin != r.id and ends != null and std.mem.eql(u8, ends.?, r.last_digest.items)) { // Nothing a digest covers moved: what was applied on top is // what the session will apply on top of it. Replayed when the // copy is next put back. r.neutral += 1; return r.keepSince(u.tape); } if (r.applied > 0) { if (u.origin == r.id) r.stats.mispredicted += 1 else r.stats.foreign += 1; if (u.origin == r.id and std.c.getenv("PARDES_REPLICA_TRACE") != null) { trace(r.gpa, "replica {d}: its input {d} was recorded otherwise; it guessed:\n", .{ r.id, u.seq }, &.{r.pending.items[0].spec.?}); trace(r.gpa, "and the authority recorded:\n", .{}, &.{u.tape}); } r.recovering = nowNs(); r.toConfirmed(); } r.moved = true; if (tape.replayUnit(&r.t, u.tape)) |why| { trace(r.gpa, "replica {d}: the unit of {d}/{d} diverged: {s}\n", .{ r.id, u.origin, u.seq, why }, &.{u.tape}); return r.fail(why); } if (u.origin == r.id) { if (r.pending.items.len == 0 or r.pending.items[0].seq != u.seq) return r.fail("the authority confirmed an input this replica did not send next"); if (r.blocked == u.seq) r.blocked = null; r.freePending(r.pending.orderedRemove(0)); } r.dirty = true; } fn fail(r: *Replica, why: []const u8) void { if (r.diverged == null) r.diverged = r.gpa.dupe(u8, why) catch return; } /// A unit kept to replay when the copy is next put back; past /// `rebase_after` of them, that is now (`toConfirmed`). fn keepSince(r: *Replica, unit: []const u8) void { const kept = r.gpa.dupe(u8, unit) catch return r.fail("out of memory"); r.since.append(r.gpa, kept) catch return r.fail("out of memory"); if (r.since.items.len >= rebase_after) { r.stats.rebases += 1; r.toConfirmed(); r.dirty = true; } } fn clearSince(r: *Replica) void { for (r.since.items) |u| r.gpa.free(u); r.since.clearRetainingCapacity(); } /// Back to the confirmed position: the copy put back, the units fast- /// pathed since replayed. fn toConfirmed(r: *Replica) void { const held = r.copy.held; if (held) { r.copy.restore(); rollback.Epoch.select(null); // 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; // Its views as the copy was taken, or as a delta set them between // the units since (which may move them again). for (r.since.items, 0..) |u, i| { if (held) r.putViews(i); if (tape.replayUnit(&r.t, u)) |why| return r.fail(why); } if (held) r.putViews(r.since.items.len); r.clearSince(); for (r.pending.items) |*p| if (p.spec) |s| { r.gpa.free(s); p.spec = null; }; } /// The pending inputs applied again, as far as they go. pub fn settle(r: *Replica) void { if (!r.dirty or r.diverged != null) return; r.dirty = false; const was = Stepping.begin(&r.t, &r.epoch); defer was.end(); while (r.applied < r.pending.items.len and r.blocked != r.pending.items[r.applied].seq) if (!r.speculate()) break; if (r.recovering) |t0| { if (r.stats.samples) r.stats.rollback_ns.append(r.gpa, nowNs() - t0) catch {}; r.recovering = null; } } /// pending[applied] applied on top: whether it was. fn speculate(r: *Replica) bool { const p = &r.pending.items[r.applied]; // Every kind, a view's own (a resize, the pointer) too: each client // has its own view, and what reaches the authority's (a pty's size, // the pointer over a sliding pane) stops it as any host call does. const in = parseInput(p.msg) orelse return false; 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; r.keepViews(); rollback.Epoch.select(&r.epoch); if (r.stats.samples) r.stats.copy_ns.append(r.gpa, nowNs() - t0) catch {}; r.stats.copy_bytes += r.copy.savedBytes(); r.stats.copies += 1; } var terminals: [pardes.MAX_PANES]u64 = undefined; if (checked) terminalDigests(c, &terminals); const t0 = nowNs(); tape.beginSpeculation(&r.t); // The time it was sent with, every time it is applied. r.t.guess = p.guess; c.toView(r.view); // Input into a terminal: what reaches its program (a key in tty // mode, a paste, a mouse report) is a pty write, the authority's, // and stops here (phase 6 predicts its echo). The rest (pardes's // own keys over it, the wheel) reads its emulator, here the last // delta's and there what the pty has said since: it is applied, // and applied again over each delta while it waits (`screen`), so // what the authority's unit confirms read the emulator its step // read (the deltas come before it). const keyboard = if (c.panes[c.active]) |pane| pane.terminal != null else false; c.update(in.event); c.step(); p.terminal = r.t.screen_state and (keyboard or r.t.touched); // No digest is taken here: a blob born under the copy and digested // keeps its word past the epoch's free of it (src/walk.zig), and a // later blob at that address read as it. const clean = tape.endSpeculation(&r.t); const dt = nowNs() - t0; // Where a blob was written, should one be: the input that did. if (checked and std.c.getenv("PARDES_REPLICA_TRACE") != null) r.copy.check(); if (!clean) { // Undone, and the earlier ones applied again on the confirmed // position: this one waits for the authority. r.stats.stopped += 1; r.stats.stop(r.t.poisoned_by); if (std.c.getenv("PARDES_REPLICA_TRACE") != null) std.debug.print("replica {d}: its input {d} ({t}) stopped at a host call ({s}): it waits\n", .{ r.id, p.seq, in.event, r.t.poisoned_by }); r.blocked = p.seq; const upto = r.applied; r.toConfirmed(); while (r.applied < upto) if (!r.speculate()) break; if (r.applied == 0 and r.copy.held) { r.copy.release(); rollback.Epoch.select(null); } return false; } if (checked) { var after: [pardes.MAX_PANES]u64 = undefined; terminalDigests(c, &after); if (!std.mem.eql(u64, &terminals, &after)) { for (terminals, after, 0..) |x, y, id| if (x != y) std.debug.print("replica {d}: its input {d} ({any}) wrote terminal {d}\n", .{ r.id, p.seq, in.event, id }); @panic("replica: a speculation wrote a terminal's emulator"); } } r.stats.speculated += 1; if (r.stats.samples) r.stats.spec_ns.append(r.gpa, dt) catch {}; p.spec = r.gpa.dupe(u8, r.t.buf.items) catch return false; r.t.buf.clearRetainingCapacity(); r.applied += 1; return true; } /// Its client's, once a frame before it draws: a predicted echo the /// screen has not shown in time goes, and keys deferred behind one not /// predicted are predicted once its doing is on the screen. Whether what /// the overlay draws changed since the last call (by a key, a unit, a /// delta or this: `echo.changed`). pub fn echoFrame(r: *Replica) bool { return r.echo.frame(r.core()); } /// Nothing pending and nothing applied: the replica is the authority's /// confirmed state, which `digest` says (a copy taken ahead, `ready`, /// has nothing on top of it). pub fn quiet(r: *const Replica) bool { return r.pending.items.len == 0 and r.applied == 0; } /// The copy taken now, while nothing is pending (the host is idle, its /// frame drawn), so that the next input of its own is applied at once /// without taking it: a copy is a megabyte saved. Let go when a unit /// comes first. pub fn ready(r: *Replica) void { if (r.copy.held or r.pending.items.len > 0 or r.diverged != null) return; const c = r.core(); const t0 = nowNs(); rollback.Epoch.select(&r.epoch); defer rollback.Epoch.select(null); r.copy.take(&r.epoch, c) catch return; r.keepViews(); if (r.stats.samples) r.stats.copy_ns.append(r.gpa, nowNs() - t0) catch {}; r.stats.copy_bytes += r.copy.savedBytes(); r.stats.copies += 1; } fn keepViews(r: *Replica) void { if (!r.t.screen_state) return; for (r.core().panes, &r.views) |slot, *v| v.* = .{ .at = if (slot) |pane| terminal.viewOf(pane) else null }; } fn putViews(r: *Replica, after: usize) void { if (!r.t.screen_state) return; for (r.core().panes, r.views) |slot, v| if (v.after == after) if (slot) |pane| if (pane.terminal != null) terminal.viewTo(pane, v.at); } /// Whether its core loaded from the dump is the session as it was /// dumped, by the welcome's `digest`. pub fn loaded(r: *Replica, want: u64) bool { return r.digest() == want; } /// Its own view drawn and presented through `present`, between steps /// (views.drawOne): nothing the digest covers moves. The epoch's trees /// held while a copy is (a render can make or drop a syntax tree). pub fn draw(r: *Replica, present: pardes.views.Present) void { rollback.Epoch.select(&r.epoch); defer rollback.Epoch.select(null); pardes.views.drawOne(r.core(), r.view, present) catch {}; } /// `f(ctx, core)` with its own view live, outside any step, as `draw` /// draws it (views.within): what its frontend reads of its own view /// (its pointer's cells, its size) while another client's input was the /// session's last. pub fn within(r: *Replica, ctx: anytype, comptime f: fn (@TypeOf(ctx), *Pardes) anyerror!void) void { rollback.Epoch.select(&r.epoch); defer rollback.Epoch.select(null); pardes.views.within(r.core(), r.view, ctx, f) catch {}; } /// 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(terminal.emulator_gpa); slot.* = .{ .serial = m.serial }; } const sc = &slot.*.?; // The emulator is the authority's: on the C heap, outside the // rollback epoch, so a copy held now never saves or puts back any // of what this writes (State.gpa). switch (m.kind) { kind_delta => { const t0 = nowNs(); const applied = sc.rep.apply(state.gpa, 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, &.{}); }; if (r.stats.samples) r.stats.apply_ns.append(r.gpa, nowNs() - t0) catch {}; sc.refused = false; terminal.takeMarks(state, applied.extra); r.echo.delta(c, m.pane, sc.rep.top); // Its rows as the core keeps them read are another grid's. c.shell_rows.markStale(pane); // Its view is the authority's now: a rollback puts it back // here, and what was applied over a terminal goes on top. if (r.copy.held) r.views[m.pane] = .{ .at = terminal.viewOf(pane), .after = r.since.items.len }; r.overTerminals(); 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(state.gpa, &state.vt, m.payload) catch r.fail("a terminal's rows did not apply"); c.shell_rows.markStale(pane); r.overTerminals(); return null; }, else => return null, } } /// A terminal was written (a delta, rows): what is applied over the /// emulator (`Pending.terminal`) read the one before it, and the /// authority's step reads this one (it comes before that step's unit). /// Back to the confirmed position, to be applied again over it. fn overTerminals(r: *Replica) void { const any = for (r.pending.items[0..r.applied]) |p| { if (p.terminal) break true; } else false; if (!any) return; const was = Stepping.begin(&r.t, &r.epoch); defer was.end(); r.toConfirmed(); r.dirty = true; } /// 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.rep.blank(&state.vt, want[0], want[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(); return tape.digestOf(r.core()); } }; /// The bytes of a unit's last digest record: the state it ended on; null /// for one that says what the host wrote or which host it is (a replica's /// core takes those only by replaying the unit). fn lastDigest(bytes: []const u8) ?[]const u8 { var r: walk.Reader = .{ .bytes = bytes }; var last: ?[]const u8 = null; while (true) { const head = r.take(5) catch return last; const payload = r.take(std.mem.bytesToValue(u32, head[1..5])) catch return last; if (head[0] == tape.digest_kind) last = payload; if (head[0] == tape.set_kind) return null; } } fn terminalDigests(p: *const Pardes, out: *[pardes.MAX_PANES]u64) void { for (p.panes, out) |slot, *d| { d.* = 0; const pane = slot orelse continue; const state = pane.terminal orelse continue; var h = walk.Hasher.init(0); // Its view aside: a speculation may move it (`views`). state.digestScreen(&h, false); d.* = h.final(); } } // ---- over a socket (docs/next-daemon.md, "Phase 5 part B notes") ---- // // The session's half: each client handed over by the daemon (daemon.zig) is // a Peer, with a view of its own, a thread reading its inputs and one // writing what it is sent. The recorder is on while any is. At each step // boundary of the session's loop (`Peers.boundary`, after a pump): // - the pump's unit goes to every client; // - a client that came is joined: its view opened, the session dumped // (src/dump.zig) and sent ahead of every unit after; // - each input that came is a unit of its own: its view, the input, a // `step` (what the client's own core applied at once); // - a client gone takes its view with it. // A client's link only ever holds bytes queued for it: the session's step // never waits on one. One that lets `lag_max` pile up is cut off. const libc = std.c; const log = std.log.scoped(.replica); /// What a client may leave unread, past its join's dump, before it is cut /// off: minutes of typing, a screenful of a flood's deltas many times over. const lag_max: usize = 64 << 20; const dump_piece = 1 << 20; /// A blob in a far join's list (wire.zig `blobs`): its place in the state /// (u64le), its length (u64le) and its BLAKE3 hash. const blob_entry = 48; const Tm = extern struct { sec: c_int, min: c_int, hour: c_int, mday: c_int, mon: c_int, year: c_int, wday: c_int, yday: c_int, isdst: c_int, gmtoff: c_long, zone: ?[*:0]const u8 }; extern "c" fn localtime_r(t: *const libc.time_t, tm: *Tm) ?*Tm; /// This zone's offset from UTC now, seconds. fn gmtoff() i32 { var ts: libc.timespec = undefined; _ = libc.clock_gettime(.REALTIME, &ts); const secs: libc.time_t = ts.sec; var tm: Tm = undefined; return if (localtime_r(&secs, &tm) != null) @intCast(tm.gmtoff) else 0; } /// `bytes` as dump pieces (1 MiB at most each). fn writePieces(fd: c_int, bytes: []const u8) bool { var at: usize = 0; while (at < bytes.len) : (at += dump_piece) { const piece = bytes[at..@min(bytes.len, at + dump_piece)]; const head = wire.header(@backingInt(wire.ServerTag.dump), piece.len); if (!writeAll(fd, &head) or !writeAll(fd, piece)) return false; } return true; } // ---- zstd (libzstd, vendored: build.zig) ---- /// A far client's stream from its welcome on (`Peer.farJoin`): its join in /// one frame at level 6 over an 8 MiB window, since an undo snapshot is a /// near copy of its file's text, a file's length before or after it (the /// join's numbers: Phase 6's content cache and zstd notes); what follows in /// a frame at level 3 over 1 MiB. Each envelope (wire.zig `zstd`) is a /// flush of at most `piece` of input, so that a reader unpacks one whole. const zstd = struct { const CCtx = opaque {}; const DCtx = opaque {}; const In = extern struct { src: ?*const anyopaque, size: usize, pos: usize }; const Out = extern struct { dst: ?*anyopaque, size: usize, pos: usize }; const Mem = extern struct { alloc: *const fn (?*anyopaque, usize) callconv(.c) ?*anyopaque, free: *const fn (?*anyopaque, ?*anyopaque) callconv(.c) void, ctx: ?*anyopaque = null, }; extern fn ZSTD_createCCtx_advanced(mem: Mem) ?*CCtx; extern fn ZSTD_freeCCtx(c: ?*CCtx) usize; extern fn ZSTD_CCtx_setParameter(c: *CCtx, param: c_int, value: c_int) usize; extern fn ZSTD_compressStream2(c: *CCtx, out: *Out, in: *In, op: c_int) usize; extern fn ZSTD_createDCtx_advanced(mem: Mem) ?*DCtx; extern fn ZSTD_freeDCtx(d: ?*DCtx) usize; extern fn ZSTD_decompressStream(d: *DCtx, out: *Out, in: *In) usize; extern fn ZSTD_isError(code: usize) c_uint; const level_param = 100; const window_param = 101; const Op = enum(c_int) { more = 0, flush = 1, end = 2 }; const piece = 1 << 20; /// What zstd allocates is a Zig allocator's (c_heap): a test's own. var gpa: Allocator = std.heap.c_allocator; const heap = c_heap.Heap(&gpa); fn alloc(_: ?*anyopaque, n: usize) callconv(.c) ?*anyopaque { return heap.malloc(n); } fn free(_: ?*anyopaque, p: ?*anyopaque) callconv(.c) void { heap.free(p); } const mem: Mem = .{ .alloc = alloc, .free = free }; fn compressor(level: c_int, window_log: c_int) ?*CCtx { const c = ZSTD_createCCtx_advanced(mem) orelse return null; if (ZSTD_isError(ZSTD_CCtx_setParameter(c, level_param, level)) != 0 or ZSTD_isError(ZSTD_CCtx_setParameter(c, window_param, window_log)) != 0) { _ = ZSTD_freeCCtx(c); return null; } return c; } }; fn readSome(fd: c_int, buf: []u8) usize { while (true) { const n = libc.read(fd, buf.ptr, buf.len); if (n < 0 and libc.errno(n) == .INTR) continue; return if (n <= 0) 0 else @intCast(n); } } /// What a stream's reader holds of it, read and not yet taken: a dump's /// reader leaves the units read with its last piece to the stream's. pub const Framer = struct { buf: std.ArrayListUnmanaged(u8) = .empty, len: usize = 0, /// What zstd envelopes (wire.zig `zstd`) unpacked to, its messages not /// taken yet, and the stream's decompressor: a far client's. inner: std.ArrayListUnmanaged(u8) = .empty, z: ?*zstd.DCtx = null, bad: bool = false, pub fn deinit(f: *Framer, gpa: Allocator) void { f.buf.deinit(gpa); f.inner.deinit(gpa); if (f.z) |z| _ = zstd.ZSTD_freeDCtx(z); f.z = null; } /// Framed messages off `fd` (wire.zig) handed to `take` until /// the stream ends, `take` says stop, or a message is malformed. An /// envelope's are handed on as if they had come bare. fn run(fr: *Framer, gpa: Allocator, fd: c_int, ctx: anytype, comptime take: fn (@TypeOf(ctx), u8, []const u8) bool) void { if (fr.bad or !fr.drain(ctx, take)) return; while (true) { var at: usize = 0; var stop = false; while (!stop) { const f = (wire.framed(fr.buf.items[at..fr.len]) catch break) orelse break; at += f.total; if (f.tag == @backingInt(wire.ServerTag.zstd)) { fr.bad = !fr.unpack(gpa, f.payload); stop = fr.bad or !fr.drain(ctx, take); } else stop = !take(ctx, f.tag, f.payload); } if (at > 0) { std.mem.copyForwards(u8, fr.buf.items[0 .. fr.len - at], fr.buf.items[at..fr.len]); fr.len -= at; } if (stop) return; if (wire.framed(fr.buf.items[0..fr.len])) |_| {} else |_| return; // Room for what the head says is coming, or 64 KiB more. const want = if (fr.len >= wire.header_len) wire.header_len + @as(usize, std.mem.readInt(u32, fr.buf.items[1..5], .little)) else 0; const room = @max(want, fr.len + (64 << 10)); if (fr.buf.items.len < room) fr.buf.resize(gpa, room) catch return; const n = readSome(fd, fr.buf.items[fr.len..]); if (n == 0) return; fr.len += n; } } /// An envelope's bytes onto `inner`. Its writer flushed at most /// `zstd.piece` of input into it, so it unpacks to no more than that. fn unpack(fr: *Framer, gpa: Allocator, payload: []const u8) bool { if (fr.z == null) fr.z = zstd.ZSTD_createDCtx_advanced(zstd.mem); const z = fr.z orelse return false; var in: zstd.In = .{ .src = payload.ptr, .size = payload.len, .pos = 0 }; while (true) { fr.inner.ensureUnusedCapacity(gpa, 256 << 10) catch return false; const spare = fr.inner.unusedCapacitySlice(); var out: zstd.Out = .{ .dst = spare.ptr, .size = spare.len, .pos = 0 }; if (zstd.ZSTD_isError(zstd.ZSTD_decompressStream(z, &out, &in)) != 0) return false; fr.inner.items.len += out.pos; if (in.pos == in.size and out.pos < out.size) return true; } } /// The whole messages in `inner` handed to `take`; false when it says /// stop (what is left waits for the next run) or one is malformed. fn drain(fr: *Framer, ctx: anytype, comptime take: fn (@TypeOf(ctx), u8, []const u8) bool) bool { var at: usize = 0; var stop = false; while (!stop) { const f = (wire.framed(fr.inner.items[at..]) catch { fr.bad = true; return false; }) orelse break; at += f.total; stop = !take(ctx, f.tag, f.payload); } if (at > 0) { const rest = fr.inner.items.len - at; std.mem.copyForwards(u8, fr.inner.items[0..rest], fr.inner.items[at..]); fr.inner.items.len = rest; } return !stop; } }; pub const Peer = struct { peers: *Peers, fd: c_int, id: u16, view: u8, /// Its bye said it joins again for its view (a divergence's rejoin): /// kept for it (views.away), not closed. Its reader's, read after its end. again: bool = false, /// Its number in the session's `Screens`. sid: u16 = 0, /// Inputs read (each one's seq, as the client numbered them). seq: u32 = 0, /// The `stamp` frame its next input came with (its reader's). stamp: [stamp_len]u8 = undefined, stamped: bool = false, reader: ?std.Thread = null, writer: ?std.Thread = null, lock: std.Io.Mutex = .init, cond: std.Io.Condition = .init, /// What it is sent, not written yet, and what the writer writes now. out: std.ArrayListUnmanaged(u8) = .empty, sending: std.ArrayListUnmanaged(u8) = .empty, limit: usize = 64 << 20, closing: bool = false, cut: bool = false, /// Its writer has ended (what it was sent, written). done: std.atomic.Value(bool) = .init(false), /// Its join, which its writer writes before what it is sent: the /// welcome, then the dump with the session's blobs put back where they /// go, pinned until written (memory.zig `pin`). The core's allocator's. welcome: [wire.hello_max + 64]u8 = undefined, welcome_len: usize = 0, dump: []u8 = &.{}, blobs: std.ArrayListUnmanaged(walk.Deferred) = .empty, dump_gpa: Allocator = undefined, /// Its first word after its hello: whether it is far (through ssh), its /// blobs asked for by hash and its stream in zstd (`farJoin`). far: ?bool = null, /// A far client's answer to its join's list: the blobs it lacks. want: ?[]u8 = null, /// A far client's stream's compressor, and an envelope's worth of its /// output; the input since the last envelope. z: ?*zstd.CCtx = null, zout: std.ArrayListUnmanaged(u8) = .empty, zin: usize = 0, fn writeJoin(peer: *Peer) bool { if (!writeAll(peer.fd, peer.welcome[0..peer.welcome_len])) return false; const io = peer.peers.io; peer.lock.lockUncancelable(io); while (peer.far == null and !peer.closing and !peer.cut) peer.cond.waitUncancelable(io, &peer.lock); const far = peer.far; peer.lock.unlock(io); if (far orelse return false) return peer.farJoin(); var pos: usize = 0; for (peer.blobs.items) |b| { if (!writePieces(peer.fd, peer.dump[pos..b.at]) or !writePieces(peer.fd, b.bytes)) return false; pos = b.at; } return writePieces(peer.fd, peer.dump[pos..]); } /// A far client's join, in one zstd frame: the list of the dump's blobs /// (each one's place in the state, its length and its BLAKE3 hash), the /// state, then the blobs it says it lacks; what follows the join goes /// in a cheaper frame. The hashing is this thread's, never the step's. /// ponytail: a blob is hashed again at every far join, 3.6 GB/s; a /// session's join after its first would keep them, beside its words. fn farJoin(peer: *Peer) bool { const gpa = peer.peers.gpa; peer.z = zstd.compressor(6, 23) orelse return false; var list: std.ArrayListUnmanaged(u8) = .empty; defer list.deinit(gpa); for (peer.blobs.items) |b| { // Gone meanwhile: its leave waits for this thread in the // session's step, so the hashing stops here. if (peer.letting()) return false; var entry: [blob_entry]u8 = undefined; std.mem.writeInt(u64, entry[0..8], b.at, .little); std.mem.writeInt(u64, entry[8..16], b.bytes.len, .little); std.crypto.hash.Blake3.hash(b.bytes, entry[16..48], .{}); list.appendSlice(gpa, &entry) catch return false; if (list.items.len + blob_entry > dump_piece) { if (!peer.zMessage(.blobs, list.items)) return false; list.clearRetainingCapacity(); } } if (list.items.len > 0 and !peer.zMessage(.blobs, list.items)) return false; if (!peer.zPieces(peer.dump) or !peer.zWrite(&.{}, .flush)) return false; if (peer.blobs.items.len > 0) { const io = peer.peers.io; peer.lock.lockUncancelable(io); while (peer.want == null and !peer.closing and !peer.cut) peer.cond.waitUncancelable(io, &peer.lock); const want = peer.want; peer.lock.unlock(io); const bits = want orelse return false; if (bits.len != (peer.blobs.items.len + 7) / 8) return false; for (peer.blobs.items, 0..) |b, i| if (bits[i / 8] >> @intCast(i % 8) & 1 != 0) { if (!peer.zPieces(b.bytes)) return false; }; } if (!peer.zWrite(&.{}, .end)) return false; _ = zstd.ZSTD_freeCCtx(peer.z); peer.z = zstd.compressor(3, 20); return peer.z != null; } /// Whether it is being let go (or was cut off). fn letting(peer: *Peer) bool { const io = peer.peers.io; peer.lock.lockUncancelable(io); defer peer.lock.unlock(io); return peer.closing or peer.cut; } /// One message into its stream's compressor. fn zMessage(peer: *Peer, tag: wire.ServerTag, payload: []const u8) bool { const head = wire.header(@backingInt(tag), payload.len); return peer.zWrite(&head, .more) and peer.zWrite(payload, .more); } /// `bytes` as dump pieces (1 MiB at most each), into the compressor. fn zPieces(peer: *Peer, bytes: []const u8) bool { var at: usize = 0; while (at < bytes.len) : (at += dump_piece) { if (!peer.zMessage(.dump, bytes[at..@min(bytes.len, at + dump_piece)])) return false; } return true; } /// `bytes` into its stream's compressor, and what comes out written as /// envelopes: one at each `zstd.piece` of input, and one now if `op` /// says flush or end (the frame's). fn zWrite(peer: *Peer, bytes: []const u8, op: zstd.Op) bool { const z = peer.z orelse return false; var rest = bytes; while (true) { const n = @min(rest.len, zstd.piece - peer.zin); const full = peer.zin + n == zstd.piece; const now: zstd.Op = if (n < rest.len or (full and op == .more)) .flush else op; var in: zstd.In = .{ .src = rest.ptr, .size = n, .pos = 0 }; while (true) { peer.zout.ensureUnusedCapacity(peer.peers.gpa, 128 << 10) catch return false; const spare = peer.zout.unusedCapacitySlice(); var out: zstd.Out = .{ .dst = spare.ptr, .size = spare.len, .pos = 0 }; const left = zstd.ZSTD_compressStream2(z, &out, &in, @backingInt(now)); if (zstd.ZSTD_isError(left) != 0) return false; peer.zout.items.len += out.pos; if (if (now == .more) in.pos == in.size else left == 0) break; } peer.zin += n; if (now != .more) { const head = wire.header(@backingInt(wire.ServerTag.zstd), peer.zout.items.len); if (!writeAll(peer.fd, &head) or !writeAll(peer.fd, peer.zout.items)) return false; peer.zout.clearRetainingCapacity(); peer.zin = 0; } rest = rest[n..]; if (rest.len == 0) return true; } } /// `parts` queued for it, in order; never waits. A client whose queue /// passes its limit is cut off: its link is shut down, and its reader /// says it is gone. fn send(peer: *Peer, parts: []const []const u8) void { const io = peer.peers.io; peer.lock.lockUncancelable(io); defer peer.lock.unlock(io); if (peer.cut or peer.closing) return; var n: usize = peer.out.items.len; for (parts) |p| n += p.len; if (n > peer.limit) { log.info("client {d} is {d} MB behind: cut off", .{ peer.id, n >> 20 }); peer.peers.cut += 1; peer.cut = true; _ = libc.shutdown(peer.fd, 2); peer.cond.signal(io); return; } for (parts) |p| peer.out.appendSlice(peer.peers.gpa, p) catch { peer.cut = true; _ = libc.shutdown(peer.fd, 2); break; }; peer.cond.signal(io); } fn writeLoop(peer: *Peer) void { const io = peer.peers.io; defer peer.done.store(true, .release); if (!peer.writeJoin()) { _ = libc.shutdown(peer.fd, 2); return; } // Its pins let go at the next boundary. peer.peers.post(.{ .joined = peer }); while (true) { peer.lock.lockUncancelable(io); while (peer.out.items.len == 0 and !peer.closing and !peer.cut) peer.cond.waitUncancelable(io, &peer.lock); if (peer.out.items.len == 0 or peer.cut) { peer.lock.unlock(io); return; } std.mem.swap(std.ArrayListUnmanaged(u8), &peer.out, &peer.sending); // The limit was for the dump and what is queued behind it. peer.limit = lag_max; peer.lock.unlock(io); const ok = if (peer.z != null) peer.zWrite(peer.sending.items, .flush) else writeAll(peer.fd, peer.sending.items); peer.sending.clearRetainingCapacity(); if (!ok) { _ = libc.shutdown(peer.fd, 2); return; } } } fn take(peer: *Peer, tag: u8, payload: []const u8) bool { const t = std.enums.fromInt(wire.ClientTag, tag) orelse return false; switch (t) { .hello => return false, .bye => { peer.again = (wire.decodeClient(tag, payload) catch return false).bye.again; return false; }, .ping => { var out: [16]u8 = undefined; const v = (wire.decodeClient(tag, payload) catch return false).ping; const pong = wire.encodeServer(&out, .{ .pong = v }) catch return false; peer.send(&.{pong}); return true; }, // Its word about a terminal (an ack, rows asked, a reset), to // the session's Screens at the next boundary. .screen_ack => { const msg = peer.peers.gpa.dupe(u8, payload) catch return false; peer.peers.post(.{ .screen = .{ .peer = peer, .msg = msg } }); return true; }, .check => { peer.peers.post(.{ .check = peer }); return true; }, // What its join's writer waits for (`writeJoin`, `farJoin`). .far, .want => { const io = peer.peers.io; const msg = wire.decodeClient(tag, payload) catch return false; const bits = if (msg == .want) peer.peers.gpa.dupe(u8, msg.want) catch return false else null; peer.lock.lockUncancelable(io); defer peer.lock.unlock(io); if (bits) |b| { if (peer.want != null) { peer.peers.gpa.free(b); return false; } peer.want = b; } else peer.far = msg.far; peer.cond.signal(io); return true; }, // Its next input's time, kept for it (this thread's alone). .stamp => { const s = (wire.decodeClient(tag, payload) catch return false).stamp; _ = wire.encodeClient(&peer.stamp, .{ .stamp = s }) catch return false; peer.stamped = true; return true; }, else => {}, } peer.seq += 1; const stamp: []const u8 = if (peer.stamped) &peer.stamp else &.{}; peer.stamped = false; const msg = peer.peers.gpa.alloc(u8, head_len + stamp.len + wire.header_len + payload.len) catch return false; header(msg, peer.id, peer.seq); @memcpy(msg[head_len..][0..stamp.len], stamp); const at = head_len + stamp.len; msg[at] = tag; std.mem.writeInt(u32, msg[at + 1 ..][0..4], @intCast(payload.len), .little); @memcpy(msg[at + wire.header_len ..], payload); if (parseInput(msg) == null) { peer.peers.gpa.free(msg); return false; } peer.peers.post(.{ .input = .{ .peer = peer, .msg = msg } }); return true; } fn readLoop(peer: *Peer) void { // The framer goes before `gone`, after which the peer may be freed. var fr: Framer = .{}; fr.run(peer.peers.gpa, peer.fd, peer, take); fr.deinit(peer.peers.gpa); peer.peers.post(.{ .gone = peer }); } }; /// The session's clients, for `dying`. var live_peers: ?*Peers = null; /// The process is panicking: each client's link shut first, so that it /// hears the end now, not when the trace is written (seconds, symbolized). pub fn dying() void { const ps = live_peers orelse return; for (ps.list) |slot| if (slot) |peer| { _ = libc.shutdown(peer.fd, 2); }; } pub const Peers = struct { gpa: Allocator = std.heap.c_allocator, io: std.Io = undefined, /// This session's name and pid, for a welcome. name: []const u8 = "", t: tape.Tape = undefined, recording: bool = false, list: [pardes.views.max]?*Peer = @splat(null), next_id: u16 = 1, seq: u32 = 0, lock: std.Io.Mutex = .init, inbox: std.ArrayListUnmanaged(Note) = .empty, taken: std.ArrayListUnmanaged(Note) = .empty, /// A reader posted: the loop's one test a step while nothing is attached. mail: std.atomic.Value(bool) = .init(false), /// Wakes the session's loop (its wait for input) from a reader. wake_ctx: ?*anyopaque = null, wake: ?*const fn (?*anyopaque) void = null, /// What the session would be with no client: unattended without a /// terminal of its own (the host says). alone_unattended: bool = false, /// The worst a join cost the session's step, and the last one's dump. join_ns: u64 = 0, each_join: std.ArrayListUnmanaged(u64) = .empty, dump_bytes: usize = 0, /// ...of it the state the step dumped (the rest, blobs, the writer's). state_bytes: usize = 0, /// What each client input cost the session (its step, its unit sent), /// and each boundary (its pump's unit sent, what came taken in), ns: /// PARDES_REPLICA_STATS writes them at the session's end, and only then /// are these and `each_join` kept (`samples`): a session runs for days. samples: bool = false, input_ns: std.ArrayListUnmanaged(u64) = .empty, boundary_ns: std.ArrayListUnmanaged(u64) = .empty, cut: u32 = 0, head: [unit_head]u8 = undefined, /// Its clients' terminals as screen state (src/screen_state.zig), while /// it records: what each was sent. screens: Screens = undefined, msgs: std.ArrayListUnmanaged([]u8) = .empty, /// Clients waiting to join while the session's texts are hashed /// (`joins`), the texts and the thread hashing them. held: std.ArrayListUnmanaged(Joining) = .empty, texts: std.ArrayListUnmanaged([]const u8) = .empty, hasher: ?std.Thread = null, rounds: u8 = 0, pub const Note = union(enum) { join: Joining, input: Msg, screen: Msg, gone: *Peer, check: *Peer, joined: *Peer, hashed }; /// A connection to join, and the view it joins again for, if it does. pub const Joining = daemon.Joining; pub const Msg = struct { peer: *Peer, msg: []u8 }; pub fn count(ps: *const Peers) usize { var n: usize = 0; for (ps.list) |slot| n += @intFromBool(slot != null); return n; } fn post(ps: *Peers, note: Note) void { ps.lock.lockUncancelable(ps.io); ps.inbox.append(ps.gpa, note) catch { ps.lock.unlock(ps.io); switch (note) { .join => |j| _ = libc.close(j.fd), .input, .screen => |in| ps.gpa.free(in.msg), .gone, .check, .joined, .hashed => {}, } return; }; ps.mail.store(true, .release); ps.lock.unlock(ps.io); if (ps.wake) |w| w(ps.wake_ctx); } /// A replica's connection the daemon handed over (its hello taken /// there), and the view its hello says it had: joined at the next step /// boundary. Any thread. pub fn handed(ps: *Peers, fd: c_int, view: ?u8) void { ps.post(.{ .join = .{ .fd = fd, .view = view } }); } /// What was recorded since the last unit, to every client as one, its /// digest at its end. fn unit(ps: *Peers, origin: u16, seq: u32) void { if (ps.t.buf.items.len == 0) return; tape.recordDigest(&ps.t); const bytes = ps.t.buf.items; unitHeader(&ps.head, origin, seq); trace(ps.gpa, "session: unit {d}/{d}, {d} bytes, to {d} clients:\n", .{ origin, seq, bytes.len, ps.count() }, &.{bytes}); const head = wire.header(@backingInt(wire.ServerTag.unit), unit_head + bytes.len); for (ps.list) |slot| if (slot) |peer| peer.send(&.{ &head, &ps.head, bytes }); ps.t.buf.clearRetainingCapacity(); // The sizes its steps gave terminals, now: the next flush says so. if (ps.t.core) |core| terminal.resizeDeferred(core); } /// After each of the session's pumps: its unit sent, the clients that /// came joined, their inputs taken in, the ones gone let go. pub fn boundary(ps: *Peers, core: *Pardes) void { if (!ps.recording and !ps.mail.load(.acquire)) return; const t0 = nowNs(); defer if (ps.recording and ps.samples) ps.boundary_ns.append(ps.gpa, nowNs() - t0) catch {}; if (ps.recording) { // The rows the pump's steps read, then its unit, then what the // terminals came to (the next steps read that). ps.screensOut(core, .fill); ps.seq += 1; ps.unit(0, ps.seq); ps.screensOut(core, .flush); } if (!ps.mail.load(.acquire)) return; ps.lock.lockUncancelable(ps.io); std.mem.swap(std.ArrayListUnmanaged(Note), &ps.inbox, &ps.taken); ps.mail.store(false, .release); ps.lock.unlock(ps.io); for (ps.taken.items) |note| switch (note) { .join => |j| { ps.held.append(ps.gpa, j) catch { daemon.refuseReplica(j.fd, "out of memory"); continue; }; ps.joins(core); }, .hashed => { ps.unhashedDone(); ps.joins(core); }, .input => |in| { ps.input(core, in.peer, in.msg); ps.gpa.free(in.msg); }, .screen => |in| { defer ps.gpa.free(in.msg); const reply = (ps.screens.take(core, in.peer.sid, in.msg) catch null) orelse continue; defer ps.gpa.free(reply); const head = wire.header(@backingInt(wire.ServerTag.screen), reply.len); in.peer.send(&.{ &head, reply }); }, .gone => |peer| ps.leave(core, peer), .joined => |peer| released(peer), .check => |peer| { var out: [16]u8 = undefined; peer.send(&.{wire.encodeServer(&out, .{ .check = tape.digestOf(core) }) catch unreachable}); }, }; ps.taken.clearRetainingCapacity(); } fn input(ps: *Peers, core: *Pardes, peer: *Peer, msg: []const u8) void { const in = parseInput(msg) orelse return; const t0 = nowNs(); defer if (ps.samples) ps.input_ns.append(ps.gpa, nowNs() - t0) catch {}; // The terminals as this step reads them, then the step, the rows // it read, its unit (part B terminal notes' order). ps.screensOut(core, .flush); core.toView(peer.view); ps.t.stamp = stampOf(in); core.update(in.event); core.step(); ps.t.stamp = null; ps.screensOut(core, .fill); ps.unit(peer.id, in.seq); } const ScreensOut = enum { flush, fill }; /// What each client is owed of the terminals (`Screens.flush`), or the /// rows a step read that it lacks (`Screens.fill`, then `filled`), each /// a screen message queued for it. fn screensOut(ps: *Peers, core: *Pardes, comptime what: ScreensOut) void { for (ps.list) |slot| if (slot) |peer| ps.screensTo(core, peer, what); if (what == .fill) ps.screens.filled(core); } fn screensTo(ps: *Peers, core: *Pardes, peer: *Peer, comptime what: ScreensOut) void { defer { for (ps.msgs.items) |m| ps.gpa.free(m); ps.msgs.clearRetainingCapacity(); } (switch (what) { .flush => ps.screens.flush(core, peer.sid, &ps.msgs), .fill => ps.screens.fill(core, peer.sid, &ps.msgs), }) catch return; for (ps.msgs.items) |m| { const head = wire.header(@backingInt(wire.ServerTag.screen), m.len); peer.send(&.{ &head, m }); } } /// The clients waiting to join, joined, once the texts the session /// never digested have their words (`walk.unhashed`): those are hashed /// on a thread of their own, pinned meanwhile, and the joins wait a /// boundary or two for them, the session's step never. A second round /// joins whatever is left. fn joins(ps: *Peers, core: *Pardes) void { if (ps.hasher != null or ps.held.items.len == 0) return; if (ps.rounds < 2) { walk.unhashed(Pardes, core, &ps.texts); if (ps.texts.items.len > 0) { for (ps.texts.items) |b| pardes.memory.pin(b); if (std.Thread.spawn(.{}, hashTexts, .{ps})) |t| { ps.hasher = t; ps.rounds += 1; return; } else |_| ps.unhashedDone(); } } ps.rounds = 0; for (ps.held.items) |j| ps.join(core, j); ps.held.clearRetainingCapacity(); } fn hashTexts(ps: *Peers) void { walk.makeWords(ps.texts.items); ps.post(.hashed); } /// The hashing thread joined, its texts unpinned. fn unhashedDone(ps: *Peers) void { if (ps.hasher) |t| t.join(); ps.hasher = null; for (ps.texts.items) |b| pardes.memory.unpin(b); ps.texts.clearRetainingCapacity(); } fn join(ps: *Peers, core: *Pardes, joining: Joining) void { const fd = joining.fd; const t0 = nowNs(); defer { ps.join_ns = @max(ps.join_ns, nowNs() - t0); if (ps.samples) ps.each_join.append(ps.gpa, nowNs() - t0) catch {}; } const slot = for (&ps.list) |*s| { if (s.* == null) break s; } else return daemon.refuseReplica(fd, "that session has as many clients as it takes"); live_peers = ps; if (!ps.recording) { // A session recording to a file (PARDES_RECORD) has its tape. if (tape.on != null) return daemon.refuseReplica(fd, "that session records a tape of its own (PARDES_RECORD)"); ps.t = tape.memory(ps.gpa); ps.t.unit_digests = true; // Terminals cross as screen state: a unit carries no pty bytes, // and its digest is a word (PARDES_REPLICA_TRACE: one a field). ps.t.screen_state = true; ps.t.whole_digest = std.c.getenv("PARDES_REPLICA_TRACE") == null; ps.screens = .init(ps.gpa); tape.on = &ps.t; ps.recording = true; ps.samples = std.c.getenv("PARDES_REPLICA_STATS") != null; } // Someone looks at it now: its messages go by keys, not the clock. core.unattended = false; // Its own view again, kept for it since it left (views.away), or one // new. ponytail: a divergence's redial that came before its old // link's end (posted by that link's reader, microseconds after the // bye; the redial is a dial and the daemon's hand-over later) finds // its view not kept yet, and takes a new one. const back = if (joining.view) |v| core.rejoinView(v) else false; const k = (if (back) joining.view else core.openView()) orelse { core.unattended = ps.count() == 0 and ps.alone_unattended; if (ps.count() == 0) ps.stop(core); return daemon.refuseReplica(fd, "that session has as many views as it takes"); }; // Its own process draws it. core.undrawn |= @as(u8, 1) << @intCast(k); ps.seq += 1; ps.unit(0, ps.seq); // The session's mutable state, dumped now; its blobs (file texts, // undo, registers) left out, pinned, and streamed by the client's // writer thread: the step pays for the state, not for the text. var blobs: std.ArrayListUnmanaged(walk.Deferred) = .empty; const bytes = pardes.dump.dumpJoin(core, &blobs) catch |err| { blobs.deinit(core.gpa); core.undrawn &= ~(@as(u8, 1) << @intCast(k)); core.closeView(k); ps.unit(0, ps.seq); if (ps.count() == 0) ps.stop(core); var why: [96]u8 = undefined; return daemon.refuseReplica(fd, std.fmt.bufPrint(&why, "that session could not be dumped: {t}", .{err}) catch "that session could not be dumped"); }; var whole = bytes.len; for (blobs.items) |b| { pardes.memory.pin(b.bytes); whole += b.bytes.len; } ps.dump_bytes = whole; ps.state_bytes = bytes.len; // The joiner's core is the dump's: the host this tape wraps, and // what the host wrote in the core, are said again at the next input. tape.resync(&ps.t); const peer = ps.gpa.create(Peer) catch { for (blobs.items) |b| pardes.memory.unpin(b.bytes); blobs.deinit(core.gpa); core.gpa.free(bytes); return daemon.refuseReplica(fd, "out of memory"); }; peer.* = .{ .peers = ps, .fd = fd, .id = ps.next_id, .view = k, .limit = lag_max, .dump = bytes, .blobs = blobs, .dump_gpa = core.gpa }; ps.next_id +%= 1; if (ps.next_id == 0) ps.next_id = 1; // The session's digest as dumped, for the joiner to check its load by. const digest = tape.digestOf(core); peer.welcome_len = (wire.encodeServer(&peer.welcome, .{ .welcome = .{ .pid = @intCast(libc.getpid()), .session = ps.name[0..@min(ps.name.len, wire.max_name)], .client = peer.id, .view = k, .dump_len = whole, .gmtoff = gmtoff(), .digest = digest, .semantics = wire.semantics, .blobs = @intCast(blobs.items.len) } }) catch unreachable).len; peer.writer = std.Thread.spawn(.{}, Peer.writeLoop, .{peer}) catch null; peer.reader = std.Thread.spawn(.{}, Peer.readLoop, .{peer}) catch null; if (peer.writer == null or peer.reader == null) { ps.letGo(peer); core.undrawn &= ~(@as(u8, 1) << @intCast(k)); core.closeView(k); ps.unit(0, ps.seq); return; } slot.* = peer; // Its terminals afresh, after its dump and before any unit. if (ps.screens.addPeer()) |sid| { peer.sid = sid; ps.screensTo(core, peer, .flush); } else |_| _ = libc.shutdown(fd, 2); log.info("client {d} joined '{s}' as view {d}: a {d} KB dump ({d} KB of state) in {d} us", .{ peer.id, ps.name, k, whole >> 10, bytes.len >> 10, (nowNs() - t0) / 1000 }); if (std.c.getenv("PARDES_REPLICA_TRACE") != null) std.debug.print("session: client {d} joined after unit {d}\n", .{ peer.id, ps.seq }); } fn leave(ps: *Peers, core: *Pardes, peer: *Peer) void { for (&ps.list) |*slot| if (slot.* == peer) { slot.* = null; }; log.info("client {d} left '{s}'", .{ peer.id, ps.name }); ps.screens.dropPeer(peer.sid); core.undrawn &= ~(@as(u8, 1) << @intCast(peer.view)); ps.closeViewOf(core, peer, peer.again); if (ps.count() == 0) core.unattended = ps.alone_unattended; ps.seq += 1; ps.unit(0, ps.seq); ps.letGo(peer); if (ps.count() == 0) ps.stop(core); } /// A gone client's view closed (its slot let go already), or kept for /// it (`again`: it joins again for it, views.away): the last one of a /// session no one else watches leaves the session its layout, for a /// client that comes after to find. fn closeViewOf(ps: *Peers, core: *Pardes, peer: *Peer, again: bool) void { if (again) core.awayView(peer.view) else if (ps.count() == 0 and ps.alone_unattended) core.leaveView(peer.view) else core.closeView(peer.view); } /// Its threads ended and joined, its link closed. fn letGo(ps: *Peers, peer: *Peer) void { const io = ps.io; peer.lock.lockUncancelable(io); peer.closing = true; peer.cond.signal(io); peer.lock.unlock(io); _ = libc.shutdown(peer.fd, 2); if (peer.writer) |w| w.join(); if (peer.reader) |r| r.join(); released(peer); _ = libc.close(peer.fd); peer.out.deinit(ps.gpa); peer.sending.deinit(ps.gpa); if (peer.want) |b| ps.gpa.free(b); if (peer.z) |z| _ = zstd.ZSTD_freeCCtx(z); peer.zout.deinit(ps.gpa); // What its reader posted after it was let go (its end) is nobody's. ps.lock.lockUncancelable(io); var i: usize = 0; while (i < ps.inbox.items.len) { const mine = switch (ps.inbox.items[i]) { .input, .screen => |in| in.peer == peer, .gone, .check, .joined => |p| p == peer, .join, .hashed => false, }; if (!mine) { i += 1; continue; } switch (ps.inbox.items[i]) { .input, .screen => |in| ps.gpa.free(in.msg), else => {}, } _ = ps.inbox.orderedRemove(i); } ps.lock.unlock(io); ps.gpa.destroy(peer); } /// Every client told `why` and let go, its view with it: an Upgrade's /// exec is next (tui.zig `upgradeNow`). What each was sent goes first, /// for up to 200 ms; a client then dials the session again. pub fn refuseAll(ps: *Peers, core: *Pardes, why: []const u8) void { if (ps.count() == 0) return; var out: [600]u8 = undefined; const words = wire.encodeServer(&out, .{ .refused = why }) catch return; const io = ps.io; for (ps.list) |slot| if (slot) |peer| { peer.send(&.{words}); peer.lock.lockUncancelable(io); peer.closing = true; peer.cond.signal(io); peer.lock.unlock(io); }; const until = nowNs() + 200 * std.time.ns_per_ms; while (nowNs() < until) { const busy = for (ps.list) |slot| { if (slot) |peer| if (!peer.done.load(.acquire)) break true; } else false; if (!busy) break; const ts: libc.timespec = .{ .sec = 0, .nsec = 2 * std.time.ns_per_ms }; _ = libc.nanosleep(&ts, null); } // Each joins again for its view, kept in the dump (views.away). ps.drop(core, true); } /// A join's dump and pins let go: written, or its client gone. fn released(peer: *Peer) void { for (peer.blobs.items) |b| pardes.memory.unpin(b.bytes); peer.blobs.deinit(peer.dump_gpa); peer.blobs = .empty; if (peer.dump.len > 0) peer.dump_gpa.free(peer.dump); peer.dump = &.{}; } /// Detach typed in client view `k`'s: its link ends (its reader says /// it is gone, and the next boundary lets it go). pub fn detach(ps: *Peers, k: u8) bool { for (ps.list) |slot| if (slot) |peer| if (peer.view == k) { _ = libc.shutdown(peer.fd, 2); return true; }; return false; } fn stop(ps: *Peers, core: *Pardes) void { if (!ps.recording) return; terminal.resizeDeferred(core); ps.screens.deinit(core); if (core.host.vtable == &ps.t.vtable) core.host = ps.t.real; tape.on = null; tape.release(&ps.t); ps.recording = false; } /// Every client let go (the session's end, a Restore): each sees its /// link end. pub fn dropAll(ps: *Peers, core: *Pardes) void { ps.drop(core, false); } /// ...each view kept for its client if `again` (an Upgrade's). fn drop(ps: *Peers, core: *Pardes, again: bool) void { ps.unhashedDone(); for (ps.held.items) |j| _ = libc.close(j.fd); ps.held.clearRetainingCapacity(); ps.rounds = 0; for (&ps.list) |*slot| if (slot.*) |peer| { slot.* = null; core.undrawn &= ~(@as(u8, 1) << @intCast(peer.view)); ps.closeViewOf(core, peer, again); ps.screens.dropPeer(peer.sid); ps.letGo(peer); }; ps.stop(core); ps.lock.lockUncancelable(ps.io); for (ps.inbox.items) |note| switch (note) { .join => |j| _ = libc.close(j.fd), .input, .screen => |in| ps.gpa.free(in.msg), .gone, .check, .joined, .hashed => {}, }; ps.inbox.clearRetainingCapacity(); ps.lock.unlock(ps.io); core.unattended = ps.alone_unattended; } pub fn deinit(ps: *Peers) void { if (std.c.getenv("PARDES_REPLICA_STATS")) |path| if (ps.input_ns.items.len > 0) ps.writeStats(std.mem.span(path)); ps.inbox.deinit(ps.gpa); ps.taken.deinit(ps.gpa); ps.input_ns.deinit(ps.gpa); ps.boundary_ns.deinit(ps.gpa); ps.msgs.deinit(ps.gpa); ps.held.deinit(ps.gpa); ps.texts.deinit(std.heap.c_allocator); ps.each_join.deinit(ps.gpa); } fn writeStats(ps: *Peers, path: []const u8) void { var buf: [400]u8 = undefined; const line = std.fmt.bufPrint(&buf, "session inputs {d} input_us {d}/{d}/{d} boundaries {d} boundary_us {d}/{d}/{d} join_us {d} dump_kb {d} state_kb {d} cut {d}\n", .{ ps.input_ns.items.len, pctOf(ps.input_ns.items, 50) / 1000, pctOf(ps.input_ns.items, 99) / 1000, pctOf(ps.input_ns.items, 100) / 1000, ps.boundary_ns.items.len, pctOf(ps.boundary_ns.items, 50) / 1000, pctOf(ps.boundary_ns.items, 99) / 1000, pctOf(ps.boundary_ns.items, 100) / 1000, ps.join_ns / 1000, ps.dump_bytes >> 10, ps.state_bytes >> 10, ps.cut, }) catch return; var z: [4096]u8 = undefined; const pz = std.fmt.bufPrintSentinel(&z, "{s}", .{path}, 0) catch return; const fd = libc.open(pz, .{ .ACCMODE = .WRONLY, .CREAT = true, .APPEND = true, .CLOEXEC = true }, @as(libc.mode_t, 0o644)); if (fd < 0) return; _ = libc.write(fd, line.ptr, line.len); var each: [400]u8 = undefined; var w: std.Io.Writer = .fixed(&each); w.writeAll("session joins_us") catch {}; for (ps.each_join.items) |ns| w.print(" {d}", .{ns / 1000}) catch {}; w.writeAll("\n") catch {}; _ = libc.write(fd, w.buffered().ptr, w.buffered().len); _ = libc.close(fd); } }; // ---- the client's half ---- pub const Joined = struct { fd: c_int, pid: u32, client: u16, view: u8, gmtoff: i32, dump: []u8, /// The session's digest as dumped (`Replica.loaded`). digest: u64 = 0, /// Its build's (wire.semantics): the daemon judged the hello by what it /// last heard, which an upgrade under way may not have said yet. semantics: u64 = 0, /// What was read past the dump: the stream's (`readLink`). rest: Framer = .{}, /// A far join's blobs that came over the link, for `Have.store` (the C /// heap's), and how it went: its blobs, those it held already (from the /// core it left, from disk) and the bytes of the ones it was sent. got: []Got = &.{}, blobs: u32 = 0, from_memory: u32 = 0, from_disk: u32 = 0, sent_bytes: u64 = 0, /// How long its dial and load took, ms (`join`). ms: u64 = 0, }; /// A blob a far join was sent: where it is in the dump, and its hash. pub const Got = struct { pos: usize, len: usize, hash: [32]u8 }; /// Connected to the replica socket at `path`, its hello said for /// `session`, welcomed, and the dump read whole: what a client joins with. /// A far client (`have`) is sent its dump's blobs by hash first, and asks /// for those it holds nowhere. Errors are said in `why`. `view`: the one /// it had, joining again for it. pub fn dial(gpa: Allocator, path: []const u8, session: []const u8, why: []u8, have: ?*Have, view: ?u8) ?Joined { const fd = libc.socket(libc.AF.UNIX, libc.SOCK.STREAM | libc.SOCK.CLOEXEC, 0); if (fd < 0) return said(why, "no socket", .{}); var addr: libc.sockaddr.un = .{ .path = @splat(0) }; if (path.len >= addr.path.len) { _ = libc.close(fd); return said(why, "the socket's path is too long: {s}", .{path}); } @memcpy(addr.path[0..path.len], path); if (libc.connect(fd, @ptrCast(&addr), @sizeOf(libc.sockaddr.un)) != 0) { _ = libc.close(fd); return said(why, "nothing answers at {s}", .{path}); } return joinOn(gpa, fd, session, why, have, view); } /// `dial`'s, on a connection made: the hello, then the join. The /// connection is closed if the join fails. fn joinOn(gpa: Allocator, fd: c_int, session: []const u8, why: []u8, have: ?*Have, view: ?u8) ?Joined { var out: [wire.hello_max + 16]u8 = undefined; const hello = wire.encodeClient(&out, .{ .hello = .{ .session = session, .view = view } }) catch { _ = libc.close(fd); return said(why, "that session's name is too long", .{}); }; // Its first word, in the same write: whether it is far. const far = wire.encodeClient(out[hello.len..], .{ .far = have != null }) catch unreachable; var j: Joined = .{ .fd = fd, .pid = 0, .client = 0, .view = 0, .gmtoff = 0, .dump = &.{} }; const Read = struct { j: *Joined, gpa: Allocator, why: []u8, have: ?*Have, failed: ?[]const u8 = null, welcomed: bool = false, done: bool = false, /// The join's list of blobs (`blob_entry` each), as it comes. list: std.ArrayListUnmanaged(u8) = .empty, /// Where what comes fills the dump, in order (each a place and a /// length): the state's runs between the blobs, then each blob /// asked for. A blob listed twice is copied once the dump is whole. runs: std.ArrayListUnmanaged([2]usize) = .empty, run: usize = 0, run_at: usize = 0, dups: std.ArrayListUnmanaged([3]usize) = .empty, fn deinit(r: *@This()) void { r.list.deinit(r.gpa); r.runs.deinit(r.gpa); r.dups.deinit(r.gpa); } fn fail(r: *@This(), words: []const u8) bool { r.failed = words; return false; } fn take(r: *@This(), tag: u8, payload: []const u8) bool { const msg = wire.decodeServer(tag, payload) catch return r.fail("the session's answer was not understood"); switch (msg) { .welcome => |w| { r.j.pid = w.pid; r.j.client = w.client; r.j.view = w.view; r.j.gmtoff = w.gmtoff; r.j.digest = w.digest; r.j.semantics = w.semantics; r.j.dump = r.gpa.alloc(u8, @intCast(w.dump_len)) catch return r.fail("out of memory for the session's dump"); r.welcomed = true; r.j.blobs = if (r.have != null) w.blobs else 0; // A near client's dump comes whole, and a far one's // without blobs is its state. if (r.j.blobs == 0) r.runs.append(r.gpa, .{ 0, r.j.dump.len }) catch return r.fail("out of memory for the session's dump"); r.done = w.dump_len == 0; return !r.done; }, .refused => |words| { r.failed = std.fmt.bufPrint(r.why, "{s}\x00", .{words}) catch "refused"; return false; }, .blobs => |entries| { const whole = @as(usize, r.j.blobs) * blob_entry; if (r.runs.items.len > 0 or r.list.items.len + entries.len > whole) return r.fail("the session sent more of its blobs' list than it said"); r.list.appendSlice(r.gpa, entries) catch return r.fail("out of memory for the session's blobs' list"); if (r.list.items.len == whole) return r.lacking(); return true; }, .dump => |piece| { if (r.runs.items.len == 0) return r.fail("the session sent its dump before its blobs' list"); var p = piece; while (p.len > 0) { if (r.run == r.runs.items.len) return r.fail("the session sent more dump than it said"); const run = r.runs.items[r.run]; const n = @min(p.len, run[1] - r.run_at); @memcpy(r.j.dump[run[0] + r.run_at ..][0..n], p[0..n]); r.run_at += n; p = p[n..]; if (r.run_at == run[1]) { r.run += 1; r.run_at = 0; } } if (r.run < r.runs.items.len) return true; for (r.dups.items) |d| @memcpy(r.j.dump[d[0]..][0..d[2]], r.j.dump[d[1]..][0..d[2]]); r.done = true; return false; }, else => return r.fail("the session sent a unit before its dump"), } } /// The list whole: each blob put in place from what the client /// holds (`Have.find`), or asked for, and the runs to fill made. fn lacking(r: *@This()) bool { const h = r.have.?; const dump = r.j.dump; const n: usize = r.j.blobs; const bits = r.gpa.alloc(u8, (n + 7) / 8) catch return r.fail("out of memory for the session's blobs' list"); defer r.gpa.free(bits); @memset(bits, 0); var got: std.ArrayListUnmanaged(Got) = .empty; defer got.deinit(std.heap.c_allocator); var firsts: std.AutoHashMapUnmanaged([32]u8, [2]usize) = .empty; defer firsts.deinit(r.gpa); var shift: usize = 0; var end: usize = 0; for (0..n) |i| { const e = r.list.items[i * blob_entry ..][0..blob_entry]; const len = std.math.cast(usize, std.mem.readInt(u64, e[8..16], .little)) orelse return r.fail("the session's list of blobs is malformed"); const pos = std.math.add(usize, std.math.cast(usize, std.mem.readInt(u64, e[0..8], .little)) orelse maxInt, shift) catch maxInt; if (pos < end or pos > dump.len or len > dump.len - pos) return r.fail("the session's list of blobs is malformed"); shift += len; if (pos > end) r.runs.append(r.gpa, .{ end, pos - end }) catch return r.fail("out of memory for the session's blobs' list"); end = pos + len; const hash = e[16..48]; const first = firsts.getOrPut(r.gpa, hash.*) catch return r.fail("out of memory for the session's blobs' list"); if (first.found_existing and first.value_ptr[1] == len) { r.dups.append(r.gpa, .{ pos, first.value_ptr[0], len }) catch return r.fail("out of memory for the session's blobs' list"); continue; } first.value_ptr.* = .{ pos, len }; if (h.find(hash, dump[pos..][0..len])) |where| switch (where) { .memory => r.j.from_memory += 1, .disk => r.j.from_disk += 1, } else { bits[i / 8] |= @as(u8, 1) << @intCast(i % 8); got.append(std.heap.c_allocator, .{ .pos = pos, .len = len, .hash = hash.* }) catch return r.fail("out of memory for the session's blobs' list"); r.j.sent_bytes += len; } } if (dump.len > end) r.runs.append(r.gpa, .{ end, dump.len - end }) catch return r.fail("out of memory for the session's blobs' list"); for (got.items) |g| r.runs.append(r.gpa, .{ g.pos, g.len }) catch return r.fail("out of memory for the session's blobs' list"); const head = wire.header(@backingInt(wire.ClientTag.want), bits.len); if (!writeAll(r.j.fd, &head) or !writeAll(r.j.fd, bits)) return r.fail("the session hung up"); r.j.got = got.toOwnedSlice(std.heap.c_allocator) catch return r.fail("out of memory for the session's blobs' list"); return true; } const maxInt = std.math.maxInt(usize); }; if (!writeAll(fd, out[0 .. hello.len + far.len])) { _ = libc.close(fd); return said(why, "the session hung up", .{}); } var r: Read = .{ .j = &j, .gpa = gpa, .why = why, .have = have }; defer r.deinit(); j.rest.run(gpa, fd, &r, Read.take); if (r.failed != null or !r.done) { j.rest.deinit(gpa); if (j.dump.len > 0) gpa.free(j.dump); std.heap.c_allocator.free(j.got); _ = libc.close(fd); const text = r.failed orelse "the session hung up before the dump was whole"; if (text.ptr == why.ptr) return null; return said(why, "{s}", .{text}); } return j; } // ---- a far client's blobs ---- /// What a far client holds of a join's blobs already, by content (`dial`): /// the cache on disk, and on a rejoin the blobs of the core it leaves. pub const Have = struct { io: std.Io, cache: ?Cache = null, /// The core it leaves (`leaving`), each blob hashed once when one of its /// length is looked for. ponytail: a scan a lookup, fine to some /// thousands of blobs; a map by length would take over past that. old: std.ArrayListUnmanaged([]const u8) = .empty, old_hash: std.ArrayListUnmanaged(?[32]u8) = .empty, /// The thread writing the last join's blobs to disk (`store`). storing: ?std.Thread = null, pub fn init(io: std.Io) Have { return .{ .io = io, .cache = Cache.open(io) }; } pub fn deinit(h: *Have) void { h.wait(); h.left(); h.old.deinit(std.heap.c_allocator); h.old_hash.deinit(std.heap.c_allocator); if (h.cache) |c| c.dir.close(h.io); } fn wait(h: *Have) void { if (h.storing) |t| t.join(); h.storing = null; } /// `core`'s blobs, looked at by the next join until `left`: a rejoin /// takes what it held, by content, before the core goes. pub fn leaving(h: *Have, core: *const Pardes) void { h.left(); walk.blobs(Pardes, core, &h.old); h.old_hash.appendNTimes(std.heap.c_allocator, null, h.old.items.len) catch h.old.clearRetainingCapacity(); } pub fn left(h: *Have) void { h.old.clearRetainingCapacity(); h.old_hash.clearRetainingCapacity(); } pub const Where = enum { memory, disk }; /// The blob of `hash` put in `out` (its length), from the core it /// leaves or the cache; null when it holds it nowhere. fn find(h: *Have, hash: *const [32]u8, out: []u8) ?Where { for (h.old.items, h.old_hash.items) |b, *word| { if (b.len != out.len) continue; if (word.* == null) { var d: [32]u8 = undefined; std.crypto.hash.Blake3.hash(b, &d, .{}); word.* = d; } if (!std.mem.eql(u8, &word.*.?, hash)) continue; @memcpy(out, b); return .memory; } if (h.cache) |c| if (c.get(h.io, hash, out)) return .disk; return null; } /// The blobs a join was sent, written to the cache on a thread of their /// own, which frees the dump (`gpa`'s) and the list after: the first /// frame waits for none of it. pub fn store(h: *Have, gpa: Allocator, j: *Joined) void { const dump = j.dump; const got = j.got; j.dump = &.{}; j.got = &.{}; h.wait(); const Store = struct { fn run(c: Cache, io: std.Io, a: Allocator, bytes: []u8, list: []Got) void { defer { a.free(bytes); std.heap.c_allocator.free(list); } var incoming: u64 = 0; for (list) |g| incoming += g.len; c.trim(io, @min(incoming, c.cap)); var put: u64 = 0; for (list) |g| { if (put + g.len > c.cap) continue; put += g.len; c.put(io, &g.hash, bytes[g.pos..][0..g.len]); } } }; const c = h.cache orelse { gpa.free(dump); std.heap.c_allocator.free(got); return; }; h.storing = std.Thread.spawn(.{}, Store.run, .{ c, h.io, gpa, dump, got }) catch { Store.run(c, h.io, gpa, dump, got); return; }; } /// `core`'s blobs the cache lacks, written there: what this client made /// since it joined (an edit's text, its undo), for its next start. pub fn keep(h: *Have, core: *const Pardes) void { h.wait(); const c = h.cache orelse return; var all: std.ArrayListUnmanaged([]const u8) = .empty; defer all.deinit(std.heap.c_allocator); walk.blobs(Pardes, core, &all); var missing: std.ArrayListUnmanaged(struct { bytes: []const u8, hash: [32]u8 }) = .empty; defer missing.deinit(std.heap.c_allocator); var incoming: u64 = 0; for (all.items) |b| { var d: [32]u8 = undefined; std.crypto.hash.Blake3.hash(b, &d, .{}); if (c.has(h.io, &d, b.len)) continue; missing.append(std.heap.c_allocator, .{ .bytes = b, .hash = d }) catch return; incoming += b.len; } if (missing.items.len == 0) return; c.trim(h.io, @min(incoming, c.cap)); var put: u64 = 0; for (missing.items) |m| { if (put + m.bytes.len > c.cap) continue; put += m.bytes.len; c.put(h.io, &m.hash, m.bytes); } } }; /// A far client's blobs on disk, a file each named by its BLAKE3 hash in /// hex, in $XDG_CACHE_HOME/pardes/blobs (else ~/.cache/pardes/blobs): what /// a client started again, or a second one on this machine, is not sent /// again. The cache directory and not the runtime one: the blobs are worth /// keeping across a logout or a reboot and safe to lose, and they can be /// hundreds of megabytes, which the runtime directory (a tmpfs, often /// capped at a tenth of memory and emptied at logout) is not for. A file /// read back is hashed again: one cut short, corrupted or planted is a /// miss and goes, never wrong content. pub const Cache = struct { dir: std.Io.Dir, /// Bytes it keeps at most: PARDES_BLOB_CACHE_MB, else 1 GiB. cap: u64, pub fn open(io: std.Io) ?Cache { var buf: [4096]u8 = undefined; const base = if (std.c.getenv("XDG_CACHE_HOME")) |x| std.mem.span(x) else ""; const path = if (base.len > 0 and base[0] == '/') std.fmt.bufPrint(&buf, "{s}/pardes/blobs", .{base}) catch return null else if (std.c.getenv("HOME")) |home| std.fmt.bufPrint(&buf, "{s}/.cache/pardes/blobs", .{std.mem.span(home)}) catch return null else return null; const cwd = std.Io.Dir.cwd(); cwd.createDirPath(io, std.fs.path.dirname(path).?) catch return null; cwd.createDir(io, path, .fromMode(0o700)) catch |err| if (err != error.PathAlreadyExists) return null; const mb = if (std.c.getenv("PARDES_BLOB_CACHE_MB")) |v| std.fmt.parseInt(u64, std.mem.span(v), 10) catch 1024 else 1024; return .{ .dir = cwd.openDir(io, path, .{ .iterate = true }) catch return null, .cap = mb << 20 }; } fn name(hash: *const [32]u8) [64]u8 { return std.fmt.bytesToHex(hash.*, .lower); } /// The blob of `hash` read into `out` (its length) and hashed again. /// A file of another length or content is a miss, and goes; a hit's /// time is made now, so the least recently used go first (`trim`). pub fn get(c: Cache, io: std.Io, hash: *const [32]u8, out: []u8) bool { const file = name(hash); var f = c.dir.openFile(io, &file, .{}) catch return false; const ok = ok: { defer f.close(io); const st = f.stat(io) catch break :ok false; if (st.size != out.len) break :ok false; var reader = f.reader(io, &.{}); const n = reader.interface.readSliceShort(out) catch break :ok false; if (n != out.len) break :ok false; var d: [32]u8 = undefined; std.crypto.hash.Blake3.hash(out, &d, .{}); break :ok std.mem.eql(u8, &d, hash); }; if (!ok) { c.dir.deleteFile(io, &file) catch {}; return false; } c.dir.setTimestampsNow(io, &file, .{}) catch {}; return true; } /// Whether a file of `len` bytes is there under `hash` (not read). pub fn has(c: Cache, io: std.Io, hash: *const [32]u8, len: usize) bool { const file = name(hash); const st = c.dir.statFile(io, &file, .{}) catch return false; return st.size == len; } var tmp_serial: std.atomic.Value(u32) = .init(0); /// `bytes` kept under `hash`: written aside and renamed into place, so /// that a reader never meets half a file (and would hash it wrong). pub fn put(c: Cache, io: std.Io, hash: *const [32]u8, bytes: []const u8) void { const file = name(hash); if (c.has(io, hash, bytes.len)) return; var buf: [96]u8 = undefined; const tmp = std.fmt.bufPrint(&buf, ".tmp-{d}-{d}-{s}", .{ std.c.getpid(), tmp_serial.fetchAdd(1, .monotonic), file[0..16] }) catch return; c.dir.writeFile(io, .{ .sub_path = tmp, .data = bytes }) catch { c.dir.deleteFile(io, tmp) catch {}; return; }; c.dir.rename(tmp, c.dir, &file, io) catch c.dir.deleteFile(io, tmp) catch {}; } /// Room for `incoming` more bytes under the cap, the least recently /// used files deleted first (a hit makes its file's time now). /// ponytail: the directory scanned and sorted at each join's store; /// fine to tens of thousands of blobs, where an index would take over. pub fn trim(c: Cache, io: std.Io, incoming: u64) void { const File = struct { name: [80]u8, len: u8, size: u64, mtime: i96 }; var files: std.ArrayListUnmanaged(File) = .empty; defer files.deinit(std.heap.c_allocator); var total: u64 = 0; var it = c.dir.iterate(); while (it.next(io) catch null) |entry| { if (entry.kind != .file or entry.name.len > 80) continue; const st = c.dir.statFile(io, entry.name, .{}) catch continue; var f: File = .{ .name = undefined, .len = @intCast(entry.name.len), .size = st.size, .mtime = st.mtime.nanoseconds }; @memcpy(f.name[0..f.len], entry.name); files.append(std.heap.c_allocator, f) catch return; total += st.size; } if (total + incoming <= c.cap) return; std.mem.sort(File, files.items, {}, struct { fn older(_: void, a: File, b: File) bool { return a.mtime < b.mtime; } }.older); for (files.items) |f| { if (total + incoming <= c.cap) break; c.dir.deleteFile(io, f.name[0..f.len]) catch continue; total -= f.size; } } }; fn said(why: []u8, comptime fmt: []const u8, args: anytype) ?Joined { _ = std.fmt.bufPrint(why, fmt ++ "\x00", args) catch {}; return null; } /// A message `Replica.input` made, to the session: the event's frame (its /// client and seq are the connection's). pub fn sendInput(fd: c_int, msg: []const u8) bool { return writeAll(fd, msg[head_len..]); } /// A message `Replica.screen` or `screenRequest` made, to the session. pub fn sendScreen(fd: c_int, msg: []const u8) bool { var buf: [64]u8 = undefined; if (wire.header_len + msg.len > buf.len) { const head = wire.header(@backingInt(wire.ClientTag.screen_ack), msg.len); return writeAll(fd, &head) and writeAll(fd, msg); } buf[0..wire.header_len].* = wire.header(@backingInt(wire.ClientTag.screen_ack), msg.len); @memcpy(buf[wire.header_len..][0..msg.len], msg); return writeAll(fd, buf[0 .. wire.header_len + msg.len]); } /// Asks the session's digest, answered in stream order. pub fn askCheck(fd: c_int) bool { var out: [16]u8 = undefined; return writeAll(fd, wire.encodeClient(&out, .check) catch unreachable); } /// The client's last word: `again`, it joins again for its view at once. pub fn bye(fd: c_int, again: bool) void { var out: [16]u8 = undefined; if (wire.encodeClient(&out, .{ .bye = .{ .again = again } })) |b| _ = writeAll(fd, b) else |_| {} } /// What the session streams a client after its dump, as its frontend's loop /// takes it: a unit's and a terminal message's bytes and a refusal's words /// on the C heap, the loop's to free. pub const Said = union(enum) { unit: []u8, screen: []u8, checked: u64, refused: []u8 }; /// The session's stream off `fd`, each message handed to `post` until the /// link ends (a refusal ends it too); `post` says whether it took it (one /// it did not is freed here). pub fn readLink(gpa: Allocator, fd: c_int, rest: *Framer, ctx: anytype, comptime post: fn (@TypeOf(ctx), Said) bool) void { const Take = struct { fn take(x: @TypeOf(ctx), tag: u8, payload: []const u8) bool { const t = std.enums.fromInt(wire.ServerTag, tag) orelse return false; const msg: Said = switch (t) { .unit => .{ .unit = std.heap.c_allocator.dupe(u8, payload) catch return false }, .screen => .{ .screen = std.heap.c_allocator.dupe(u8, payload) catch return false }, .check => .{ .checked = (wire.decodeServer(tag, payload) catch return false).check }, .refused => .{ .refused = std.heap.c_allocator.dupe(u8, (wire.decodeServer(tag, payload) catch return false).refused) catch return false }, .pong, .welcome, .dump, .blobs, .zstd => return true, }; if (!post(x, msg)) switch (msg) { .unit, .screen, .refused => |b| std.heap.c_allocator.free(b), .checked => {}, }; return msg != .refused; } }; rest.run(gpa, fd, ctx, Take.take); } /// The words a client goes with when its session runs another build now. const upgrade_words = "session upgraded to a newer pardes: upgrade this client too"; /// A replica client's join, the terminal's and the window's alike (their /// `remote`): the session at `path` dialled, its build checked to be this /// one's, and its dump loaded into a replica checked against the session /// as it was dumped. Or, `old` given, joined again once old's link has /// ended, for old's view (`redial`): the core it leaves held meanwhile so /// that its blobs are not sent again (`Have.leaving`), and let go before /// the new one loads. The dump is let go, a far join's to the thread that /// keeps the blobs it was sent (`Have.store`), and how long it all took is /// `j.ms`. Null, and why in `why`. pub fn join(gpa: Allocator, j: *Joined, path: []const u8, session: []const u8, o: pardes.Options, have: ?*Have, why: *[600]u8, old: ?*Replica) ?*Replica { if (old) |prev| if (have) |h| h.leaving(prev.core()); const t0 = nowNs(); if (old) |prev| { j.* = redial(gpa, path, session, why, have, prev.diverged == null, j.view) orelse { var words: [600]u8 = undefined; const said_ = std.mem.sliceTo(why, 0); @memcpy(words[0..said_.len], said_); _ = std.fmt.bufPrint(why, "could not join again: {s}\x00", .{words[0..said_.len]}) catch {}; return null; }; if (have) |h| h.left(); prev.deinit(); } else j.* = sameBuild(gpa, dial(gpa, path, session, why, have, null) orelse return null, why) orelse return null; defer { if (have) |h| h.store(gpa, j) else gpa.free(j.dump); j.dump = &.{}; } const r = Replica.initDump(gpa, j.client, j.view, j.dump, o) catch |err| { _ = std.fmt.bufPrint(why, "the session's dump would not load: {t}\x00", .{err}) catch {}; return null; }; // PARDES_NO_ECHO: no predicted echo (the gates' baseline). if (std.c.getenv("PARDES_NO_ECHO") != null) r.echo.on = false; // PARDES_REPLICA_STATS: its timing samples kept, for its line. r.stats.samples = std.c.getenv("PARDES_REPLICA_STATS") != null; if (!r.loaded(j.digest)) { r.deinit(); _ = std.fmt.bufPrint(why, "the session's dump loaded as another session (a build's dump is not complete)\x00", .{}) catch {}; return null; } r.gmtoff = j.gmtoff; j.ms = (nowNs() - t0) / std.time.ns_per_ms; return r; } /// `j`, when its session runs this build; else its link let go, and why in /// `why`: the daemon judged the hello by what the session last said, which /// an upgrade under way may not have said yet. fn sameBuild(gpa: Allocator, j: Joined, why: []u8) ?Joined { if (j.semantics == wire.semantics) return j; bye(j.fd, false); _ = libc.close(j.fd); var jj = j; jj.rest.deinit(gpa); gpa.free(j.dump); _ = std.fmt.bufPrint(why, "{s}\x00", .{upgrade_words}) catch {}; return null; } /// The session again, after a divergence or an upgrade: an upgrade's /// takes the time its exec and load take, and its daemon's, so it is /// dialled every 100 ms for 20 s. Null, and why in `why`. /// `patient`: after an Upgrade's `refused` alone, while the session is /// away a moment; after a divergence a session that will not answer is /// gone, and the client says so at once (it froze 20 s, 2026-10-30). /// `view`: the one it had, which the session kept for it (views.away). fn redial(gpa: Allocator, path: []const u8, session: []const u8, why: *[600]u8, have: ?*Have, patient: bool, view: u8) ?Joined { var tries: u32 = 0; while (true) : (tries += 1) { why.* = @splat(0); if (dial(gpa, path, session, why, have, view)) |j| return sameBuild(gpa, j, why); if (std.mem.indexOf(u8, std.mem.sliceTo(why, 0), "runs another build") != null) { _ = std.fmt.bufPrint(why, "{s}\x00", .{upgrade_words}) catch {}; return null; } if (!patient or tries > 200) return null; const ts: libc.timespec = .{ .sec = 0, .nsec = 100 * std.time.ns_per_ms }; _ = libc.nanosleep(&ts, null); } } /// A replica client's link to its session, the terminal's (tui.zig /// `remote`) and the window's (gui.zig `remote`): its replica, its socket, /// what the session said, and what it checks. Drawing is the frontend's. pub const Link = struct { r: *Replica, fd: c_int, quit: bool = false, /// The session hung up. gone: bool = false, /// Something to draw: an input applied, a unit taken. dirty: bool = true, /// The last frame was held for the frontend's answer (a terminal's /// FrameAck, a window's skipped image). owed: bool = false, /// PARDES_REPLICA_CHECK=: once quiet a while after a change, the /// session's digest is asked, and whether this replica's agrees is /// written there, a line a check. check: ?[:0]const u8 = null, changed: bool = false, asked: bool = false, /// When its own last input was, and its last check asked (`quietCheck` /// waits a while after each). input_ns: u64 = 0, asked_ns: u64 = 0, /// How many of its own inputs the session recorded otherwise when it /// last drew: a frame after one that draws something is a rollback that /// may have been seen (counted so: an upper bound, the frame shows the /// inputs after it too). mispredicted: u32 = 0, visible: u32 = 0, /// What the session said as it let this client go (the C heap's). refused: ?[]u8 = null, /// A line over its frame, until its next key (`notify`): why it joined /// again. The client's own, never the session's core. notice_buf: [240]u8 = undefined, notice_len: usize = 0, /// PARDES_TEST_DIVERGE=: once quiet after its n-th unit, its core /// is put off the session's (a digested counter moved), the next unit's /// digest finds it, and it joins again (test/daemon.py). test_diverge: u32 = 0, /// Put off so in this join: its checks are not written (they differ). put_off: bool = false, /// How its last join went (Joined's counts), and how long its dial and /// load took (PARDES_REPLICA_STATS). join: struct { blobs: u32 = 0, from_memory: u32 = 0, from_disk: u32 = 0, sent_bytes: u64 = 0 } = .{}, join_ms: u64 = 0, /// The test knobs the environment sets (PARDES_REPLICA_CHECK, /// PARDES_TEST_DIVERGE). pub fn fromEnv(c: *Link, gpa: Allocator, env: *const std.process.Environ.Map) !void { if (env.get("PARDES_REPLICA_CHECK")) |file| c.check = try gpa.dupeSentinel(u8, file, 0); if (env.get("PARDES_TEST_DIVERGE")) |n| c.test_diverge = std.fmt.parseInt(u32, n, 10) catch 0; } pub fn deinit(c: *Link, gpa: Allocator) void { if (c.check) |file| gpa.free(file); if (c.refused) |words| std.heap.c_allocator.free(words); } /// Join `j`'s link, from its start, and how that join went. pub fn reset(c: *Link, r: *Replica, j: *const Joined) void { c.r = r; c.fd = j.fd; c.join = .{ .blobs = j.blobs, .from_memory = j.from_memory, .from_disk = j.from_disk, .sent_bytes = j.sent_bytes }; c.join_ms = j.ms; c.quit = false; c.gone = false; c.dirty = true; c.owed = false; c.changed = false; c.asked = false; c.mispredicted = 0; c.put_off = false; } pub fn notify(c: *Link, comptime fmt: []const u8, args: anytype) void { const text = std.fmt.bufPrint(&c.notice_buf, fmt, args) catch c.notice_buf[0..]; for (text) |*b| if (b.* < 0x20 or b.* > 0x7e) { b.* = '?'; }; c.notice_len = text.len; } pub fn notice(c: *const Link) []const u8 { return c.notice_buf[0..c.notice_len]; } /// The frontend's input: applied at once, and sent to the session. pub fn input(c: *Link, ev: pardes.Event) void { // Its notice read: a key of its own puts it away. if (c.notice_len > 0 and (ev == .key or ev == .paste)) c.notice_len = 0; c.input_ns = nowNs(); const msg = c.r.input(ev) catch return; if (!sendInput(c.fd, msg)) c.cut(); c.dirty = true; } /// What the session streamed, in its order; the bytes are let go. pub fn take(c: *Link, msg: Said) void { switch (msg) { .unit => |bytes| { defer std.heap.c_allocator.free(bytes); c.r.confirm(bytes); if (c.test_diverge != 0 and c.r.stats.units >= c.test_diverge and c.r.quiet()) { c.test_diverge = 0; c.put_off = true; c.r.core().next_serial +%= 1000; } if (c.r.moved) c.dirty = true; c.r.moved = false; c.changed = true; }, .screen => |bytes| { defer std.heap.c_allocator.free(bytes); if (c.r.screen(bytes)) |reply| if (!sendScreen(c.fd, reply)) c.cut(); c.dirty = true; }, .checked => |d| c.checked(d), .refused => |words| { if (c.refused) |old| std.heap.c_allocator.free(old); c.refused = words; c.quit = true; }, } if (c.r.diverged != null) c.quit = true; } /// Its own view drawn, by the frontend (`drew` is whether anything was /// written to it): a rollback it may have shown counted, and the /// history rows it shows and does not hold (a scroll back) asked for, /// blank until they come. pub fn drawn(c: *Link, drew: bool) void { if (c.r.stats.mispredicted > c.mispredicted) { c.mispredicted = c.r.stats.mispredicted; if (drew) c.visible += 1; } c.dirty = false; while (c.r.screenRequest()) |req| if (!sendScreen(c.fd, req)) { c.cut(); break; }; } /// A write to the session failed: it hung up (it cut this client off, /// lagging), as its reader will say. fn cut(c: *Link) void { c.quit = true; c.gone = true; } /// Each pass of the frontend's loop: quiet (nothing of its own /// pending) 300 ms after its last input and its last check, and /// changed since, the session's digest is asked once, answered in /// stream order after the units before it (a session that pumps on, a /// window's test feed, sends a unit a frame; the check's own wakes it /// once). The wake it wants, ms. pub fn quietCheck(c: *Link) ?u32 { if (c.check == null or !c.changed or c.asked or !c.r.quiet()) return null; const quiet_ns = 300 * std.time.ns_per_ms; const since = nowNs() -| @max(c.input_ns, c.asked_ns); if (since < quiet_ns) return @intCast((quiet_ns - since) / std.time.ns_per_ms + 1); c.changed = false; c.asked = askCheck(c.fd); if (!c.asked) c.cut(); c.asked_ns = nowNs(); return null; } /// The session's digest against this replica's, if it is quiet still. fn checked(c: *Link, theirs: u64) void { c.asked = false; const path = c.check orelse return; if (!c.r.quiet() or c.put_off) return; const mine = c.r.digest(); var buf: [96]u8 = undefined; const line = (if (mine == theirs) std.fmt.bufPrint(&buf, "agree {x:0>16}\n", .{mine}) else std.fmt.bufPrint(&buf, "differ {x:0>16} {x:0>16}\n", .{ mine, theirs })) catch return; appendTo(path, line); } /// PARDES_REPLICA_STATS=: how its inputs and the session's units /// went, a line at its end (test/daemon.py, the gates). pub fn writeStats(c: *Link, path: []const u8) void { const st = &c.r.stats; var buf: [1024]u8 = undefined; const e = &c.r.echo.stats; var w: std.Io.Writer = .fixed(&buf); w.print("inputs {d} at_once {d} stopped {d} units {d} fast {d} neutral {d} mispredicted {d} foreign {d} visible {d} rtt_us {d} spec_us {d}/{d} copy_us {d}/{d} rollback_us {d}/{d} join_ms {d} blobs {d} from_memory {d} from_disk {d} sent_kb {d} echo {d}/{d} confirmed {d} missed {d}", .{ st.inputs, st.speculated, st.stopped, st.units, st.fast, c.r.neutral, st.mispredicted, st.foreign, c.visible, c.r.rtt_ns / 1000, pctOf(st.spec_ns.items, 50) / 1000, pctOf(st.spec_ns.items, 99) / 1000, pctOf(st.copy_ns.items, 50) / 1000, pctOf(st.copy_ns.items, 99) / 1000, pctOf(st.rollback_ns.items, 50) / 1000, pctOf(st.rollback_ns.items, 99) / 1000, c.join_ms, c.join.blobs, c.join.from_memory, c.join.from_disk, c.join.sent_bytes >> 10, e.predicted, e.predicted + e.unpredicted, e.confirmed, e.mispredicted, }) catch return; // What stopped its inputs, last: a word a pair before it. w.writeAll(" stops ") catch return; st.writeStops(&w) catch return; w.writeByte('\n') catch return; var z: [4096]u8 = undefined; appendTo(std.fmt.bufPrintSentinel(&z, "{s}", .{path}, 0) catch return, w.buffered()); } /// The link ended: whether the client joins again, and why in its /// notice (it diverged, or the session let it go to upgrade). pub fn rejoins(c: *Link) bool { if (c.r.diverged) |reason| { c.notify("joined again: this client diverged from the session ({s})", .{reason}); return true; } if (c.refused) |words| { c.notify("joined again: {s}", .{words}); std.heap.c_allocator.free(words); c.refused = null; return true; } return false; } }; test "a client joining again after a divergence is told at once that its session is gone" { var why: [600]u8 = undefined; const t0 = nowNs(); try std.testing.expect(redial(std.testing.allocator, "/nonexistent/pardes-replica.sock", "gone", &why, null, false, 1) == null); try std.testing.expect(nowNs() - t0 < 100 * std.time.ns_per_ms); } fn appendTo(path: [:0]const u8, line: []const u8) void { const fd = libc.open(path, .{ .ACCMODE = .WRONLY, .CREAT = true, .APPEND = true, .CLOEXEC = true }, @as(libc.mode_t, 0o644)); if (fd < 0) return; _ = libc.write(fd, line.ptr, line.len); _ = libc.close(fd); } pub fn digestOf(a: *Authority) u64 { const was = Stepping.begin(&a.t, null); defer was.end(); return tape.digestOf(a.core); } const TestHost = struct { fn watched(_: ?*anyopaque) bool { return false; } const vtable: pardes.Host.VTable = .{ .watched = watched }; fn host() pardes.Host { return .{ .vtable = &vtable }; } }; /// An edit's file time is the clock's second, which a replica guesses: a /// second's turn between a key and the authority's take of it is a fair /// misprediction (11 runs in 40 of a loaded Debug window build's test /// below). The tests that count fast confirmations start early in a second. fn freshSecond() void { while (true) { var ts: std.c.timespec = undefined; if (std.c.clock_gettime(.REALTIME, &ts) != 0 or ts.nsec < 50 * std.time.ns_per_ms) return; const rest: std.c.timespec = .{ .sec = 0, .nsec = std.time.ns_per_s - ts.nsec }; _ = std.c.nanosleep(&rest, null); } } fn key(r: *Replica, cp: u21, sent: *std.ArrayListUnmanaged([]u8)) !void { const text = [_]u8{@intCast(cp & 0x7f)}; const msg = try r.input(.{ .key = .{ .cp = cp, .text = if (cp < 0x80 and cp >= 0x20) &text else "" } }); try sent.append(std.testing.allocator, try std.testing.allocator.dupe(u8, msg)); } 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(), false); defer a.deinit(); 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; defer { for (sent.items) |m| gpa.free(m); sent.deinit(gpa); } freshSecond(); for ("oabc") |k| try key(r, k, &sent); try key(r, pardes.Key.escape, &sent); try std.testing.expectEqual(@as(usize, 5), r.applied); for (sent.items) |m| { r.confirm(try a.take(m)); r.settle(); } if (r.diverged) |why| std.debug.print("diverged: {s}\n", .{why}); try std.testing.expect(r.diverged == null); try std.testing.expectEqual(@as(u32, 5), r.stats.fast); try std.testing.expect(r.quiet()); try std.testing.expectEqual(digestOf(a), r.digest()); } test "an input's time is its client's: an edit's second confirms on the fast path though the authority takes it in the next" { const gpa = std.testing.allocator; 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), false); defer r.deinit(); var sent: std.ArrayListUnmanaged([]u8) = .empty; defer { for (sent.items) |m| gpa.free(m); sent.deinit(gpa); } try key(r, 'o', &sent); for (sent.items) |m| { r.confirm(try a.take(m)); r.settle(); } // Typed 30 ms before a second's turn, taken 30 ms after it: the edit's // file time is the clock's second, read in the step. while (true) { var ts: std.c.timespec = undefined; _ = std.c.clock_gettime(.REALTIME, &ts); if (ts.nsec >= 970 * std.time.ns_per_ms) break; const rest: std.c.timespec = .{ .sec = 0, .nsec = 970 * std.time.ns_per_ms - ts.nsec }; _ = std.c.nanosleep(&rest, null); } try key(r, 'x', &sent); try std.testing.expectEqual(@as(usize, 1), r.applied); const late: std.c.timespec = .{ .sec = 0, .nsec = 60 * std.time.ns_per_ms }; _ = std.c.nanosleep(&late, null); r.confirm(try a.take(sent.items[1])); r.settle(); try std.testing.expect(r.diverged == null and r.quiet()); try std.testing.expectEqual(@as(u32, 2), r.stats.fast); try std.testing.expectEqual(@as(u32, 0), r.stats.mispredicted); try std.testing.expectEqual(digestOf(a), r.digest()); } 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(), 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, false); defer r1.deinit(); const r2 = try Replica.init(gpa, 2, first, false); defer r2.deinit(); var s1: std.ArrayListUnmanaged([]u8) = .empty; var s2: std.ArrayListUnmanaged([]u8) = .empty; defer { for (s1.items) |m| gpa.free(m); for (s2.items) |m| gpa.free(m); s1.deinit(gpa); s2.deinit(gpa); } freshSecond(); for ("oone") |k| try key(r1, k, &s1); for ("Otwo") |k| try key(r2, k, &s2); // The authority hears r2 first, then r1; both hear the units in that // order. for ([_]*std.ArrayListUnmanaged([]u8){ &s2, &s1 }) |list| for (list.items) |m| { const u = try gpa.dupe(u8, try a.take(m)); defer gpa.free(u); r1.confirm(u); r1.settle(); r2.confirm(u); r2.settle(); }; for ([_]*Replica{ r1, r2 }) |r| { if (r.diverged) |why| std.debug.print("diverged: {s}\n", .{why}); try std.testing.expect(r.diverged == null); try std.testing.expect(r.quiet()); try std.testing.expectEqual(digestOf(a), r.digest()); } try std.testing.expect(r1.stats.foreign >= 1); try std.testing.expectEqual(@as(u32, 4), r2.stats.fast); } test "a delta applied under a speculation outlives its rollback: the terminal stays the authority's newest" { if (comptime !terminal.enabled) return error.SkipZigTest; const gpa = std.testing.allocator; const a = try Authority.init(gpa, .{ .cols = 80, .rows = 24, .boot = .tty }, TestHost.host(), true); defer a.deinit(); var screens: Screens = .init(gpa); defer screens.deinit(a.core); const peer = try screens.addPeer(); const r = try Replica.init(gpa, 1, try a.unit(0, 0), true); defer r.deinit(); const shell: u8 = for (a.core.panes, 0..) |slot, id| { if (slot) |pane| if (pane.isTerminal()) break @intCast(id); } else return error.NoShell; // Typing goes to the text pane under the shell (the host's write of // `active`, taped). a.core.active = for (a.core.panes, 0..) |slot, id| { if (slot) |pane| if (pane.file != null) break id; } else return error.NoTextPane; r.confirm(try a.local(.{ .focus = true })); try deliver(a, &screens, peer, r, .flush); var sent: std.ArrayListUnmanaged([]u8) = .empty; defer { for (sent.items) |m| gpa.free(m); sent.deinit(gpa); } // Typed into the file, at once: a copy is held. try key(r, 'o', &sent); try std.testing.expect(r.copy.held); var line: [64]u8 = undefined; for (0..3) |round| { // The shell prints: its unit rolls the replica back and applies the // key again; then its delta lands, under the new copy. for (0..40) |i| a.output(.{ .output = .{ .pane = shell, .bytes = try std.fmt.bufPrint(&line, "round {d} line {d}\r\n", .{ round, i }) } }); r.confirm((try a.pending()).?); r.settle(); try std.testing.expect(r.copy.held); try deliver(a, &screens, peer, r, .flush); // The rows the core keeps, read once under the copy. _ = try terminal.shellRows(r.core(), r.core().panes[shell].?); } for (sent.items) |m| { r.confirm(try a.take(m)); r.settle(); gpa.free(m); } sent.clearRetainingCapacity(); try deliver(a, &screens, peer, r, .flush); // Drawn (its rows read, between steps), then typed into: the copy keeps // those rows. The shell prints, its delta lands under the copy, and then // another's unit puts the copy back: the rows it kept are of an older // grid and must not be read. r.confirm(try a.local(.{ .focus = false })); _ = try terminal.shellRows(r.core(), r.core().panes[shell].?); try key(r, 'x', &sent); for (0..40) |i| a.output(.{ .output = .{ .pane = shell, .bytes = try std.fmt.bufPrint(&line, "last line {d}\r\n", .{i}) } }); r.confirm((try a.pending()).?); r.settle(); try deliver(a, &screens, peer, r, .flush); r.confirm(try a.local(.{ .focus = true })); r.settle(); const n = a.core.panes[shell].?.rows; const back = try terminal.shellRows(r.core(), r.core().panes[shell].?); const now = try terminal.shellRows(a.core, a.core.panes[shell].?); for (now[now.len - n ..], back[back.len - n ..]) |x, y| try std.testing.expectEqualStrings(x, y); for (sent.items) |m| { r.confirm(try a.take(m)); r.settle(); } try deliver(a, &screens, peer, r, .flush); if (r.diverged) |why| std.debug.print("diverged: {s}\n", .{why}); try std.testing.expect(r.diverged == null and r.quiet()); try std.testing.expectEqual(digestOf(a), r.digest()); var dump_a: std.Io.Writer.Allocating = .init(gpa); defer dump_a.deinit(); var dump_r: std.Io.Writer.Allocating = .init(gpa); defer dump_r.deinit(); try screen_state.dumpScreen(&a.core.panes[shell].?.terminal.?.vt, &dump_a.writer); try screen_state.dumpScreen(&r.core().panes[shell].?.terminal.?.vt, &dump_r.writer); try std.testing.expectEqualStrings(dump_a.written(), dump_r.written()); const rows_a = try terminal.shellRows(a.core, a.core.panes[shell].?); const rows_r = try terminal.shellRows(r.core(), r.core().panes[shell].?); // As many rows (the history is the authority's to the row), the screen's // the same; above it, rows scrolled past more than a screen at once are // holes until fetched. try std.testing.expectEqual(rows_a.len, rows_r.len); const shown = a.core.panes[shell].?.rows; for (rows_a[rows_a.len - shown ..], rows_r[rows_r.len - shown ..]) |x, y| try std.testing.expectEqualStrings(x, y); } test "a closed terminal brought back on a screen-state replica: its emulator on the C heap, never the rollback epoch's" { if (comptime !terminal.enabled) return error.SkipZigTest; const gpa = std.testing.allocator; const a = try Authority.init(gpa, .{ .cols = 80, .rows = 24, .boot = .tty }, TestHost.host(), true); defer a.deinit(); const r = try Replica.init(gpa, 1, try a.unit(0, 0), true); defer r.deinit(); const shell: u8 = for (a.core.panes, 0..) |slot, id| { if (slot) |pane| if (pane.isTerminal()) break @intCast(id); } else return error.NoShell; a.core.active = shell; r.confirm(try a.local(.{ .command = "Del" })); try std.testing.expectEqual(@as(usize, 1), a.core.store.closed.items.len); var line: [32]u8 = undefined; r.confirm(try a.local(.{ .command = try std.fmt.bufPrint(&line, "Look @p{d}", .{a.core.store.closed.items[0].serial}) })); try std.testing.expect(r.diverged == null); const back = for (r.core().panes) |slot| { if (slot) |pane| if (pane.terminal) |state| break state; } else return error.NotBack; // Its deltas write it while a copy is held, and its screen replica's // blobs are freed with the C heap's (`deinit`): the epoch's, a rollback // freed what they held and the exit freed them behind its back (H21). try std.testing.expect(r.epoch.owns(@intFromPtr(back)) == null); } test "a view that sized a terminal closing leaves nothing queued: the others' replicas copy, type and agree" { if (comptime !terminal.enabled) return error.SkipZigTest; const gpa = std.testing.allocator; const a = try Authority.init(gpa, .{ .cols = 100, .rows = 30, .boot = .tty }, TestHost.host(), true); 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, true); defer r1.deinit(); const r2 = try Replica.init(gpa, 2, first, true); defer r2.deinit(); a.core.active = for (a.core.panes, 0..) |slot, id| { if (slot) |pane| if (pane.isTerminal()) break id; } else return error.NoShell; const opened = try a.openView(2); r2.view = opened.view; for ([_]*Replica{ r1, r2 }) |r| r.confirm(opened.unit); var sent: std.ArrayListUnmanaged([]u8) = .empty; defer { for (sent.items) |m| gpa.free(m); sent.deinit(gpa); } // The second client, at another size, types into the terminal: its // view sizes it. Then it goes (H10, 2026-10-30: the first aborted). try sent.append(gpa, try gpa.dupe(u8, try r2.input(.{ .resize = .{ .cols = 50, .rows = 20 } }))); try key(r2, 'x', &sent); for (sent.items) |m| { const u = try gpa.dupe(u8, try a.take(m)); defer gpa.free(u); r1.confirm(u); r1.settle(); } r1.confirm(try a.closeView(2)); try std.testing.expectEqual(@as(usize, 0), a.core.effects_len); try std.testing.expectEqual(@as(usize, 0), r1.core().effects_len); r1.ready(); try std.testing.expect(r1.copy.held); for (sent.items) |m| gpa.free(m); sent.clearRetainingCapacity(); try key(r1, 'y', &sent); r1.confirm(try a.take(sent.items[0])); r1.settle(); if (r1.diverged) |why| std.debug.print("diverged: {s}\n", .{why}); try std.testing.expect(r1.diverged == null and r1.quiet()); try std.testing.expectEqual(digestOf(a), r1.digest()); } test "a terminal sized again by a client's key: the step reads the grid it had, on both sides" { if (comptime !terminal.enabled) return error.SkipZigTest; const gpa = std.testing.allocator; const a = try Authority.init(gpa, .{ .cols = 50, .rows = 20, .boot = .tty }, TestHost.host(), true); defer a.deinit(); var screens: Screens = .init(gpa); defer screens.deinit(a.core); const peer = try screens.addPeer(); const r = try Replica.init(gpa, 1, try a.unit(0, 0), true); defer r.deinit(); const shell: u8 = for (a.core.panes, 0..) |slot, id| { if (slot) |pane| if (pane.isTerminal()) break @intCast(id); } else return error.NoShell; a.core.active = shell; // History the replica holds as holes, of lines a narrow grid wraps in // two, which a wider one unwraps. var line: [96]u8 = undefined; for (0..60) |i| a.output(.{ .output = .{ .pane = shell, .bytes = try std.fmt.bufPrint(&line, "{d:0>4} xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx\r\n", .{i}) } }); r.confirm((try a.pending()).?); // Out of terminal mode in the session's view, which sizes it; then a // client's own view (a copy of it), wider: its first key sizes the // terminal again, in that key's step (the soak's tty and window at two // sizes, 2026-10-30: the client's replay read holes the session's step // had read as text, and the fill came in the new grid's numbers). r.confirm(try a.local(.{ .key = .{ .cp = 'b', .ctrl = true } })); for ([_]u21{ 'g', 'g' }) |cp| r.confirm(try a.local(.{ .key = .{ .cp = cp, .text = &.{@intCast(cp)} } })); const opened = try a.openView(1); r.view = opened.view; r.confirm(opened.unit); try deliver(a, &screens, peer, r, .flush); var sent: std.ArrayListUnmanaged([]u8) = .empty; defer { for (sent.items) |m| gpa.free(m); sent.deinit(gpa); } const Step = struct { fn take(au: *Authority, sc: *Screens, pe: u16, rr: *Replica, msg: []const u8) !void { try deliver(au, sc, pe, rr, .flush); const u = try std.testing.allocator.dupe(u8, try au.take(msg)); defer std.testing.allocator.free(u); try deliver(au, sc, pe, rr, .fill); terminal.resizeDeferred(au.core); rr.confirm(u); rr.settle(); } }; try sent.append(gpa, try gpa.dupe(u8, try r.input(.{ .resize = .{ .cols = 120, .rows = 30 } }))); try key(r, 'g', &sent); try key(r, 'g', &sent); for (sent.items) |m| try Step.take(a, &screens, peer, r, m); for (sent.items) |m| gpa.free(m); sent.clearRetainingCapacity(); // The session's view types into it, which sizes it back (the client's // copy of its history all holes again, a new numbering); then the // client's key that reads all of it, and sizes it again. try deliver(a, &screens, peer, r, .flush); { const was = Stepping.begin(&a.t, null); a.core.toView(0); a.core.update(.{ .key = .{ .cp = 'k', .text = "k" } }); a.core.step(); was.end(); } a.seq += 1; const back = try gpa.dupe(u8, try a.unit(0, a.seq)); defer gpa.free(back); try deliver(a, &screens, peer, r, .fill); terminal.resizeDeferred(a.core); r.confirm(back); r.settle(); try deliver(a, &screens, peer, r, .flush); try key(r, 'w', &sent); try key(r, 'w', &sent); for (sent.items) |m| try Step.take(a, &screens, peer, r, m); try deliver(a, &screens, peer, r, .flush); if (r.diverged) |why| std.debug.print("diverged: {s}\n", .{why}); try std.testing.expect(r.diverged == null and r.quiet()); try std.testing.expectEqual(digestOf(a), r.digest()); } /// What the session sends a peer: its terminals' changes (`.flush`), or, /// around a step's unit (Peers.input), the rows the step read that the /// peer lacks (`.fill`), after which the caller gives terminals the sizes /// the step gave them (`terminal.resizeDeferred`), then the unit. fn deliver(a: *Authority, screens: *Screens, peer: u16, r: *Replica, comptime what: enum { flush, fill }) !void { const gpa = std.testing.allocator; var msgs: std.ArrayListUnmanaged([]u8) = .empty; defer { for (msgs.items) |m| gpa.free(m); msgs.deinit(gpa); } switch (what) { .flush => try screens.flush(a.core, peer, &msgs), .fill => { try screens.fill(a.core, peer, &msgs); screens.filled(a.core); }, } for (msgs.items) |m| if (r.screen(m)) |reply| { _ = try screens.take(a.core, peer, reply); }; } test "pardes's own keys over a terminal's history apply at once: its view moves here, a delta while they wait puts them on top again, the authority's ends the same" { if (comptime !terminal.enabled) return error.SkipZigTest; const gpa = std.testing.allocator; const a = try Authority.init(gpa, .{ .cols = 80, .rows = 24, .boot = .tty }, TestHost.host(), true); defer a.deinit(); var screens: Screens = .init(gpa); defer screens.deinit(a.core); const peer = try screens.addPeer(); const r = try Replica.init(gpa, 1, try a.unit(0, 0), true); defer r.deinit(); const shell: u8 = for (a.core.panes, 0..) |slot, id| { if (slot) |pane| if (pane.isTerminal()) break @intCast(id); } else return error.NoShell; a.core.active = shell; r.confirm(try a.local(.{ .focus = true })); var line: [64]u8 = undefined; for (0..200) |i| a.output(.{ .output = .{ .pane = shell, .bytes = try std.fmt.bufPrint(&line, "history line {d}\r\n", .{i}) } }); r.confirm((try a.pending()).?); try deliver(a, &screens, peer, r, .flush); r.settle(); var sent: std.ArrayListUnmanaged([]u8) = .empty; defer { for (sent.items) |m| gpa.free(m); sent.deinit(gpa); } // Normal mode in the shell, up a few rows, then half a screen and more: // the cursor leaves the view, and the view follows it back. const keys = [_]pardes.Key{ .{ .cp = a.core.opts.tty_toggle, .ctrl = true }, .{ .cp = 'k', .text = "k" }, .{ .cp = 'k', .text = "k" }, .{ .cp = 'u', .ctrl = true }, .{ .cp = 'u', .ctrl = true }, .{ .cp = 'k', .text = "k" }, }; for (keys) |k| try sent.append(gpa, try gpa.dupe(u8, try r.input(.{ .key = k }))); try std.testing.expectEqual(@as(u32, 0), r.stats.stopped); try std.testing.expectEqual(sent.items.len, r.applied); const here = r.core().panes[shell].?; try std.testing.expect(terminal.viewOf(here) != null); // The shell prints while they wait: its unit, then its delta, which // sets the view the authority's (at the bottom still): what was applied // goes on top of it again. for (0..5) |i| a.output(.{ .output = .{ .pane = shell, .bytes = try std.fmt.bufPrint(&line, "late line {d}\r\n", .{i}) } }); r.confirm((try a.pending()).?); r.settle(); try deliver(a, &screens, peer, r, .flush); r.settle(); try std.testing.expectEqual(sent.items.len, r.applied); try std.testing.expect(terminal.viewOf(r.core().panes[shell].?) != null); // The authority takes them in order, the terminal sent before each and // the rows its step read after, as the session's loop does. for (sent.items) |m| { try deliver(a, &screens, peer, r, .flush); r.settle(); const u = try gpa.dupe(u8, try a.take(m)); defer gpa.free(u); try deliver(a, &screens, peer, r, .fill); r.confirm(u); r.settle(); } try deliver(a, &screens, peer, r, .flush); r.settle(); if (r.diverged) |why| std.debug.print("diverged: {s}\n", .{why}); try std.testing.expect(r.diverged == null and r.quiet()); try std.testing.expectEqual(@as(u32, 0), r.stats.mispredicted); try std.testing.expectEqual(digestOf(a), r.digest()); try std.testing.expect(terminal.viewOf(a.core.panes[shell].?) != null); try std.testing.expectEqual(terminal.viewOf(a.core.panes[shell].?), terminal.viewOf(r.core().panes[shell].?)); // A rollback with nothing confirmed on top puts the view back: one more // key up, and another's unit first. try sent.append(gpa, try gpa.dupe(u8, try r.input(.{ .key = .{ .cp = 'u', .ctrl = true } }))); const before = terminal.viewOf(a.core.panes[shell].?); try std.testing.expect(terminal.viewOf(r.core().panes[shell].?).? < before.?); r.confirm(try a.local(.{ .focus = false })); r.settle(); const last = try gpa.dupe(u8, try a.take(sent.items[sent.items.len - 1])); defer gpa.free(last); r.toConfirmed(); try std.testing.expectEqual(before, terminal.viewOf(r.core().panes[shell].?)); r.dirty = true; r.settle(); try deliver(a, &screens, peer, r, .fill); r.confirm(last); r.settle(); try deliver(a, &screens, peer, r, .flush); r.settle(); if (r.diverged) |why| std.debug.print("diverged: {s}\n", .{why}); try std.testing.expect(r.diverged == null and r.quiet()); try std.testing.expectEqual(digestOf(a), r.digest()); 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=)" { 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); defer a.deinit(); _ = try a.local(.{ .key = .{ .cp = 'j', .text = "j" } }); const was = Stepping.begin(&a.t, null); const bytes = try pardes.dump.dumpBytes(a.core); tape.resync(&a.t); was.end(); defer a.core.gpa.free(bytes); const r = try Replica.initDump(gpa, 1, 0, bytes, .{ .cols = 80, .rows = 24 }); defer r.deinit(); try std.testing.expectEqual(digestOf(a), r.digest()); r.confirm(try a.local(.{ .key = .{ .cp = 'j', .text = "j" } })); if (r.diverged) |why| std.debug.print("diverged: {s}\n", .{why}); try std.testing.expect(r.diverged == null); var sent: std.ArrayListUnmanaged([]u8) = .empty; defer { for (sent.items) |m| gpa.free(m); sent.deinit(gpa); } for ("oab") |k| try key(r, k, &sent); try key(r, pardes.Key.escape, &sent); for (sent.items) |m| { r.confirm(try a.take(m)); r.settle(); } if (r.diverged) |why| std.debug.print("diverged: {s}\n", .{why}); try std.testing.expect(r.diverged == null); try std.testing.expect(r.quiet()); try std.testing.expectEqual(digestOf(a), r.digest()); } test "a host's Adopt and a terminal reader's failure are inputs: a replica makes the same pane" { const gpa = std.testing.allocator; // Its terminals as screen state, as a session's for its clients are. const a = try Authority.init(gpa, .{ .cols = 80, .rows = 24, .file = "mise.toml" }, TestHost.host(), true); defer a.deinit(); const was = Stepping.begin(&a.t, null); const bytes = try pardes.dump.dumpBytes(a.core); tape.resync(&a.t); was.end(); defer a.core.gpa.free(bytes); const r = try Replica.initDump(gpa, 1, 0, bytes, .{ .cols = 80, .rows = 24 }); defer r.deinit(); // What tui.zig's and gui.zig's adoptShell and a failed reader do between // steps: they wrote the core straight, and every client joined again. const host = Stepping.begin(&a.t, null); const id = a.core.adoptShell().?; try std.testing.expect(a.core.panes[id].?.isTerminal() and !a.core.panes[id].?.greet); a.core.readerFailed(id, error.InputOutput); a.core.pump(a.host) catch {}; host.end(); a.seq += 1; r.confirm(try a.unit(0, a.seq)); if (r.diverged) |why| std.debug.print("diverged: {s}\n", .{why}); try std.testing.expect(r.diverged == null); try std.testing.expectEqual(digestOf(a), r.digest()); } test "a join's dump, its blobs put back where they go, is the session's dump" { const gpa = std.testing.allocator; const a = try Authority.init(gpa, .{ .cols = 80, .rows = 24, .file = "mise.toml" }, TestHost.host(), false); defer a.deinit(); const text = try gpa.alloc(u8, 20000); defer gpa.free(text); @memset(text, 'x'); _ = try a.local(.{ .key = .{ .cp = 'i', .text = "i" } }); _ = try a.local(.{ .paste = text }); _ = try a.local(.{ .key = .{ .cp = pardes.Key.escape, .text = "" } }); const was = Stepping.begin(&a.t, null); defer was.end(); const whole = try pardes.dump.dumpBytes(a.core); defer a.core.gpa.free(whole); var blobs: std.ArrayListUnmanaged(walk.Deferred) = .empty; defer blobs.deinit(a.core.gpa); const state = try pardes.dump.dumpJoin(a.core, &blobs); defer a.core.gpa.free(state); try std.testing.expect(blobs.items.len > 0); try std.testing.expect(state.len + 20000 <= whole.len); var joined: std.ArrayListUnmanaged(u8) = .empty; defer joined.deinit(gpa); var pos: usize = 0; for (blobs.items) |b| { try joined.appendSlice(gpa, state[pos..b.at]); try joined.appendSlice(gpa, b.bytes); pos = b.at; } try joined.appendSlice(gpa, state[pos..]); try std.testing.expectEqualSlices(u8, whole, joined.items); } test "a cached blob is hashed again as it is read: one cut short, corrupted, planted or longer is a miss, and goes" { const io = std.testing.io; var tmp = std.testing.tmpDir(.{ .iterate = true }); defer tmp.cleanup(); const c: Cache = .{ .dir = tmp.dir, .cap = 1 << 20 }; var text: [6000]u8 = undefined; for (&text, 0..) |*b, i| b.* = @truncate(i *% 31 +% i / 7); var hash: [32]u8 = undefined; std.crypto.hash.Blake3.hash(&text, &hash, .{}); const file = Cache.name(&hash); var out: [6000]u8 = undefined; try std.testing.expect(!c.get(io, &hash, &out)); c.put(io, &hash, &text); try std.testing.expect(c.has(io, &hash, text.len)); try std.testing.expect(c.get(io, &hash, &out)); try std.testing.expectEqualSlices(u8, &text, &out); var corrupted = text; corrupted[4000] ^= 0x20; const planted: [6000]u8 = @splat('x'); var longer: [6001]u8 = undefined; @memcpy(longer[0..6000], &text); longer[6000] = '\n'; for ([_][]const u8{ text[0..3000], &corrupted, &planted, &longer }) |bad| { try tmp.dir.writeFile(io, .{ .sub_path = &file, .data = bad }); @memset(&out, 0); try std.testing.expect(!c.get(io, &hash, &out)); try std.testing.expectError(error.FileNotFound, tmp.dir.statFile(io, &file, .{})); } // ...and put back, it is read again. c.put(io, &hash, &text); try std.testing.expect(c.get(io, &hash, &out)); try std.testing.expectEqualSlices(u8, &text, &out); } test "the blob cache stays under its cap, the least recently used going first" { const io = std.testing.io; var tmp = std.testing.tmpDir(.{ .iterate = true }); defer tmp.cleanup(); const c: Cache = .{ .dir = tmp.dir, .cap = 3 * 5000 }; var blobs: [3][5000]u8 = undefined; var hashes: [3][32]u8 = undefined; for (&blobs, &hashes, 0..) |*b, *h, k| { @memset(b, @intCast('a' + k)); std.crypto.hash.Blake3.hash(b, h, .{}); c.put(io, h, b); // Each older than the next, a thousand seconds apart. const name = Cache.name(h); try tmp.dir.setTimestamps(io, &name, .{ .modify_timestamp = .{ .new = .{ .nanoseconds = @as(i96, @intCast(k + 1)) * 1000 * std.time.ns_per_s } } }); } // The oldest read: it is the newest now. var out: [5000]u8 = undefined; try std.testing.expect(c.get(io, &hashes[0], &out)); c.trim(io, 5000); try std.testing.expect(c.has(io, &hashes[0], 5000)); try std.testing.expect(!c.has(io, &hashes[1], 5000)); try std.testing.expect(c.has(io, &hashes[2], 5000)); // A file not a blob's counts, and goes by its time as well. const junk: [9000]u8 = @splat(0); try tmp.dir.writeFile(io, .{ .sub_path = ".tmp-1-1-0123456789abcdef", .data = &junk }); try tmp.dir.setTimestamps(io, ".tmp-1-1-0123456789abcdef", .{ .modify_timestamp = .{ .new = .{ .nanoseconds = 500 * std.time.ns_per_s } } }); c.trim(io, 5000); try std.testing.expectError(error.FileNotFound, tmp.dir.statFile(io, ".tmp-1-1-0123456789abcdef", .{})); try std.testing.expect(c.has(io, &hashes[0], 5000) and c.has(io, &hashes[2], 5000)); // Under the cap with room to spare: nothing goes. c.trim(io, 0); try std.testing.expect(c.has(io, &hashes[0], 5000) and c.has(io, &hashes[2], 5000)); // Room for the whole cap: everything goes, the older first. c.trim(io, c.cap); try std.testing.expect(!c.has(io, &hashes[0], 5000) and !c.has(io, &hashes[2], 5000)); } /// A far join over a socket pair, the session's writer and reader threads /// against the client's `joinOn`, as the daemon hands a connection over: /// its hello read off first. fn farJoinOnce(ps: *Peers, core: *Pardes, have: ?*Have) !Joined { var fds: [2]c_int = undefined; if (libc.socketpair(libc.AF.UNIX, libc.SOCK.STREAM | libc.SOCK.CLOEXEC, 0, &fds) != 0) return error.NoSocket; var blobs: std.ArrayListUnmanaged(walk.Deferred) = .empty; const state = pardes.dump.dumpJoin(core, &blobs) catch |err| { _ = libc.close(fds[0]); _ = libc.close(fds[1]); return err; }; var whole = state.len; for (blobs.items) |b| whole += b.bytes.len; const peer = try ps.gpa.create(Peer); peer.* = .{ .peers = ps, .fd = fds[0], .id = 1, .view = 0, .dump = state, .blobs = blobs, .dump_gpa = core.gpa }; peer.welcome_len = (wire.encodeServer(&peer.welcome, .{ .welcome = .{ .pid = 1, .session = "t", .dump_len = whole, .blobs = @intCast(blobs.items.len) } }) catch unreachable).len; const Serve = struct { fn run(p: *Peer) void { var hello: [wire.header_len + 14]u8 = undefined; var got: usize = 0; while (got < hello.len) { const n = libc.read(p.fd, hello[got..].ptr, hello.len - got); if (n <= 0) return p.peers.post(.{ .gone = p }); got += @intCast(n); } p.readLoop(); } }; peer.writer = try std.Thread.spawn(.{}, Peer.writeLoop, .{peer}); peer.reader = try std.Thread.spawn(.{}, Serve.run, .{peer}); defer ps.letGo(peer); var why: [300]u8 = @splat(0); return joinOn(std.testing.allocator, fds[1], "t", &why, have, null) orelse { std.debug.print("the join failed: {s}\n", .{std.mem.sliceTo(&why, 0)}); return error.JoinFailed; }; } fn endJoin(j: *Joined, have: ?*Have) void { _ = libc.close(j.fd); j.rest.deinit(std.testing.allocator); if (have) |h| { h.store(std.testing.allocator, j); h.wait(); } else { std.testing.allocator.free(j.dump); std.heap.c_allocator.free(j.got); } } test "a far join is sent each blob once: joined again with them on disk or in the core it leaves, the state alone; a cached file gone bad, that blob again" { const gpa = std.testing.allocator; const io = std.testing.io; zstd.gpa = gpa; defer zstd.gpa = std.heap.c_allocator; const a = try Authority.init(gpa, .{ .cols = 80, .rows = 24, .file = "mise.toml" }, TestHost.host(), false); defer a.deinit(); const text = try gpa.alloc(u8, 30000); defer gpa.free(text); for (text, 0..) |*b, i| b.* = if (i % 61 == 60) '\n' else @intCast('a' + (i * 7 + i / 13) % 26); _ = try a.local(.{ .key = .{ .cp = 'i', .text = "i" } }); _ = try a.local(.{ .paste = text }); _ = try a.local(.{ .key = .{ .cp = pardes.Key.escape, .text = "" } }); _ = try a.local(.{ .key = .{ .cp = 'o', .text = "o" } }); _ = try a.local(.{ .paste = text[0..9000] }); _ = try a.local(.{ .key = .{ .cp = pardes.Key.escape, .text = "" } }); const was = Stepping.begin(&a.t, null); defer was.end(); const whole = try pardes.dump.dumpBytes(a.core); defer a.core.gpa.free(whole); // What the session's list will say: its blobs, those of one text once. var listed: std.ArrayListUnmanaged(walk.Deferred) = .empty; defer listed.deinit(a.core.gpa); a.core.gpa.free(try pardes.dump.dumpJoin(a.core, &listed)); var distinct: std.AutoHashMapUnmanaged([32]u8, usize) = .empty; defer distinct.deinit(gpa); var distinct_bytes: u64 = 0; var biggest: [32]u8 = undefined; var biggest_len: usize = 0; for (listed.items) |b| { var d: [32]u8 = undefined; std.crypto.hash.Blake3.hash(b.bytes, &d, .{}); if ((try distinct.getOrPut(gpa, d)).found_existing) continue; distinct_bytes += b.bytes.len; if (b.bytes.len > biggest_len) { biggest = d; biggest_len = b.bytes.len; } } try std.testing.expect(distinct.count() >= 3); var tmp = std.testing.tmpDir(.{ .iterate = true }); defer tmp.cleanup(); var have: Have = .{ .io = io, .cache = .{ .dir = tmp.dir, .cap = 64 << 20 } }; defer { have.cache = null; have.deinit(); } var ps: Peers = .{ .gpa = gpa, .io = io }; defer ps.deinit(); // A near client: the dump whole, as before. var j = try farJoinOnce(&ps, a.core, null); try std.testing.expectEqualSlices(u8, whole, j.dump); try std.testing.expectEqual(@as(u32, 0), j.blobs); endJoin(&j, null); // The first far join: every blob sent, once. j = try farJoinOnce(&ps, a.core, &have); try std.testing.expectEqualSlices(u8, whole, j.dump); try std.testing.expectEqual(listed.items.len, j.blobs); try std.testing.expectEqual(@as(u32, 0), j.from_disk + j.from_memory); try std.testing.expectEqual(distinct_bytes, j.sent_bytes); endJoin(&j, &have); // Again: all of them on disk. j = try farJoinOnce(&ps, a.core, &have); try std.testing.expectEqualSlices(u8, whole, j.dump); try std.testing.expectEqual(distinct.count(), j.from_disk); try std.testing.expectEqual(@as(u64, 0), j.sent_bytes); endJoin(&j, &have); // The biggest's file corrupted: it alone is sent again. const name = Cache.name(&biggest); const junk = try gpa.alloc(u8, biggest_len); defer gpa.free(junk); @memset(junk, 'z'); try tmp.dir.writeFile(io, .{ .sub_path = &name, .data = junk }); j = try farJoinOnce(&ps, a.core, &have); try std.testing.expectEqualSlices(u8, whole, j.dump); try std.testing.expectEqual(distinct.count() - 1, j.from_disk); try std.testing.expectEqual(@as(u64, biggest_len), j.sent_bytes); endJoin(&j, &have); // A rejoin, no disk: what the core it leaves holds. const cache = have.cache; have.cache = null; have.leaving(a.core); j = try farJoinOnce(&ps, a.core, &have); have.left(); have.cache = cache; try std.testing.expectEqualSlices(u8, whole, j.dump); try std.testing.expectEqual(distinct.count(), j.from_memory); try std.testing.expectEqual(@as(u64, 0), j.sent_bytes); endJoin(&j, &have); } /// A replica joined from the session's dump as it is now, between units, /// as `Peers.join` sends it: its state, its blobs put back where they go. fn joinedNow(a: *Authority, id: u16, view: u8) !*Replica { const gpa = std.testing.allocator; const was = Stepping.begin(&a.t, null); var blobs: std.ArrayListUnmanaged(walk.Deferred) = .empty; defer blobs.deinit(a.core.gpa); const state = try pardes.dump.dumpJoin(a.core, &blobs); defer a.core.gpa.free(state); tape.resync(&a.t); was.end(); var whole: std.ArrayListUnmanaged(u8) = .empty; defer whole.deinit(gpa); var pos: usize = 0; for (blobs.items) |b| { try whole.appendSlice(gpa, state[pos..b.at]); try whole.appendSlice(gpa, b.bytes); pos = b.at; } try whole.appendSlice(gpa, state[pos..]); return Replica.initDump(gpa, id, view, whole.items, .{ .cols = 80, .rows = 24 }); } fn agrees(a: *Authority, r: *Replica) !void { if (r.diverged) |why| std.debug.print("diverged: {s}\n", .{why}); try std.testing.expect(r.diverged == null); try std.testing.expect(r.quiet()); try std.testing.expectEqual(digestOf(a), r.digest()); } test "a replica joined after a pane closed: the session's jump to it, its Panes and Recent rows, asked by either" { const gpa = std.testing.allocator; const a = try Authority.init(gpa, .{ .cols = 80, .rows = 24, .file = "mise.toml" }, TestHost.host(), false); defer a.deinit(); // A file looked at and closed: a jump to it, Recent's, a closed pane. var cwd: [std.fs.max_path_bytes]u8 = undefined; var line: [std.fs.max_path_bytes + 32]u8 = undefined; const dir = std.mem.span(@as([*:0]u8, @ptrCast(std.c.getcwd(&cwd, cwd.len) orelse return error.NoCwd))); _ = try a.local(.{ .command = try std.fmt.bufPrint(&line, "Look {s}/build.zig.zon", .{dir}) }); _ = try a.local(.{ .command = "Del" }); try std.testing.expectEqual(@as(usize, 1), a.core.store.closed.items.len); try std.testing.expect(a.core.njumps > 1); // What another window of the user's wrote to the store, which the // session read (src/variants_test.zig's case, the variant hunt's). a.core.recent.opened(a.core.recentGpa(), try std.fmt.bufPrint(&line, "{s}/build.zig", .{dir})); const r = try joinedNow(a, 1, 0); defer r.deinit(); try std.testing.expectEqual(digestOf(a), r.digest()); r.confirm(try a.local(.{ .key = .{ .cp = 'j', .text = "j" } })); r.confirm(try a.local(.{ .command = "Search Panes" })); r.confirm(try a.local(.{ .command = "Search Recent" })); try agrees(a, r); // The replica's own: it waits for the session's rows. for ([_][]const u8{ "Search Panes", "Search Recent" }) |asked| { const msg = try gpa.dupe(u8, try r.input(.{ .command = asked })); defer gpa.free(msg); r.confirm(try a.take(msg)); r.settle(); } try agrees(a, r); // The closed pane brought back by the replica's Look at it: the // session's record of it, off the tape. { const closed = try std.fmt.bufPrint(&line, "Look @p{d}", .{a.core.store.closed.items[0].serial}); const msg = try gpa.dupe(u8, try r.input(.{ .command = closed })); defer gpa.free(msg); r.confirm(try a.take(msg)); r.settle(); try std.testing.expectEqual(@as(usize, 0), a.core.store.closed.items.len); try agrees(a, r); r.confirm(try a.local(.{ .command = "Del" })); } // A jump back onto the closed file: opened again, from Recent. for (0..3) |_| { const msg = try gpa.dupe(u8, try r.input(.{ .key = .{ .cp = 'o', .ctrl = true } })); defer gpa.free(msg); r.confirm(try a.take(msg)); r.settle(); } try agrees(a, r); } test "a replica's Del of a file its session's Recent knows asks the host what the session asked" { const gpa = std.testing.allocator; const a = try Authority.init(gpa, .{ .cols = 80, .rows = 24, .file = "mise.toml" }, TestHost.host(), false); defer a.deinit(); var cwd: [std.fs.max_path_bytes]u8 = undefined; var line: [std.fs.max_path_bytes + 32]u8 = undefined; const dir = std.mem.span(@as([*:0]u8, @ptrCast(std.c.getcwd(&cwd, cwd.len) orelse return error.NoCwd))); _ = try a.local(.{ .command = try std.fmt.bufPrint(&line, "Look {s}/build.zig.zon", .{dir}) }); // Joined while it is open: in the session's Recent, in no replica's. const r = try joinedNow(a, 1, 0); defer r.deinit(); const msg = try gpa.dupe(u8, try r.input(.{ .command = "Del" })); defer gpa.free(msg); r.confirm(try a.take(msg)); r.settle(); try std.testing.expectEqual(@as(usize, 1), a.core.store.closed.items.len); try agrees(a, r); } /// A host with ptys whose pump polls for a frame, as a client's does. const PtyHost = struct { fn resized(_: ?*anyopaque, _: u8, _: u16, _: u16) void {} fn poll(_: ?*anyopaque) void {} const vtable: pardes.Host.VTable = .{ .watched = TestHost.watched, .pty_resize = resized, .poll_frame = poll }; fn host() pardes.Host { return .{ .vtable = &vtable }; } }; fn inputOf(buf: []u8, client: u16, seq: u32, ev: pardes.Event) ![]const u8 { const n = (try wire.encodeClient(buf[head_len..], .{ .event = ev })).len; header(buf, client, seq); return buf[0 .. head_len + n]; } test "a client leaves, and one joins: what the leave queued (a terminal's resize) is done in its unit, on every side, before the join's dump" { if (comptime !terminal.enabled) return error.SkipZigTest; const gpa = std.testing.allocator; const a = try Authority.init(gpa, .{ .cols = 80, .rows = 24, .boot = .tty }, PtyHost.host(), true); defer a.deinit(); const first = try gpa.dupe(u8, try a.unit(0, 0)); defer gpa.free(first); const old = try Replica.init(gpa, 1, first, true); defer old.deinit(); // A second client, bigger, types into the terminal: it sizes it. const opened = try a.openView(2); old.confirm(opened.unit); var buf: [256]u8 = undefined; old.confirm(try a.take(try inputOf(&buf, 2, 1, .{ .resize = .{ .cols = 120, .rows = 40 } }))); old.confirm(try a.take(try inputOf(&buf, 2, 2, .{ .key = .{ .cp = 'x', .text = "x" } }))); // It leaves: the terminal is the first view's size again, its pty's // resize queued for the next pump; and a client joins at that boundary. var was = Stepping.begin(&a.t, null); a.core.closeView(opened.view); was.end(); old.confirm(try a.unit(0, 100)); // The client left idle takes its copy ahead (Replica.ready): of a core // with nothing queued. old.ready(); was = Stepping.begin(&a.t, null); const k = a.core.openView() orelse return error.NoView; was.end(); old.confirm(try a.unit(0, 101)); const joiner = try joinedNow(a, 3, k); defer joiner.deinit(); try std.testing.expectEqual(digestOf(a), joiner.digest()); // The next pump's unit, every client's. const u = try gpa.dupe(u8, try a.local(.tick)); defer gpa.free(u); old.confirm(u); joiner.confirm(u); try agrees(a, old); try agrees(a, joiner); } test "a client that diverged joins again for its view: kept for it meanwhile, its pane in it again; the other client agrees" { const gpa = std.testing.allocator; 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 old = try Replica.init(gpa, 1, first, false); defer old.deinit(); const opened = try a.openView(2); old.confirm(opened.unit); var buf: [256]u8 = undefined; old.confirm(try a.take(try inputOf(&buf, 2, 1, .{ .command = "New" }))); const made = a.core.active; // Its bye says it joins again: its view is kept, as every replica keeps it. var was = Stepping.begin(&a.t, null); a.core.awayView(opened.view); was.end(); old.confirm(try a.unit(0, 100)); try agrees(a, old); // Back for it: its own, its pane in it, in the dump it loads. was = Stepping.begin(&a.t, null); try std.testing.expect(a.core.rejoinView(opened.view)); was.end(); old.confirm(try a.unit(0, 101)); const back = try joinedNow(a, 3, opened.view); defer back.deinit(); try std.testing.expectEqual(digestOf(a), back.digest()); a.view_of[3] = opened.view; const u = try gpa.dupe(u8, try a.take(try back.input(.{ .key = .{ .cp = 'l', .text = "l" } }))); defer gpa.free(u); old.confirm(u); back.confirm(u); try std.testing.expectEqual(made, a.core.active); try std.testing.expect(pardes.layout.findPane(a.core, made) != null); try agrees(a, old); try agrees(a, back); } test "a client joined from a dump moves through another view's pane as the session does, its lines not wrapped" { const gpa = std.testing.allocator; const a = try Authority.init(gpa, .{ .cols = 80, .rows = 24, .file = "build.zig" }, TestHost.host(), false); defer a.deinit(); // The first client's Wrap off (SPC t w), and its cursor down into the // file's long lines, near the bottom of its view. var buf: [256]u8 = undefined; var seq: u32 = 1; const before = [_]pardes.Event{.{ .command = "Wrap" }} ++ @as([10]pardes.Event, @splat(.{ .key = .{ .cp = 'd', .ctrl = true } })) ++ @as([15]pardes.Event, @splat(.{ .key = .{ .cp = 'j', .text = "j" } })); for (before) |ev| { _ = try a.take(try inputOf(&buf, 1, seq, ev)); seq += 1; } // Another client joins, its view not live; the first's keys go on. _ = try a.openView(2); const joiner = try joinedNow(a, 3, 1); defer joiner.deinit(); try std.testing.expectEqual(digestOf(a), joiner.digest()); for (0..3) |_| { const u = try gpa.dupe(u8, try a.take(try inputOf(&buf, 1, seq, .{ .key = .{ .cp = 'd', .ctrl = true } }))); defer gpa.free(u); seq += 1; joiner.confirm(u); try agrees(a, joiner); } } test "a client joined from a dump makes a `/` query's rows as the session does, though only the session has drawn its owner" { if (comptime !pardes.syntax.enabled) return error.SkipZigTest; const gpa = std.testing.allocator; const a = try Authority.init(gpa, .{ .cols = 80, .rows = 24, .file = "build.zig" }, TestHost.host(), false); defer a.deinit(); // The session draws: its owner's colours painted for the view (File.refreshHighlights). { const was = Stepping.begin(&a.t, null); defer was.end(); var arena: std.heap.ArenaAllocator = .init(gpa); defer arena.deinit(); _ = try a.core.render(arena.allocator()); } _ = try a.openView(2); const joiner = try joinedNow(a, 3, 1); defer joiner.deinit(); try std.testing.expectEqual(digestOf(a), joiner.digest()); var buf: [256]u8 = undefined; for ("/co", 1..) |c, seq| { const u = try gpa.dupe(u8, try a.take(try inputOf(&buf, 1, @intCast(seq), .{ .key = .{ .cp = c, .text = &.{c} } }))); defer gpa.free(u); joiner.confirm(u); try agrees(a, joiner); } } /// An input of a replica's in the session's order, as `Peers.input` takes /// it: the terminals flushed to every peer, the step, the rows it read that /// each peer holds as holes (`fill`), then its unit to every replica. fn takeAll(a: *Authority, screens: *Screens, rs: []const *Replica, ps: []const u16, msg: []const u8) !void { const gpa = std.testing.allocator; for (rs, ps) |r, peer| try deliver(a, screens, peer, r, .flush); const u = try gpa.dupe(u8, try a.take(msg)); defer gpa.free(u); var rows: std.ArrayListUnmanaged([]u8) = .empty; defer rows.deinit(gpa); for (rs, ps) |r, peer| { rows.clearRetainingCapacity(); try screens.fill(a.core, peer, &rows); for (rows.items) |m| { _ = r.screen(m); gpa.free(m); } } screens.filled(a.core); for (rs) |r| { r.confirm(u); r.settle(); } } fn sendAs(r: *Replica, a: *Authority, screens: *Screens, rs: []const *Replica, ps: []const u16, ev: pardes.Event) !void { const msg = try std.testing.allocator.dupe(u8, try r.input(ev)); defer std.testing.allocator.free(msg); try takeAll(a, screens, rs, ps, msg); } test "a step that reads a terminal's rows as the core keeps them sends a new client the ones it holds as holes" { if (comptime !terminal.enabled) return error.SkipZigTest; const gpa = std.testing.allocator; const a = try Authority.init(gpa, .{ .cols = 80, .rows = 24, .boot = .tty }, PtyHost.host(), true); defer a.deinit(); var screens: Screens = .init(gpa); defer screens.deinit(a.core); const first = try gpa.dupe(u8, try a.unit(0, 0)); defer gpa.free(first); const r1 = try Replica.init(gpa, 1, first, true); defer r1.deinit(); const r2 = try Replica.init(gpa, 2, first, true); defer r2.deinit(); const shell: u8 = for (a.core.panes, 0..) |slot, id| { if (slot) |pane| if (pane.isTerminal()) break @intCast(id); } else return error.NoShell; a.core.active = shell; var line: [64]u8 = undefined; for (0..60) |i| a.output(.{ .output = .{ .pane = shell, .bytes = try std.fmt.bufPrint(&line, "line {d} of the shell's history\r\n", .{i}) } }); const out = try gpa.dupe(u8, (try a.pending()).?); defer gpa.free(out); for ([_]*Replica{ r1, r2 }) |r| r.confirm(out); // The first client alone has the terminal; it reads all of its rows // (its text, the cursor on the first): the core keeps them. const p1 = [_]u16{try screens.addPeer()}; for ([_]pardes.Event{ .{ .key = .{ .cp = 'b', .ctrl = true } }, .{ .key = .{ .cp = 'g', .text = "g" } }, .{ .key = .{ .cp = 'g', .text = "g" } } }) |ev| { const msg = try gpa.dupe(u8, try r1.input(ev)); defer gpa.free(msg); try takeAll(a, &screens, &.{r1}, &p1, msg); r2.confirm(a.out.items); } // A second comes: its history all holes. The first reads the rows the // core kept, nothing written since. const ps = [_]u16{ p1[0], try screens.addPeer() }; try sendAs(r1, a, &screens, &.{ r1, r2 }, &ps, .{ .key = .{ .cp = 'O', .text = "O" } }); for ([_]*Replica{ r1, r2 }) |r| try agrees(a, r); }