//! What a recording costs: bytes and time a moment, for the shapes of work //! the backends produce. `zig build bench-store`. const std = @import("std"); const zt = @import("ztrace"); const moments = 100_000; const Case = struct { name: []const u8, /// Emits one moment's events, ending with the one that cuts it. run: *const fn (rec: *zt.Recorder, i: u64) anyerror!void, }; fn step(rec: *zt.Recorder, i: u64) !void { const regs: zt.Regs = .{ .rip = 0x401000 + i % 512, .rsp = 0x7ffd_0000_1000 - 8 * (i % 64), .rax = i }; try rec.emit(.{ .kind = .step, .tid = 1, .a = .{ regs.rip, 0, 0, 0, 0, 0 } }, std.mem.asBytes(®s)); } fn mark(rec: *zt.Recorder, i: u64) !void { try rec.emit(.{ .kind = .mark, .tid = 1, .a = .{ i, 0, 0, 0, 0, 0 } }, ""); } fn write(rec: *zt.Recorder, addr: u64, bytes: []const u8) !void { try rec.emit(.{ .kind = .mem_write, .tid = 1, .a = .{ addr, bytes.len, 0, 0, 0, 0 } }, bytes); } const cases = [_]Case{ .{ .name = "a mark", .run = mark }, .{ .name = "a step with registers", .run = step }, .{ .name = "... and a word pushed on the stack", .run = struct { fn run(rec: *zt.Recorder, i: u64) !void { try write(rec, 0x7ffd_0000_1000 - 8 * (i % 64), std.mem.asBytes(&i)); try step(rec, i); } }.run }, .{ .name = "a word written somewhere in 1 MiB of heap", .run = struct { fn run(rec: *zt.Recorder, i: u64) !void { try write(rec, 0x5555_0000_0000 + (i *% 0x9e3779b97f4a7c15 >> 44) * 8, std.mem.asBytes(&i)); try mark(rec, i); } }.run }, .{ .name = "4 KiB of zeros written (a calloc, a fresh page)", .run = struct { fn run(rec: *zt.Recorder, i: u64) !void { const zeros: [4096]u8 = @splat(0); try write(rec, 0x5555_0000_0000 + (i % 256) * 4096, &zeros); try mark(rec, i); } }.run }, .{ .name = "4 KiB of the same text written (a buffer filled again)", .run = struct { fn run(rec: *zt.Recorder, i: u64) !void { var text: [4096]u8 = undefined; for (&text, 0..) |*c, at| c.* = "the quick brown fox "[at % 20]; try write(rec, 0x5555_0000_0000 + (i % 256) * 4096, &text); try mark(rec, i); } }.run }, .{ .name = "4 KiB of new bytes written (a read from a file)", .run = struct { fn run(rec: *zt.Recorder, i: u64) !void { var bytes: [4096]u8 = undefined; var rng: std.Random.DefaultPrng = .init(i); rng.random().bytes(&bytes); try write(rec, 0x5555_0000_0000 + (i % 256) * 4096, &bytes); try mark(rec, i); } }.run }, }; pub fn main(init: std.process.Init) !void { const path = "bench-store.ztrace"; defer std.Io.Dir.cwd().deleteFile(init.io, path) catch {}; std.debug.print("{s:<56} {s:>12} {s:>12}\n", .{ "each moment", "bytes", "ns" }); for (cases) |case| { var rec = try zt.Recorder.create(init.gpa, init.io, path); const n: u64 = if (std.mem.startsWith(u8, case.name, "4 KiB")) moments / 10 else moments; const start = zt.event.now(); for (0..n) |i| try case.run(&rec, i); try rec.close(); const ns = zt.event.now() - start; const size = (try std.Io.Dir.cwd().statFile(init.io, path, .{})).size; std.debug.print("{s:<56} {d:>12} {d:>12}\n", .{ case.name, size / n, ns / n }); } }