acmefs: pardes --fs serves acme's control filesystem over raw Linux FUSE

1 files changed, 263 insertions, 0 deletions

diff --git a/test/fs_bench.zig b/test/fs_bench.zig
new file mode 100644
index 00000000..7315676a
--- /dev/null
+++ b/test/fs_bench.zig
@@ -0,0 +1,263 @@
+//! THE FILESYSTEM SCOREBOARD: what one acme-fs request costs the core, and
+//! what serving one costs an editor that nobody is scripting.
+//!
+//!   zig build fs-bench                  -- the table
+//!   zig build fs-bench -- --json        -- the same, machine-readable
+//!   zig build fs-bench -- --reps 200000 -- more samples per row
+//!
+//! There is no FUSE here, and no thread: `acmefs.handle` IS the transaction
+//! (src/acmefs.zig), so driving it directly is measuring the whole of what the
+//! core does per request. That is the point of the split — a transport adds a
+//! `read(2)`, a `write(2)` and a wake, and those are the kernel's numbers, not
+//! ours (the mounted end-to-end figures are measured with real clients; see
+//! examples/README.md).
+//!
+//! THREE QUESTIONS THIS ANSWERS.
+//!
+//!   1. Is a request cheap enough to serve thousands per frame? Each row is
+//!      one `handle` call, median of `--reps`.
+//!   2. Does the steady state ALLOCATE? Every row is measured through a
+//!      counting allocator and the table prints the allocation count. A
+//!      non-zero number in a read row is a bug: reads answer with a range of
+//!      the pane's live text (`Payload.region`) or with the staging buffer,
+//!      and the staging buffer is cleared, never freed.
+//!   3. What does an editor with NO script attached pay? The last two rows are
+//!      the same keystroke with zero listeners and with one. Zero listeners
+//!      must be indistinguishable from an editor with no filesystem compiled
+//!      in at all: one branch in `file_pane.setContent`.
+const std = @import("std");
+const pardes = @import("pardes");
+const acmefs = pardes.acmefs;
+
+pub const std_options: std.Options = .{ .log_level = .err };
+
+const backing = std.heap.page_allocator;
+
+/// std.time.Timer is gone in 0.16; clock_gettime is what test/perf.zig uses.
+fn nowNs() u64 {
+    var ts: std.c.timespec = undefined;
+    _ = std.c.clock_gettime(.MONOTONIC, &ts);
+    return @as(u64, @intCast(ts.sec)) *| 1_000_000_000 +| @as(u64, @intCast(ts.nsec));
+}
+
+const Row = struct {
+    name: []const u8,
+    ns: u64,
+    allocs: usize,
+    note: []const u8 = "",
+};
+
+var rows: std.ArrayList(Row) = .empty;
+
+fn record(name: []const u8, total_ns: u64, reps: usize, counting: *std.testing.FailingAllocator, note: []const u8) void {
+    rows.append(backing, .{
+        .name = name,
+        .ns = total_ns / @max(1, reps),
+        .allocs = counting.allocations,
+        .note = note,
+    }) catch {};
+}
+
+/// A session with something to measure against: one big file pane, one shell,
+/// and a scripted pane whose event queue has records waiting.
+const Session = struct {
+    core: *pardes.Pardes,
+    counting: *std.testing.FailingAllocator,
+    file_id: usize,
+    file_serial: u32,
+
+    fn init(counting: *std.testing.FailingAllocator, body_bytes: usize) !Session {
+        const gpa = counting.allocator();
+        const core = try pardes.Pardes.init(gpa, .{ .tty_only = true, .cols = 120, .rows = 40 });
+        while (core.nextEffect()) |_| {}
+
+        // A body big enough that a copy would show up in the numbers.
+        const line = "the quick brown fox jumps over the lazy dog\n";
+        var content: std.ArrayList(u8) = .empty;
+        while (content.items.len < body_bytes) try content.appendSlice(backing, line);
+        const pane = try core.hxOpenFileContent(content.items);
+        content.deinit(backing);
+        const id = core.active;
+        while (core.nextEffect()) |_| {}
+        return .{
+            .core = core,
+            .counting = counting,
+            .file_id = id,
+            .file_serial = pane.serial,
+        };
+    }
+
+    fn deinit(s: *Session) void {
+        s.core.deinit();
+    }
+
+    fn node(s: *const Session, file: acmefs.PaneFile) u64 {
+        return acmefs.Node.of(s.file_serial, file);
+    }
+};
+
+/// One row: run `req` `reps` times and report the mean cost plus how many
+/// allocations the whole run made.
+///
+/// The per-update scratch arena is reset each rep because that is what the
+/// real path does — `Pardes.update` resets it at the end of every event, and
+/// `handle` called bare would otherwise let one arena grow across a hundred
+/// thousand requests and count its CHUNKS as allocations. Resetting here
+/// measures the request, not the harness.
+fn bench(s: *Session, name: []const u8, reps: usize, req: acmefs.Req, note: []const u8) void {
+    // warm the staging buffer and any lazy index the first call builds
+    for (0..64) |_| {
+        _ = acmefs.handle(s.core, req);
+        _ = s.core.scratch.reset(.retain_capacity);
+    }
+    s.counting.allocations = 0;
+    const start = nowNs();
+    for (0..reps) |_| {
+        const reply = acmefs.handle(s.core, req);
+        std.mem.doNotOptimizeAway(reply.status);
+        _ = s.core.scratch.reset(.retain_capacity);
+    }
+    record(name, nowNs() - start, reps, s.counting, note);
+}
+
+pub fn main(init: std.process.Init) !void {
+    const args = try init.minimal.args.toSlice(init.arena.allocator());
+    var reps: usize = 100_000;
+    var json = false;
+    var i: usize = 1;
+    while (i < args.len) : (i += 1) {
+        if (std.mem.eql(u8, args[i], "--json")) {
+            json = true;
+        } else if (std.mem.eql(u8, args[i], "--reps") and i + 1 < args.len) {
+            i += 1;
+            reps = try std.fmt.parseInt(usize, args[i], 10);
+        }
+    }
+
+    // std.testing.FailingAllocator with the default options never induces a
+    // failure and counts every allocation, which is the whole of what this
+    // benchmark wanted from a wrapper.
+    var counting: std.testing.FailingAllocator = .init(backing, .{});
+    var s = try Session.init(&counting, 1 << 20); // a 1 MiB body
+    defer s.deinit();
+
+    // ---- the three shapes of request -------------------------------------
+    bench(&s, "getattr body", reps, .{
+        .tag = 1,
+        .op = .getattr,
+        .node = s.node(.body),
+    }, "stat of a 1 MiB body");
+    bench(&s, "lookup ctl", reps, .{
+        .tag = 2,
+        .op = .lookup,
+        .node = acmefs.Node.of(s.file_serial, .dir),
+        .data = "ctl",
+    }, "name -> node");
+    bench(&s, "read body 4K", reps, .{
+        .tag = 3,
+        .op = .read,
+        .node = s.node(.body),
+        .off = 4096,
+        .size = 4096,
+    }, "must be zero-copy");
+    bench(&s, "read body 1M", reps / 10, .{
+        .tag = 4,
+        .op = .read,
+        .node = s.node(.body),
+        .off = 0,
+        .size = 1 << 20,
+    }, "same cost as 4K if truly zero-copy");
+    bench(&s, "read ctl", reps, .{
+        .tag = 5,
+        .op = .read,
+        .node = s.node(.ctl),
+        .size = 256,
+    }, "formatted into the staging buffer");
+    bench(&s, "read index", reps, .{
+        .tag = 6,
+        .op = .read,
+        .node = @intFromEnum(acmefs.TopFile.index),
+        .size = 4096,
+    }, "one line per pane");
+    bench(&s, "readdir root", reps, .{
+        .tag = 7,
+        .op = .readdir,
+        .node = @intFromEnum(acmefs.TopFile.root),
+        .size = 4096,
+    }, "staged dirents");
+    bench(&s, "read event (empty)", reps, .{
+        .tag = 8,
+        .op = .read,
+        .node = s.node(.event),
+        .size = 256,
+    }, "Status.again — the blocking primitive");
+    // Appending GROWS the fixture, and every append is a whole-body swap plus
+    // an undo snapshot (that is the core's edit model, not this filesystem's),
+    // so this row is quadratic in its own rep count against a 1 MiB body.
+    // Bounded on purpose: the question is what one write costs, and 200 of
+    // them answer it without spending a quarter of an hour proving that
+    // appending ten megabytes a kilobyte at a time is slow.
+    bench(&s, "write body 1K", @min(reps, 200), .{
+        .tag = 9,
+        .op = .write,
+        .node = s.node(.body),
+        .data = "x" ** 1024,
+        .size = 1024,
+    }, "append: whole-body swap + undo snapshot");
+
+    // ---- what an unscripted editor pays ----------------------------------
+    // The same keystroke, twice: with nobody listening and with one listener.
+    // The first number is the honest answer to "what does this feature cost a
+    // session that never uses it", and the pair is what recording costs.
+    //
+    // A FRESH SESSION PER ROW, and this matters: typing inserts at the cursor,
+    // so the line under it grows by one character per rep, and the core's
+    // per-keystroke cost is dominated by walking that line's grapheme widths
+    // (measured: `file_pane.graphemeDisplayWidth` is 65% of this benchmark's
+    // cycles). Reusing one session made the second row type into a body the
+    // first had already lengthened, and reported a 2.8x "overhead" that was
+    // entirely the fixture. Small bodies for the same reason: on the megabyte
+    // fixture a keystroke costs ~40 ms whatever this filesystem does.
+    const key_reps = @min(reps, 2000);
+    for ([_]bool{ false, true }) |scripted| {
+        var keys = try Session.init(&counting, 32 * 1024);
+        defer keys.deinit();
+        const pane = keys.core.panes[keys.file_id].?;
+        pane.mode = .insert;
+        if (scripted) {
+            keys.core.fs.panes[keys.file_id].readers = 1;
+            keys.core.fs.listeners = 1;
+        }
+        counting.allocations = 0;
+        const start = nowNs();
+        for (0..key_reps) |_| {
+            keys.core.update(.{ .key = .{ .cp = 'x', .text = "x" } });
+            while (keys.core.nextEffect()) |_| {}
+        }
+        record(
+            if (scripted) "keystroke, 1 listener" else "keystroke, no listener",
+            nowNs() - start,
+            key_reps,
+            &counting,
+            if (scripted) "diff + record" else "one branch",
+        );
+    }
+
+    var out: std.Io.Writer.Allocating = .init(backing);
+    defer out.deinit();
+    const w = &out.writer;
+    if (json) {
+        try w.writeAll("{\"rows\":[");
+        for (rows.items, 0..) |r, n| {
+            if (n > 0) try w.writeAll(",");
+            try w.print("{{\"name\":\"{s}\",\"ns\":{d},\"allocs\":{d}}}", .{ r.name, r.ns, r.allocs });
+        }
+        try w.writeAll("]}\n");
+    } else {
+        try w.print("{s:<26} {s:>9} {s:>8}  {s}\n", .{ "request", "ns/op", "allocs", "note" });
+        try w.print("{s:<26} {s:>9} {s:>8}  {s}\n", .{ "-" ** 26, "-" ** 9, "-" ** 8, "-" ** 20 });
+        for (rows.items) |r|
+            try w.print("{s:<26} {d:>9} {d:>8}  {s}\n", .{ r.name, r.ns, r.allocs, r.note });
+    }
+    try std.Io.File.stdout().writeStreamingAll(init.io, out.written());
+}