diff options
Diffstat (limited to 'tests_syntax_perf.zig')
| -rw-r--r-- | tests_syntax_perf.zig | 795 |
1 files changed, 795 insertions, 0 deletions
diff --git a/tests_syntax_perf.zig b/tests_syntax_perf.zig new file mode 100644 index 00000000..4179cd38 --- /dev/null +++ b/tests_syntax_perf.zig @@ -0,0 +1,795 @@ +const std = @import("std"); +const h = @import("e2e_harness.zig"); + +const Harness = h.Harness; +const linux = std.os.linux; +const posix = std.posix; + +const payload_len = 64; +const wheel_events = 240; +const j_events = 240; +const ctrl_d_events = 60; +const delete_line_input = "xxxxxxxxxxxxxxxxd"; +const delete_select_lines = delete_line_input.len - 1; +const scroll_marker_line = wheel_events; +const marker_wait_ms = 60_000; +const scroll_quiet_ms = 1000; +const large_stdlib_path = "/usr/lib/zig/std/Io/Threaded.zig"; +const target_ratio_x100 = 150; +const movement_ratio_floor_us = 20_000; +const startup_first_frame_target_us = 15_000; +const startup_samples = 5; + +fn nowNs() u64 { + var ts: linux.timespec = undefined; + _ = linux.clock_gettime(linux.CLOCK.MONOTONIC, &ts); + return @intCast(ts.sec * 1_000_000_000 + ts.nsec); +} + +fn fillPayload(buf: *[payload_len]u8, marker: []const u8) []const u8 { + const alphabet = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789"; + for (buf, 0..) |*ch, i| ch.* = alphabet[(i * 7 + marker.len * 11) % alphabet.len]; + @memcpy(buf[0..marker.len], marker); + return buf[0..marker.len]; +} + +fn waitRawGrowth(hs: *Harness, start_len: usize, ms: i64) !bool { + const deadline = nowNs() + @as(u64, @intCast(ms)) * 1_000_000; + var buf: [4096]u8 = undefined; + while (nowNs() < deadline) { + var fds = [_]posix.pollfd{.{ .fd = hs.master, .events = posix.POLL.IN, .revents = 0 }}; + _ = posix.poll(&fds, 5) catch {}; + if ((fds[0].revents & posix.POLL.IN) != 0) { + const n = posix.read(hs.master, &buf) catch break; + if (n == 0) break; + try hs.raw.appendSlice(hs.gpa, buf[0..n]); + hs.stream.nextSlice(buf[0..n]); + if (hs.raw.items.len > start_len) return true; + } + } + return hs.raw.items.len > start_len; +} + +fn waitForOutputQuiet(hs: *Harness, quiet_ms: i64, max_ms: i64) !bool { + const deadline = nowNs() + @as(u64, @intCast(max_ms)) * 1_000_000; + var quiet_deadline = nowNs() + @as(u64, @intCast(quiet_ms)) * 1_000_000; + var buf: [4096]u8 = undefined; + while (nowNs() < deadline) { + if (nowNs() >= quiet_deadline) return true; + var fds = [_]posix.pollfd{.{ .fd = hs.master, .events = posix.POLL.IN, .revents = 0 }}; + _ = posix.poll(&fds, 10) catch {}; + if ((fds[0].revents & posix.POLL.IN) != 0) { + const n = posix.read(hs.master, &buf) catch break; + if (n == 0) break; + try hs.raw.appendSlice(hs.gpa, buf[0..n]); + hs.stream.nextSlice(buf[0..n]); + quiet_deadline = nowNs() + @as(u64, @intCast(quiet_ms)) * 1_000_000; + } + } + return false; +} + +fn leftPaneTopLine(hs: *Harness) !usize { + const text = try hs.screenText(); + defer hs.gpa.free(text); + var rows = std.mem.splitScalar(u8, text, '\n'); + var row_idx: usize = 0; + while (rows.next()) |row| : (row_idx += 1) { + if (row_idx < 2) continue; + if (row_idx > 2) break; + const trimmed = std.mem.trimStart(u8, row, " "); + var end: usize = 0; + while (end < trimmed.len and std.ascii.isDigit(trimmed[end])) : (end += 1) {} + if (end > 0) return std.fmt.parseInt(usize, trimmed[0..end], 10) catch 0; + } + return 0; +} + +fn waitForTopLineAbove(hs: *Harness, start_line: usize, ms: i64) !?usize { + const deadline = nowNs() + @as(u64, @intCast(ms)) * 1_000_000; + var buf: [4096]u8 = undefined; + while (nowNs() < deadline) { + var fds = [_]posix.pollfd{.{ .fd = hs.master, .events = posix.POLL.IN, .revents = 0 }}; + _ = posix.poll(&fds, 10) catch {}; + if ((fds[0].revents & posix.POLL.IN) != 0) { + const n = posix.read(hs.master, &buf) catch break; + if (n == 0) break; + try hs.raw.appendSlice(hs.gpa, buf[0..n]); + hs.stream.nextSlice(buf[0..n]); + } + const top_line = try leftPaneTopLine(hs); + if (top_line > start_line) return top_line; + } + return null; +} + +fn waitForScreenMissing(hs: *Harness, needle: []const u8, ms: i64) !bool { + { + const text = try hs.screenText(); + defer hs.gpa.free(text); + if (std.mem.indexOf(u8, text, needle) == null) return true; + } + const deadline = nowNs() + @as(u64, @intCast(ms)) * 1_000_000; + var buf: [4096]u8 = undefined; + while (nowNs() < deadline) { + var fds = [_]posix.pollfd{.{ .fd = hs.master, .events = posix.POLL.IN, .revents = 0 }}; + _ = posix.poll(&fds, 10) catch {}; + if ((fds[0].revents & posix.POLL.IN) != 0) { + const n = posix.read(hs.master, &buf) catch break; + if (n == 0) break; + try hs.raw.appendSlice(hs.gpa, buf[0..n]); + hs.stream.nextSlice(buf[0..n]); + } + const text = try hs.screenText(); + defer hs.gpa.free(text); + if (std.mem.indexOf(u8, text, needle) == null) return true; + } + return false; +} + +fn waitForScreenContainsPoll(hs: *Harness, needle: []const u8, ms: i64, poll_ms: i32) !bool { + { + const text = try hs.screenText(); + defer hs.gpa.free(text); + if (std.mem.indexOf(u8, text, needle) != null) return true; + } + const deadline = nowNs() + @as(u64, @intCast(ms)) * 1_000_000; + var buf: [4096]u8 = undefined; + while (nowNs() < deadline) { + var fds = [_]posix.pollfd{.{ .fd = hs.master, .events = posix.POLL.IN, .revents = 0 }}; + _ = posix.poll(&fds, poll_ms) catch {}; + if ((fds[0].revents & posix.POLL.IN) != 0) { + const n = posix.read(hs.master, &buf) catch break; + if (n == 0) break; + try hs.raw.appendSlice(hs.gpa, buf[0..n]); + hs.stream.nextSlice(buf[0..n]); + } + const text = try hs.screenText(); + defer hs.gpa.free(text); + if (std.mem.indexOf(u8, text, needle) != null) return true; + } + return false; +} + +fn waitForRawContainsPoll(hs: *Harness, needle: []const u8, ms: i64, poll_ms: i32) !bool { + if (std.mem.indexOf(u8, hs.raw.items, needle) != null) return true; + const deadline = nowNs() + @as(u64, @intCast(ms)) * 1_000_000; + var buf: [4096]u8 = undefined; + while (nowNs() < deadline) { + var fds = [_]posix.pollfd{.{ .fd = hs.master, .events = posix.POLL.IN, .revents = 0 }}; + _ = posix.poll(&fds, poll_ms) catch {}; + if ((fds[0].revents & posix.POLL.IN) != 0) { + const n = posix.read(hs.master, &buf) catch break; + if (n == 0) break; + try hs.raw.appendSlice(hs.gpa, buf[0..n]); + hs.stream.nextSlice(buf[0..n]); + if (std.mem.indexOf(u8, hs.raw.items, needle) != null) return true; + } + } + return std.mem.indexOf(u8, hs.raw.items, needle) != null; +} + +const startup_metric_prefix = "PARDES_STARTUP_US="; + +fn parseStartupMetric(raw: []const u8) ?u64 { + const start = std.mem.indexOf(u8, raw, startup_metric_prefix) orelse return null; + var i = start + startup_metric_prefix.len; + const digit_start = i; + while (i < raw.len and std.ascii.isDigit(raw[i])) : (i += 1) {} + if (i == digit_start) return null; + return std.fmt.parseInt(u64, raw[digit_start..i], 10) catch null; +} + +fn waitForStartupMetric(hs: *Harness, ms: i64, poll_ms: i32) !?u64 { + if (parseStartupMetric(hs.raw.items)) |value| return value; + const deadline = nowNs() + @as(u64, @intCast(ms)) * 1_000_000; + var buf: [4096]u8 = undefined; + while (nowNs() < deadline) { + var fds = [_]posix.pollfd{.{ .fd = hs.master, .events = posix.POLL.IN, .revents = 0 }}; + _ = posix.poll(&fds, poll_ms) catch {}; + if ((fds[0].revents & posix.POLL.IN) != 0) { + const n = posix.read(hs.master, &buf) catch break; + if (n == 0) break; + try hs.raw.appendSlice(hs.gpa, buf[0..n]); + if (parseStartupMetric(hs.raw.items)) |value| return value; + } + } + return parseStartupMetric(hs.raw.items); +} + +fn wheelDownBurst(gpa: std.mem.Allocator) ![]u8 { + var out: std.ArrayList(u8) = .empty; + errdefer out.deinit(gpa); + var i: usize = 0; + while (i < wheel_events) : (i += 1) + try out.appendSlice(gpa, "\x1b[<65;10;6M"); + return out.toOwnedSlice(gpa); +} + +const Movement = enum { wheel, j, ctrl_d }; + +fn movementName(movement: Movement) []const u8 { + return switch (movement) { + .wheel => "wheel", + .j => "j", + .ctrl_d => "ctrl_d", + }; +} + +fn movementEventCount(movement: Movement) usize { + return switch (movement) { + .wheel => wheel_events, + .j => j_events, + .ctrl_d => ctrl_d_events, + }; +} + +fn movementInput(gpa: std.mem.Allocator, movement: Movement) ![]u8 { + if (movement == .wheel) return wheelDownBurst(gpa); + var out: std.ArrayList(u8) = .empty; + errdefer out.deinit(gpa); + var i: usize = 0; + const bytes = switch (movement) { + .wheel => unreachable, + .j => "j", + .ctrl_d => "\x04", + }; + while (i < movementEventCount(movement)) : (i += 1) + try out.appendSlice(gpa, bytes); + return out.toOwnedSlice(gpa); +} + +fn readFileAlloc(gpa: std.mem.Allocator, path: [*:0]const u8) ![]u8 { + const rc = linux.open(path, .{ .ACCMODE = .RDONLY }, 0); + const sfd: isize = @bitCast(rc); + if (sfd < 0) return error.OpenFailed; + const fd: c_int = @intCast(sfd); + defer _ = linux.close(fd); + + var out: std.ArrayList(u8) = .empty; + errdefer out.deinit(gpa); + var buf: [16 * 1024]u8 = undefined; + while (true) { + const n = posix.read(fd, &buf) catch return error.ReadFailed; + if (n == 0) break; + try out.appendSlice(gpa, buf[0..n]); + } + return out.toOwnedSlice(gpa); +} + +fn appendZigMarker(gpa: std.mem.Allocator, out: *std.ArrayList(u8), marker: []const u8) !void { + const line = try std.fmt.allocPrint(gpa, "const {s} = \"visible\";\n", .{marker}); + defer gpa.free(line); + try out.appendSlice(gpa, line); +} + +fn appendTextMarker(gpa: std.mem.Allocator, out: *std.ArrayList(u8), marker: []const u8) !void { + const line = try std.fmt.allocPrint(gpa, "{s} visible\n", .{marker}); + defer gpa.free(line); + try out.appendSlice(gpa, line); +} + +fn appendMarker(gpa: std.mem.Allocator, out: *std.ArrayList(u8), marker: []const u8, highlighted: bool) !void { + if (highlighted) { + try appendZigMarker(gpa, out, marker); + } else { + try appendTextMarker(gpa, out, marker); + } +} + +fn makeSmallFixture(gpa: std.mem.Allocator, open_marker: []const u8, scroll_marker: []const u8, highlighted: bool) ![]u8 { + var out: std.ArrayList(u8) = .empty; + errdefer out.deinit(gpa); + try appendMarker(gpa, &out, open_marker, highlighted); + if (highlighted) { + try out.appendSlice(gpa, "const std = @import(\"std\");\n"); + try out.appendSlice(gpa, "pub fn perf_entry() usize {\n"); + try out.appendSlice(gpa, " return perf_func_0() + perf_func_199();\n"); + try out.appendSlice(gpa, "}\n"); + } + var line_no: usize = if (highlighted) 5 else 1; + var i: usize = 0; + while (line_no < scroll_marker_line) : ({ + i += 1; + line_no += 1; + }) { + const line = if (highlighted) + try std.fmt.allocPrint(gpa, "fn perf_func_{d}() usize {{ return {d} + @as(usize, {d}); }}\n", .{ i, i, i % 17 }) + else + try std.fmt.allocPrint(gpa, "plain perf line {d}: words numbers strings comments\n", .{i}); + defer gpa.free(line); + try out.appendSlice(gpa, line); + } + try appendMarker(gpa, &out, scroll_marker, highlighted); + line_no += 1; + while (line_no < scroll_marker_line + 40) : ({ + i += 1; + line_no += 1; + }) { + const line = if (highlighted) + try std.fmt.allocPrint(gpa, "fn perf_tail_{d}() usize {{ return {d}; }}\n", .{ i, i }) + else + try std.fmt.allocPrint(gpa, "plain perf tail {d}: words numbers strings comments\n", .{i}); + defer gpa.free(line); + try out.appendSlice(gpa, line); + } + return out.toOwnedSlice(gpa); +} + +fn makeStdlibFixture(gpa: std.mem.Allocator, source: []const u8, open_marker: []const u8, scroll_marker: []const u8, highlighted: bool) ![]u8 { + var out: std.ArrayList(u8) = .empty; + errdefer out.deinit(gpa); + try appendMarker(gpa, &out, open_marker, highlighted); + var line_no: usize = 1; + var lines = std.mem.splitScalar(u8, source, '\n'); + while (lines.next()) |line| { + if (line_no == scroll_marker_line) { + try appendMarker(gpa, &out, scroll_marker, highlighted); + line_no += 1; + } + try out.appendSlice(gpa, line); + try out.append(gpa, '\n'); + line_no += 1; + } + while (line_no <= scroll_marker_line) : (line_no += 1) { + if (line_no == scroll_marker_line) { + try appendMarker(gpa, &out, scroll_marker, highlighted); + } else if (highlighted) { + const line = try std.fmt.allocPrint(gpa, "fn perf_padding_{d}() void {{}}\n", .{line_no}); + defer gpa.free(line); + try out.appendSlice(gpa, line); + } else { + const line = try std.fmt.allocPrint(gpa, "plain stdlib padding {d}\n", .{line_no}); + defer gpa.free(line); + try out.appendSlice(gpa, line); + } + } + return out.toOwnedSlice(gpa); +} + +fn lineCount(content: []const u8) usize { + return std.mem.count(u8, content, "\n") + 1; +} + +const Fixture = struct { + name: []const u8, + path: []const u8, + open_marker: []const u8, + edit_marker: []const u8, + scroll_marker: []const u8, + highlighted: bool, + bytes: usize, + lines: usize, +}; + +const BenchResult = struct { + startup_app_first_frame_us: u64, + startup_spawn_first_frame_us: u64, + startup_shell_ready_us: u64, + open_visible_us: u64, + open_repaint_us: ?u64, + edit_us: u64, + delete_line_us: u64, + undo_us: u64, + move_first_us: u64, + move_done_us: u64, + move_active_us: u64, + move_top_line: usize, +}; + +const StartupResult = struct { + internal_first_frame_us: u64, + harness_first_frame_us: u64, + spawn_first_frame_us: u64, +}; + +const BestOps = struct { + open_visible_us: u64 = std.math.maxInt(u64), + edit_us: u64 = std.math.maxInt(u64), + delete_line_us: u64 = std.math.maxInt(u64), + undo_us: u64 = std.math.maxInt(u64), + + fn add(self: *BestOps, result: BenchResult) void { + self.open_visible_us = @min(self.open_visible_us, result.open_visible_us); + self.edit_us = @min(self.edit_us, result.edit_us); + self.delete_line_us = @min(self.delete_line_us, result.delete_line_us); + self.undo_us = @min(self.undo_us, result.undo_us); + } +}; + +const StartupStats = struct { + best_us: u64 = std.math.maxInt(u64), + worst_us: u64 = 0, + total_us: u64 = 0, + count: usize = 0, + + fn add(self: *StartupStats, us: u64) void { + self.best_us = @min(self.best_us, us); + self.worst_us = @max(self.worst_us, us); + self.total_us += us; + self.count += 1; + } + + fn avg(self: StartupStats) u64 { + if (self.count == 0) return 0; + return self.total_us / self.count; + } +}; + +fn runFixture(gpa: std.mem.Allocator, exe: [*:0]const u8, fixture: Fixture, movement: Movement) !BenchResult { + const startup_spawn_t0 = nowNs(); + var hs = try Harness.init(gpa, exe, 30, 100); + defer hs.deinit(); + const startup_app_t0 = nowNs(); + + if (!try waitForRawContainsPoll(&hs, "Kill Newcol", 8000, 1)) { + hs.dump("app first frame did not render before syntax perf"); + return error.StartupFirstFrameTimeout; + } + const startup_app_first_frame_us = (nowNs() - startup_app_t0) / 1000; + const startup_spawn_first_frame_us = (nowNs() - startup_spawn_t0) / 1000; + try hs.expectWaitFor("tests.zig", 8000, "app never auto-ls'd before syntax perf"); + const startup_shell_ready_us = (nowNs() - startup_spawn_t0) / 1000; + try hs.send("\x02"); // normal -> tty + try hs.pump(500); + { + var cmd_buf: [256]u8 = undefined; + const cmd = try std.fmt.bufPrint(&cmd_buf, "clear; echo {s}\r", .{fixture.path}); + try hs.send(cmd); + } + try hs.expectWaitFor(fixture.path, 8000, "perf path did not render in tty"); + try hs.send("\x02"); // tty -> normal + try hs.expectWaitFor("nm /", 6000, "failed to leave tty before syntax perf open"); + + const open_t0 = nowNs(); + try hs.send("\x1b[<2;8;3M\x1b[<2;8;3m"); // right-click body row 0 path + try hs.expectWaitFor(fixture.open_marker, marker_wait_ms, "syntax perf file did not open"); + const open_visible_us = (nowNs() - open_t0) / 1000; + var open_repaint_us: ?u64 = null; + if (fixture.highlighted) { + open_repaint_us = open_visible_us; + } + if (!try waitForOutputQuiet(&hs, 250, marker_wait_ms)) { + hs.dump("syntax perf open did not go quiet"); + return error.OpenQuietTimeout; + } + + try hs.send("i"); + try hs.expectWaitFor("in /tmp/pardes_perf_", 5000, "syntax perf did not enter file insert mode"); + + var payload: [payload_len]u8 = undefined; + const edit_marker = fillPayload(&payload, fixture.edit_marker); + const edit_t0 = nowNs(); + try hs.send(&payload); + try hs.expectWaitFor(edit_marker, marker_wait_ms, "syntax perf edit marker did not appear"); + const edit_us = (nowNs() - edit_t0) / 1000; + + try hs.send("\x1b"); // insert -> normal + try hs.expectWaitFor("nm /tmp/pardes_perf_", 5000, "syntax perf did not leave insert mode"); + if (!try waitForOutputQuiet(&hs, 250, marker_wait_ms)) { + hs.dump("syntax perf edit repaint did not go quiet"); + return error.EditRepaintQuietTimeout; + } + + const delete_t0 = nowNs(); + try hs.send(delete_line_input); + if (!try waitForScreenMissing(&hs, edit_marker, marker_wait_ms)) { + hs.dump("syntax perf line delete marker did not disappear"); + return error.DeleteLineTimeout; + } + const delete_line_us = (nowNs() - delete_t0) / 1000; + if (!try waitForOutputQuiet(&hs, 250, marker_wait_ms)) { + hs.dump("syntax perf line delete repaint did not go quiet"); + return error.DeleteLineQuietTimeout; + } + + const undo_t0 = nowNs(); + try hs.send("u"); + try hs.expectWaitFor(edit_marker, marker_wait_ms, "syntax perf undo did not restore edit marker"); + const undo_us = (nowNs() - undo_t0) / 1000; + if (!try waitForOutputQuiet(&hs, 250, marker_wait_ms)) { + hs.dump("syntax perf undo repaint did not go quiet"); + return error.UndoQuietTimeout; + } + + const move_input = try movementInput(gpa, movement); + defer gpa.free(move_input); + + const start_top_line = @max(try leftPaneTopLine(&hs), 1); + const move_t0 = nowNs(); + try hs.send(move_input); + if (try waitForTopLineAbove(&hs, start_top_line, marker_wait_ms)) |_| { + // Progress observed; keep draining below until the movement settles. + } else { + hs.dump("syntax perf movement did not move the visible file window"); + return error.MovementDidNotMove; + } + const move_first_us = (nowNs() - move_t0) / 1000; + if (!try waitForOutputQuiet(&hs, scroll_quiet_ms, marker_wait_ms)) { + hs.dump("syntax perf movement did not go quiet"); + return error.MovementQuietTimeout; + } + const move_done_us = (nowNs() - move_t0) / 1000; + const move_top_line = try leftPaneTopLine(&hs); + + return .{ + .startup_app_first_frame_us = startup_app_first_frame_us, + .startup_spawn_first_frame_us = startup_spawn_first_frame_us, + .startup_shell_ready_us = startup_shell_ready_us, + .open_visible_us = open_visible_us, + .open_repaint_us = open_repaint_us, + .edit_us = edit_us, + .delete_line_us = delete_line_us, + .undo_us = undo_us, + .move_first_us = move_first_us, + .move_done_us = move_done_us, + .move_active_us = move_done_us -| (@as(u64, scroll_quiet_ms) * 1000), + .move_top_line = move_top_line, + }; +} + +fn runStartup(gpa: std.mem.Allocator, exe: [*:0]const u8) !StartupResult { + const startup_spawn_t0 = nowNs(); + var hs = try Harness.initArgs(gpa, exe, 30, 100, "--perf-startup"); + defer hs.deinit(); + const startup_app_t0 = nowNs(); + + const internal_first_frame_us = (try waitForStartupMetric(&hs, 8000, 1)) orelse { + hs.dump("app first frame did not render before startup perf"); + return error.StartupFirstFrameTimeout; + }; + if (!try waitForRawContainsPoll(&hs, "Kill Newcol", 8000, 1)) { + hs.dump("app first frame marker rendered without topbar text"); + return error.StartupFirstFrameTimeout; + } + return .{ + .internal_first_frame_us = internal_first_frame_us, + .harness_first_frame_us = (nowNs() - startup_app_t0) / 1000, + .spawn_first_frame_us = (nowNs() - startup_spawn_t0) / 1000, + }; +} + +fn printResult(fixture: Fixture, movement: Movement, result: BenchResult) void { + std.debug.print( + "case={s} movement={s} highlight={d} bytes={d} lines={d} startup_app_first_frame_us={d} startup_spawn_first_frame_us={d} startup_shell_ready_us={d} open_visible_us={d} open_repaint_us={d} edit_us={d} edit_us_per_char={d} delete_line_us={d} undo_us={d} move_first_us={d} move_done_us={d} move_active_us={d} move_top_line={d}\n", + .{ + fixture.name, + movementName(movement), + @intFromBool(fixture.highlighted), + fixture.bytes, + fixture.lines, + result.startup_app_first_frame_us, + result.startup_spawn_first_frame_us, + result.startup_shell_ready_us, + result.open_visible_us, + result.open_repaint_us orelse 0, + result.edit_us, + result.edit_us / payload_len, + result.delete_line_us, + result.undo_us, + result.move_first_us, + result.move_done_us, + result.move_active_us, + result.move_top_line, + }, + ); +} + +fn ratioX100(highlight_us: u64, plain_us: u64) u64 { + if (plain_us == 0) return 0; + return (highlight_us * 100 + plain_us / 2) / plain_us; +} + +fn movementRatioX100(highlight_us: u64, plain_us: u64) u64 { + return ratioX100(highlight_us, @max(plain_us, movement_ratio_floor_us)); +} + +fn printRatioSummary(movement: Movement, small_txt: BenchResult, small_zig: BenchResult, large_txt: BenchResult, large_zig: BenchResult) void { + std.debug.print( + "ratio movement={s} small_move_active_x100={d} large_move_active_x100={d} target_x100={d} small_open_visible_x100={d} large_open_visible_x100={d} small_edit_x100={d} large_edit_x100={d} small_delete_line_x100={d} large_delete_line_x100={d} small_undo_x100={d} large_undo_x100={d}\n", + .{ + movementName(movement), + movementRatioX100(small_zig.move_active_us, small_txt.move_active_us), + movementRatioX100(large_zig.move_active_us, large_txt.move_active_us), + target_ratio_x100, + ratioX100(small_zig.open_visible_us, small_txt.open_visible_us), + ratioX100(large_zig.open_visible_us, large_txt.open_visible_us), + ratioX100(small_zig.edit_us, small_txt.edit_us), + ratioX100(large_zig.edit_us, large_txt.edit_us), + ratioX100(small_zig.delete_line_us, small_txt.delete_line_us), + ratioX100(large_zig.delete_line_us, large_txt.delete_line_us), + ratioX100(small_zig.undo_us, small_txt.undo_us), + ratioX100(large_zig.undo_us, large_txt.undo_us), + }, + ); +} + +fn checkMovementRatio(movement: Movement, size_name: []const u8, highlighted_us: u64, plain_us: u64) !void { + const ratio = movementRatioX100(highlighted_us, plain_us); + if (ratio > target_ratio_x100) { + std.debug.print( + "FAIL movement={s} size={s} move_active_x100={d} target_x100={d} highlighted_us={d} plain_us={d}\n", + .{ movementName(movement), size_name, ratio, target_ratio_x100, highlighted_us, plain_us }, + ); + return error.HighlightMovementPerfRegression; + } +} + +fn checkMovementRatios(movement: Movement, small_txt: BenchResult, small_zig: BenchResult, large_txt: BenchResult, large_zig: BenchResult) !void { + try checkMovementRatio(movement, "small", small_zig.move_active_us, small_txt.move_active_us); + try checkMovementRatio(movement, "large", large_zig.move_active_us, large_txt.move_active_us); +} + +fn printBestOpsRatioSummary(best: [4]BestOps) void { + std.debug.print( + "ratio aggregate=best_of_movements target_x100={d} small_open_visible_x100={d} large_open_visible_x100={d} small_edit_x100={d} large_edit_x100={d} small_delete_line_x100={d} large_delete_line_x100={d} small_undo_x100={d} large_undo_x100={d}\n", + .{ + target_ratio_x100, + ratioX100(best[1].open_visible_us, best[0].open_visible_us), + ratioX100(best[3].open_visible_us, best[2].open_visible_us), + ratioX100(best[1].edit_us, best[0].edit_us), + ratioX100(best[3].edit_us, best[2].edit_us), + ratioX100(best[1].delete_line_us, best[0].delete_line_us), + ratioX100(best[3].delete_line_us, best[2].delete_line_us), + ratioX100(best[1].undo_us, best[0].undo_us), + ratioX100(best[3].undo_us, best[2].undo_us), + }, + ); +} + +fn printStartupSummary(name: []const u8, target_us: ?u64, stats: StartupStats) void { + if (target_us) |target| { + std.debug.print( + "startup summary metric={s} target_us={d} samples={d} best_us={d} avg_us={d} worst_us={d}\n", + .{ name, target, stats.count, stats.best_us, stats.avg(), stats.worst_us }, + ); + return; + } + std.debug.print( + "startup summary metric={s} samples={d} best_us={d} avg_us={d} worst_us={d}\n", + .{ name, stats.count, stats.best_us, stats.avg(), stats.worst_us }, + ); +} + +fn checkStartupAverage(name: []const u8, target_us: u64, stats: StartupStats) !void { + const avg_us = stats.avg(); + if (avg_us <= target_us) return; + std.debug.print( + "FAIL startup metric={s} avg_us={d} target_us={d} samples={d} best_us={d} worst_us={d}\n", + .{ name, avg_us, target_us, stats.count, stats.best_us, stats.worst_us }, + ); + return error.StartupPerfRegression; +} + +pub fn main(init: std.process.Init) !void { + const gpa = init.gpa; + const args = try init.minimal.args.toSlice(init.arena.allocator()); + if (args.len != 2) { + std.debug.print("usage: {s} <pardes-exe>\n", .{args[0]}); + return error.BadArgs; + } + + const small_txt_path = "/tmp/pardes_perf_small_plain.txt"; + const small_zig_path = "/tmp/pardes_perf_small_code.zig"; + const large_txt_path = "/tmp/pardes_perf_large_plain.txt"; + const large_zig_path = "/tmp/pardes_perf_large_code.zig"; + + const stdlib_content = try readFileAlloc(gpa, large_stdlib_path); + defer gpa.free(stdlib_content); + const small_txt_content = try makeSmallFixture(gpa, "SMALLTXTOPENPERFEND", "SMALLTXTSCROLLPERFEND", false); + defer gpa.free(small_txt_content); + const small_zig_content = try makeSmallFixture(gpa, "SMALLZIGOPENPERFEND", "SMALLZIGSCROLLPERFEND", true); + defer gpa.free(small_zig_content); + const large_txt_content = try makeStdlibFixture(gpa, stdlib_content, "LARGETXTOPENPERFEND", "LARGETXTSCROLLPERFEND", false); + defer gpa.free(large_txt_content); + const large_zig_content = try makeStdlibFixture(gpa, stdlib_content, "LARGEZIGOPENPERFEND", "LARGEZIGSCROLLPERFEND", true); + defer gpa.free(large_zig_content); + + try h.writeFile(small_txt_path, small_txt_content); + try h.writeFile(small_zig_path, small_zig_content); + try h.writeFile(large_txt_path, large_txt_content); + try h.writeFile(large_zig_path, large_zig_content); + + const fixtures = [_]Fixture{ + .{ + .name = "small_txt", + .path = small_txt_path, + .open_marker = "SMALLTXTOPENPERFEND", + .edit_marker = "SMALLTXTEDITPERFEND", + .scroll_marker = "SMALLTXTSCROLLPERFEND", + .highlighted = false, + .bytes = small_txt_content.len, + .lines = lineCount(small_txt_content), + }, + .{ + .name = "small_zig", + .path = small_zig_path, + .open_marker = "SMALLZIGOPENPERFEND", + .edit_marker = "SMALLZIGEDITPERFEND", + .scroll_marker = "SMALLZIGSCROLLPERFEND", + .highlighted = true, + .bytes = small_zig_content.len, + .lines = lineCount(small_zig_content), + }, + .{ + .name = "large_txt", + .path = large_txt_path, + .open_marker = "LARGETXTOPENPERFEND", + .edit_marker = "LARGETXTEDITPERFEND", + .scroll_marker = "LARGETXTSCROLLPERFEND", + .highlighted = false, + .bytes = large_txt_content.len, + .lines = lineCount(large_txt_content), + }, + .{ + .name = "large_zig", + .path = large_zig_path, + .open_marker = "LARGEZIGOPENPERFEND", + .edit_marker = "LARGEZIGEDITPERFEND", + .scroll_marker = "LARGEZIGSCROLLPERFEND", + .highlighted = true, + .bytes = large_zig_content.len, + .lines = lineCount(large_zig_content), + }, + }; + + std.debug.print( + "syntax-perf backend=vaxis chars_per_edit={d} delete_select_lines={d} wheel_events={d} j_events={d} ctrl_d_events={d} scroll_quiet_ms={d} scroll_marker_line={d} large_stdlib={s}\n", + .{ payload_len, delete_select_lines, wheel_events, j_events, ctrl_d_events, scroll_quiet_ms, scroll_marker_line, large_stdlib_path }, + ); + var startup_only_internal_stats: StartupStats = .{}; + var startup_only_harness_stats: StartupStats = .{}; + var startup_only_spawn_stats: StartupStats = .{}; + for (0..startup_samples) |sample| { + const startup = try runStartup(gpa, args[1].ptr); + startup_only_internal_stats.add(startup.internal_first_frame_us); + startup_only_harness_stats.add(startup.harness_first_frame_us); + startup_only_spawn_stats.add(startup.spawn_first_frame_us); + std.debug.print( + "startup_sample={d} internal_first_frame_us={d} harness_first_frame_us={d} spawn_first_frame_us={d}\n", + .{ sample, startup.internal_first_frame_us, startup.harness_first_frame_us, startup.spawn_first_frame_us }, + ); + } + printStartupSummary("startup_only_internal_first_frame", null, startup_only_internal_stats); + printStartupSummary("startup_only_harness_first_frame", startup_first_frame_target_us, startup_only_harness_stats); + printStartupSummary("startup_only_spawn_first_frame", null, startup_only_spawn_stats); + try checkStartupAverage("startup_only_harness_first_frame", startup_first_frame_target_us, startup_only_harness_stats); + + const movements = [_]Movement{ .wheel, .j, .ctrl_d }; + var best_ops: [4]BestOps = .{ .{}, .{}, .{}, .{} }; + var startup_app_first_frame_stats: StartupStats = .{}; + var startup_spawn_first_frame_stats: StartupStats = .{}; + var startup_shell_ready_stats: StartupStats = .{}; + for (movements) |movement| { + const small_txt = try runFixture(gpa, args[1].ptr, fixtures[0], movement); + startup_app_first_frame_stats.add(small_txt.startup_app_first_frame_us); + startup_spawn_first_frame_stats.add(small_txt.startup_spawn_first_frame_us); + startup_shell_ready_stats.add(small_txt.startup_shell_ready_us); + best_ops[0].add(small_txt); + printResult(fixtures[0], movement, small_txt); + const small_zig = try runFixture(gpa, args[1].ptr, fixtures[1], movement); + startup_app_first_frame_stats.add(small_zig.startup_app_first_frame_us); + startup_spawn_first_frame_stats.add(small_zig.startup_spawn_first_frame_us); + startup_shell_ready_stats.add(small_zig.startup_shell_ready_us); + best_ops[1].add(small_zig); + printResult(fixtures[1], movement, small_zig); + const large_txt = try runFixture(gpa, args[1].ptr, fixtures[2], movement); + startup_app_first_frame_stats.add(large_txt.startup_app_first_frame_us); + startup_spawn_first_frame_stats.add(large_txt.startup_spawn_first_frame_us); + startup_shell_ready_stats.add(large_txt.startup_shell_ready_us); + best_ops[2].add(large_txt); + printResult(fixtures[2], movement, large_txt); + const large_zig = try runFixture(gpa, args[1].ptr, fixtures[3], movement); + startup_app_first_frame_stats.add(large_zig.startup_app_first_frame_us); + startup_spawn_first_frame_stats.add(large_zig.startup_spawn_first_frame_us); + startup_shell_ready_stats.add(large_zig.startup_shell_ready_us); + best_ops[3].add(large_zig); + printResult(fixtures[3], movement, large_zig); + printRatioSummary(movement, small_txt, small_zig, large_txt, large_zig); + try checkMovementRatios(movement, small_txt, small_zig, large_txt, large_zig); + } + printBestOpsRatioSummary(best_ops); + printStartupSummary("app_first_frame", null, startup_app_first_frame_stats); + printStartupSummary("spawn_first_frame", null, startup_spawn_first_frame_stats); + printStartupSummary("shell_ready", null, startup_shell_ready_stats); +} |