wehub-resource-sync
206 lines
8.1 KiB
Zig
206 lines
8.1 KiB
Zig
//! Gate harness: drives the inbox app core through a scalar C ABI and
|
|
//! measures correctness, determinism, and keystroke-path latency. The run1k
|
|
//! mode writes the snapshot+effect log whose digest is the transpiler gate.
|
|
//!
|
|
//! Modes:
|
|
//! smoke — fixed short sequence, print snapshot hex (cross-impl oracle)
|
|
//! run1k <out-file> — deterministic 1k-message sequence; write snapshot+effect log
|
|
//! bench10k — 10k keystroke-path dispatches; latency stats (ns)
|
|
|
|
const std = @import("std");
|
|
const impl = @import("impl");
|
|
|
|
fn snapshotHex(alloc: std.mem.Allocator) ![]u8 {
|
|
const len: usize = @intFromFloat(impl.snapshot());
|
|
const hex = try alloc.alloc(u8, len * 2);
|
|
const digits = "0123456789abcdef";
|
|
for (0..len) |i| {
|
|
const b: u8 = @intFromFloat(impl.snapshotByte(@floatFromInt(i)));
|
|
hex[i * 2] = digits[b >> 4];
|
|
hex[i * 2 + 1] = digits[b & 0xf];
|
|
}
|
|
return hex;
|
|
}
|
|
|
|
fn smoke(alloc: std.mem.Allocator) !void {
|
|
impl.reset();
|
|
impl.pushText(104);
|
|
impl.pushText(105);
|
|
_ = impl.dispatch(4, 0, 0, 0, 0, 0);
|
|
_ = impl.dispatch(0, 0, 0, 0, 0, 0);
|
|
_ = impl.dispatch(1, 4, 0, 0, 0, 0);
|
|
_ = impl.dispatch(2, 1, 0, 0, 0, 0);
|
|
_ = impl.dispatch(5, 0, 0, 0, 0, 28.5);
|
|
const hex = try snapshotHex(alloc);
|
|
std.debug.print("smoke snapshot {s}\n", .{hex});
|
|
std.debug.print("smoke effects {d}\n", .{@as(u64, @intFromFloat(impl.effectLen()))});
|
|
}
|
|
|
|
const SplitMix = struct {
|
|
state: u64,
|
|
fn next(self: *SplitMix) u64 {
|
|
self.state +%= 0x9e3779b97f4a7c15;
|
|
var z = self.state;
|
|
z = (z ^ (z >> 30)) *% 0xbf58476d1ce4e5b9;
|
|
z = (z ^ (z >> 27)) *% 0x94d049bb133111eb;
|
|
return z ^ (z >> 31);
|
|
}
|
|
fn below(self: *SplitMix, n: u64) u64 {
|
|
return self.next() % n;
|
|
}
|
|
};
|
|
|
|
// One deterministic pseudo-random message; exercises every Msg arm,
|
|
// including multi-byte UTF-8 inserts, compositions, invalid toggle ids,
|
|
// and fractional chrome insets.
|
|
fn sendRandomMsg(rng: *SplitMix) void {
|
|
const roll = rng.below(100);
|
|
if (roll < 45) {
|
|
// draft edits dominate, like real typing
|
|
const edit = rng.below(11);
|
|
switch (edit) {
|
|
0, 1, 2, 3 => { // insert 1-3 chars, sometimes multi-byte UTF-8
|
|
const n = 1 + rng.below(3);
|
|
for (0..n) |_| {
|
|
if (rng.below(8) == 0) {
|
|
// U+00E9 é = 0xC3 0xA9
|
|
impl.pushText(0xc3);
|
|
impl.pushText(0xa9);
|
|
} else {
|
|
impl.pushText(@floatFromInt(0x61 + rng.below(26)));
|
|
}
|
|
}
|
|
_ = impl.dispatch(4, 0, 0, 0, 0, 0);
|
|
},
|
|
4 => _ = impl.dispatch(4, 1, 0, 0, 0, 0), // delete_backward
|
|
5 => _ = impl.dispatch(4, 2, 0, 0, 0, 0), // delete_forward
|
|
6 => _ = impl.dispatch(4, @floatFromInt(3 + rng.below(2)), 0, 0, 0, 0), // word deletes
|
|
7 => _ = impl.dispatch(4, 6, @floatFromInt(rng.below(6)), @floatFromInt(rng.below(2)), 0, 0), // move_caret
|
|
8 => _ = impl.dispatch(4, 7, @floatFromInt(rng.below(40)), @floatFromInt(rng.below(40)), 0, 0), // set_selection
|
|
9 => { // set_composition then commit or cancel
|
|
const n = rng.below(4);
|
|
for (0..n) |_| impl.pushText(@floatFromInt(0x61 + rng.below(26)));
|
|
const cursor: f64 = if (rng.below(2) == 0) -1 else @floatFromInt(rng.below(5));
|
|
_ = impl.dispatch(4, 8, cursor, 0, 0, 0);
|
|
_ = impl.dispatch(4, if (rng.below(2) == 0) 9 else 10, 0, 0, 0, 0);
|
|
},
|
|
else => _ = impl.dispatch(4, 5, 0, 0, 0, 0), // clear
|
|
}
|
|
} else if (roll < 65) {
|
|
_ = impl.dispatch(0, 0, 0, 0, 0, 0); // add
|
|
} else if (roll < 80) {
|
|
_ = impl.dispatch(1, @floatFromInt(rng.below(80)), 0, 0, 0, 0); // toggle (some ids invalid)
|
|
} else if (roll < 88) {
|
|
_ = impl.dispatch(2, @floatFromInt(rng.below(3)), 0, 0, 0, 0); // set_filter
|
|
} else if (roll < 94) {
|
|
_ = impl.dispatch(3, 0, 0, 0, 0, 0); // clear_done
|
|
} else {
|
|
// chrome_changed with fractional insets
|
|
const left: f64 = @as(f64, @floatFromInt(rng.below(120))) * 0.5;
|
|
const top: f64 = @as(f64, @floatFromInt(rng.below(160))) * 0.5;
|
|
_ = impl.dispatch(5, 0, 0, 0, left, top);
|
|
}
|
|
}
|
|
|
|
fn run1k(alloc: std.mem.Allocator, io: std.Io, out_path: []const u8) !void {
|
|
impl.reset();
|
|
var rng = SplitMix{ .state = 0x5eed_ba5e_0000_1234 };
|
|
for (0..1000) |_| sendRandomMsg(&rng);
|
|
|
|
var out: std.ArrayList(u8) = .empty;
|
|
defer out.deinit(alloc);
|
|
const hex = try snapshotHex(alloc);
|
|
try out.appendSlice(alloc, "snapshot ");
|
|
try out.appendSlice(alloc, hex);
|
|
try out.appendSlice(alloc, "\neffects ");
|
|
const eff_len: usize = @intFromFloat(impl.effectLen());
|
|
const digits = "0123456789abcdef";
|
|
for (0..eff_len) |i| {
|
|
const b: u8 = @intFromFloat(impl.effectByte(@floatFromInt(i)));
|
|
try out.append(alloc, digits[b >> 4]);
|
|
try out.append(alloc, digits[b & 0xf]);
|
|
}
|
|
try out.appendSlice(alloc, "\n");
|
|
try std.Io.Dir.cwd().writeFile(io, .{ .sub_path = out_path, .data = out.items });
|
|
std.debug.print("run1k wrote {s} ({d} bytes, {d} effect bytes)\n", .{ out_path, out.items.len, eff_len });
|
|
}
|
|
|
|
// Raw monotonic nanoseconds (darwin). ~41ns granularity on Apple Silicon.
|
|
extern "c" fn clock_gettime_nsec_np(clock_id: c_int) u64;
|
|
const CLOCK_UPTIME_RAW: c_int = 8;
|
|
inline fn nowNs() u64 {
|
|
return clock_gettime_nsec_np(CLOCK_UPTIME_RAW);
|
|
}
|
|
|
|
fn bench10k(alloc: std.mem.Allocator) !void {
|
|
impl.reset();
|
|
var rng = SplitMix{ .state = 0xdead_beef_cafe_f00d };
|
|
const iters = 10_000;
|
|
const samples = try alloc.alloc(u64, iters);
|
|
|
|
const bench_start = nowNs();
|
|
for (0..iters) |i| {
|
|
// Keystroke-shaped mix: mostly single-char inserts.
|
|
const roll = rng.below(1000);
|
|
const t0 = nowNs();
|
|
if (roll < 700) {
|
|
impl.pushText(@floatFromInt(0x61 + rng.below(26)));
|
|
_ = impl.dispatch(4, 0, 0, 0, 0, 0);
|
|
} else if (roll < 800) {
|
|
_ = impl.dispatch(4, 1, 0, 0, 0, 0); // backspace
|
|
} else if (roll < 870) {
|
|
_ = impl.dispatch(4, 6, @floatFromInt(rng.below(6)), 0, 0, 0); // caret move
|
|
} else if (roll < 920) {
|
|
_ = impl.dispatch(0, 0, 0, 0, 0, 0); // add (submit)
|
|
} else if (roll < 970) {
|
|
_ = impl.dispatch(1, @floatFromInt(rng.below(80)), 0, 0, 0, 0); // toggle
|
|
} else if (roll < 990) {
|
|
_ = impl.dispatch(2, @floatFromInt(rng.below(3)), 0, 0, 0, 0); // filter
|
|
} else {
|
|
_ = impl.dispatch(3, 0, 0, 0, 0, 0); // clear_done
|
|
}
|
|
samples[i] = nowNs() - t0;
|
|
}
|
|
const wall_total = nowNs() - bench_start;
|
|
|
|
std.mem.sort(u64, samples, {}, std.sort.asc(u64));
|
|
var total: u64 = 0;
|
|
for (samples) |s| total += s;
|
|
std.debug.print("bench10k wall total ns: {d} (mean/dispatch incl. harness: {d})\n", .{ wall_total, wall_total / iters });
|
|
std.debug.print(
|
|
"bench10k ns: min={d} p50={d} p90={d} p99={d} p999={d} max={d} mean={d}\n",
|
|
.{
|
|
samples[0],
|
|
samples[iters / 2],
|
|
samples[(iters * 90) / 100],
|
|
samples[(iters * 99) / 100],
|
|
samples[(iters * 999) / 1000],
|
|
samples[iters - 1],
|
|
total / iters,
|
|
},
|
|
);
|
|
// Top 5 outliers for GC-pause inspection.
|
|
std.debug.print("bench10k top5: {d} {d} {d} {d} {d}\n", .{
|
|
samples[iters - 1], samples[iters - 2], samples[iters - 3],
|
|
samples[iters - 4], samples[iters - 5],
|
|
});
|
|
}
|
|
|
|
pub fn main(init: std.process.Init) !void {
|
|
const alloc = init.arena.allocator();
|
|
impl.init();
|
|
|
|
const argv = init.minimal.args.vector;
|
|
const mode: []const u8 = if (argv.len > 1) std.mem.span(argv[1]) else "smoke";
|
|
|
|
if (std.mem.eql(u8, mode, "smoke")) {
|
|
try smoke(alloc);
|
|
} else if (std.mem.eql(u8, mode, "run1k")) {
|
|
try run1k(alloc, init.io, std.mem.span(argv[2]));
|
|
} else if (std.mem.eql(u8, mode, "bench10k")) {
|
|
try bench10k(alloc);
|
|
} else {
|
|
std.debug.print("unknown mode {s}\n", .{mode});
|
|
}
|
|
}
|