From 803f2a2678a8aa8f89b0663a84a60721d36f5831 Mon Sep 17 00:00:00 2001 From: Gabriel Schneider Date: Thu, 1 Oct 2026 02:33:14 -0300 Subject: pardes - writes the whole text through one open of the body, so a page over 8 MiB arrives whole, not as its last chunk Each 8 MiB chunk went in by its own Client.write, which opens a body with OTRUNC, so every chunk replaced the one before and a long page kept only its tail, with exit 0. The text now goes in through one open, truncated once and written at rising offsets; a long write is timed by its progress, each 9P write answered within 30 s rather than the whole transfer within 2. fs.py pages 11 MiB of numbered lines and compares the body byte for byte, and pages past the 256 MiB cap and checks the first 256 MiB and the cut note. Co-Authored-By: Claude Opus 5.5 --- src/9p_io.zig | 8 ++++++++ src/main.zig | 24 +++++------------------- 2 files changed, 13 insertions(+), 19 deletions(-) (limited to 'src') diff --git a/src/9p_io.zig b/src/9p_io.zig index 6cf75c99..d80d7b30 100644 --- a/src/9p_io.zig +++ b/src/9p_io.zig @@ -1937,6 +1937,8 @@ test "9P shell environment states being inside pardes apart from how to reach it pub const Client = struct { pub const budget_ms: i64 = 2000; + /// Each write of a long one has this long to be answered (transact). + pub const write_budget_ms: i64 = 30_000; pub const max_depth: usize = 2 * ninep.max_welem; @@ -2211,6 +2213,12 @@ pub const Client = struct { const count = (try s.ask(.{ .write = .{ .fid = cur, .offset = written, .data = chunk } }, remote)).write; if (count == 0 or count > chunk.len) return Error.Botch; written += count; + // A long write is timed by its progress: each answer gives + // the next its own budget, so a large body (`pardes -`) goes + // in through one open, whole, however long it takes. The + // budget is a write's: a server putting in tens of MiB it + // held (pane.zig batchFor) answers that one write late. + s.deadline = nowMs() +| write_budget_ms; } return; } diff --git a/src/main.zig b/src/main.zig index 6627bece..1075b596 100644 --- a/src/main.zig +++ b/src/main.zig @@ -101,8 +101,8 @@ const help_text = ; /// `pardes -` inside a session: `text` into the directory's one +Pager -/// (root ctl `pager `, refilled when it is there), streamed into its -/// body a bounded chunk at a time as one undo step, and left clean. A text +/// (root ctl `pager `, refilled when it is there), written into its +/// body through one open, as one undo step, and left clean. A text /// the session would not take is never lost: it goes to stderr, with why, /// and the exit is 1. fn pageInto(io: std.Io, gpa: std.mem.Allocator, dial: []const u8, text: []const u8) void { @@ -129,25 +129,11 @@ fn pageInto(io: std.Io, gpa: std.mem.Allocator, dial: []const u8, text: []const ninep_io.Client.write(gpa, dial, "/ctl", ctl_line) catch |err| Fail.with(io, text, "no +Pager pane", err); const answer = ninep_io.Client.read(gpa, dial, "/exec", "/exec") catch |err| Fail.with(io, text, "no +Pager pane", err); const serial = std.fmt.parseInt(u32, std.mem.trim(u8, answer, " \n"), 10) catch |err| Fail.with(io, text, "no +Pager pane", err); - var path_buf: [64]u8 = undefined; - const mark = std.fmt.bufPrint(&path_buf, "/pane/{d}/mark", .{serial}) catch unreachable; - // One undo step for the whole text, however many writes carry it. - ninep_io.Client.write(gpa, dial, mark, "0\n") catch |err| Fail.with(io, text, "the +Pager pane went", err); + // The whole text through one open of the body (truncated once, then + // written at rising offsets): one undo step, and every byte of it. var body_buf: [64]u8 = undefined; const body = std.fmt.bufPrint(&body_buf, "/pane/{d}/body", .{serial}) catch unreachable; - // A chunk ends on a line's end (never inside a character), each its own - // write with its own deadline, so a large text arrives whole. - const chunk_max = 8 * 1024 * 1024; - var at: usize = 0; - while (at < text.len) { - var end = @min(text.len, at + chunk_max); - if (end < text.len) if (std.mem.lastIndexOfScalar(u8, text[at..end], '\n')) |nl| { - end = at + nl + 1; - }; - ninep_io.Client.write(gpa, dial, body, text[at..end]) catch |err| Fail.with(io, text[at..], "the +Pager pane would not take it", err); - at = end; - } - ninep_io.Client.write(gpa, dial, mark, "1\n") catch {}; + ninep_io.Client.write(gpa, dial, body, text) catch |err| Fail.with(io, text, "the +Pager pane would not take it", err); var ctl_buf: [64]u8 = undefined; ninep_io.Client.write(gpa, dial, std.fmt.bufPrint(&ctl_buf, "/pane/{d}/ctl", .{serial}) catch unreachable, "clean\n") catch {}; } -- cgit v1.3