summaryrefslogtreecommitdiff
path: root/bench/store.zig
diff options
context:
space:
mode:
Diffstat (limited to 'bench/store.zig')
-rw-r--r--bench/store.zig82
1 files changed, 82 insertions, 0 deletions
diff --git a/bench/store.zig b/bench/store.zig
new file mode 100644
index 0000000..a3d5e9a
--- /dev/null
+++ b/bench/store.zig
@@ -0,0 +1,82 @@
+//! 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(&regs));
+}
+
+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 });
+ }
+}