summaryrefslogtreecommitdiff
diff options
context:
space:
mode:
authorGabriel Schneider <[email protected]>2026-11-10 11:20:34 -0300
committerGabriel Schneider <[email protected]>2026-11-10 11:20:34 -0300
commit7f1adc581deba868f5ad04b55e34027ae70f899e (patch)
tree330d72d4ba2b69c45341918755bec3abb92235fe
parent8d91ecf978b99a79e3ff237cda14daa3d666509f (diff)
downloadcomputeranim-7f1adc581deba868f5ad04b55e34027ae70f899e.tar.gz
computeranim-7f1adc581deba868f5ad04b55e34027ae70f899e.zip
ztrace show: a recording's summary, and the program's state at a moment
-rw-r--r--src/cli/main.zig2
-rw-r--r--src/cli/show.zig102
2 files changed, 104 insertions, 0 deletions
diff --git a/src/cli/main.zig b/src/cli/main.zig
index 498f8d4..3abea6e 100644
--- a/src/cli/main.zig
+++ b/src/cli/main.zig
@@ -7,6 +7,7 @@ const commands = .{
.record = @import("record.zig"),
.run = @import("run.zig"),
.dump = @import("dump.zig"),
+ .show = @import("show.zig"),
};
const usage =
@@ -15,6 +16,7 @@ const usage =
\\ record run a program under ptrace into a recording
\\ run record a program that carries a ring producer (agent, instrumentation)
\\ dump print a recording's events
+ \\ show print a recording's summary, or the program's state at a moment
\\
\\`ztrace COMMAND --help` for each.
\\
diff --git a/src/cli/show.zig b/src/cli/show.zig
new file mode 100644
index 0000000..ce8dec4
--- /dev/null
+++ b/src/cli/show.zig
@@ -0,0 +1,102 @@
+//! ztrace show: what a recording holds, and the program's state at a moment.
+const std = @import("std");
+const zt = @import("ztrace");
+const util = @import("util.zig");
+
+pub const usage =
+ \\usage: ztrace show FILE [MOMENT]
+ \\
+ \\Without MOMENT: how many moments and events, and events by kind.
+ \\With one (negative counts from the end): each thread's registers, source
+ \\line and open calls, the live heap, the named variables with their
+ \\bytes, and the mapped regions, as of that moment.
+ \\
+;
+
+pub fn run(init: std.process.Init, args: []const [:0]const u8) !void {
+ if (args.len < 1 or args.len > 2) util.fail(usage, .{});
+ var trace = try zt.Trace.open(init.gpa, init.io, args[0]);
+ defer trace.close();
+ var buf: [4096]u8 = undefined;
+ var file_writer = std.Io.File.stdout().writer(init.io, &buf);
+ const w = &file_writer.interface;
+ const result = if (args.len == 1) summary(init.gpa, &trace, w) else blk: {
+ const n = std.fmt.parseInt(i64, args[1], 10) catch util.fail(usage, .{});
+ const index = if (n < 0) @as(i64, @intCast(trace.len)) + n else n;
+ if (index < 0 or index >= trace.len) util.fail("{s}: {d} moments, no moment {d}\n", .{ args[0], trace.len, n });
+ break :blk state(init.arena.allocator(), &trace, @intCast(index), w);
+ };
+ result catch |err| switch (err) {
+ // The reader went away (`| head`): not an error.
+ error.WriteFailed => return,
+ else => |e| return e,
+ };
+ w.flush() catch {};
+}
+
+fn summary(gpa: std.mem.Allocator, trace: *zt.Trace, w: *std.Io.Writer) !void {
+ var by_kind: [64]u64 = @splat(0);
+ var total: u64 = 0;
+ for (0..trace.len) |index| {
+ var events = try (try trace.moment(index)).events(gpa);
+ defer events.deinit(gpa);
+ while (events.next()) |item| : (total += 1) by_kind[@intFromEnum(item.ev.kind) & 63] += 1;
+ }
+ try w.print("{d} moments, {d} events\n", .{ trace.len, total });
+ for (by_kind, 0..) |n, kind| {
+ if (n != 0) try w.print("{d:>10} {t}\n", .{ n, @as(zt.Kind, @enumFromInt(kind)) });
+ }
+}
+
+/// A string id as text, or the id itself when the recording never defined it.
+fn name(m: zt.store.Moment, arena: std.mem.Allocator, id: u64) ![]const u8 {
+ const buf = try arena.alloc(u8, 4096);
+ return (try m.string(id, buf)) orelse std.fmt.allocPrint(arena, "#{x}", .{id});
+}
+
+fn state(arena: std.mem.Allocator, trace: *zt.Trace, index: u64, w: *std.Io.Writer) !void {
+ const m = try trace.moment(index);
+ try w.print("moment {d} of {d}, {d} events so far\n", .{ index, trace.len, try m.count() });
+
+ for (try m.threads(arena)) |tid| {
+ try w.print("\nthread {d}", .{tid});
+ if (try m.line(tid)) |line| try w.print(" {s}:{d}:{d}", .{ try name(m, arena, line.file), line.line, line.column });
+ try w.writeAll("\n");
+ if (try m.regs(tid)) |regs| {
+ inline for (zt.Regs.names, 0..) |reg, i| {
+ try w.print(" {s:<6} {x:0>16}{s}", .{ reg, @field(regs, reg), if (i % 3 == 2) "\n" else "" });
+ }
+ if (zt.Regs.names.len % 3 != 0) try w.writeAll("\n");
+ }
+ for (try m.stack(arena, tid), 0..) |frame, depth| {
+ try w.print(" #{d} {s} from {x} sp {x}\n", .{ depth, try name(m, arena, frame.function), frame.site, frame.sp });
+ }
+ }
+
+ const heap = try m.heap(arena);
+ if (heap.len > 0) try w.print("\nheap: {d} live\n", .{heap.len});
+ for (heap) |a| try w.print(" {x:0>12} {d:>8} bytes, by {x}, event {d}\n", .{ a.ptr, a.size, a.pc, a.born });
+
+ const variables = try m.variables(arena);
+ if (variables.len > 0) try w.writeAll("\nvariables\n");
+ for (variables) |v| {
+ var bytes: [16]u8 = undefined;
+ var known: [16]bool = undefined;
+ const n: usize = @intCast(@min(v.size, bytes.len));
+ try m.read(v.addr, bytes[0..n], known[0..n]);
+ try w.print(" {x:0>12} {s}: {s} =", .{ v.addr, try name(m, arena, v.name), try name(m, arena, v.type) });
+ for (bytes[0..n], known[0..n]) |byte, k| {
+ if (k) try w.print(" {x:0>2}", .{byte}) else try w.writeAll(" ??");
+ }
+ try w.print("{s}\n", .{if (v.size > n) " ..." else ""});
+ }
+
+ const mappings = try m.mappings(arena);
+ if (mappings.len > 0) try w.writeAll("\nmappings\n");
+ for (mappings) |region| {
+ var path: []const u8 = "";
+ var path_buf: [std.Io.Dir.max_path_bytes]u8 = undefined;
+ _ = try m.mapping(region.addr, &path, &path_buf);
+ try w.print(" {x:0>12}-{x:0>12} {s}\n", .{ region.addr, region.addr + region.len, path });
+ }
+}