tiny.profiling.host.dhat

1const std = @import("std");2const capture = @import("capture");3const sys = @import("sys");45const root = @import("root.zig");67pub const tool = "valgrind";8pub const kind = "dhat";9pub const mode = "heap";10const allocator_traffic_unobserved = "allocator_traffic_unobserved";1112pub const Options = struct {};1314pub const Lane = struct {15    capture_path: []const u8,16    out_path: []const u8,17    summary_path: []const u8,18};1920pub fn plan(allocator: std.mem.Allocator, options: Options, workload_root: []const u8) !Lane {21    _ = options;22    return .{23        .capture_path = try std.fs.path.join(allocator, &.{ workload_root, "dhat.capture.txt" }),24        .out_path = try std.fs.path.join(allocator, &.{ workload_root, "dhat.out" }),25        .summary_path = try std.fs.path.join(allocator, &.{ workload_root, "dhat.summary.json" }),26    };27}2829pub fn wrapArgv(allocator: std.mem.Allocator, options: Options, argv: []const []const u8, lane: Lane) ![]const []const u8 {30    _ = options;31    var wrapped: std.ArrayList([]const u8) = .empty;32    try wrapped.appendSlice(allocator, &.{33        tool,34        "--tool=dhat",35        try std.fmt.allocPrint(allocator, "--log-file={s}", .{lane.capture_path}),36        try std.fmt.allocPrint(allocator, "--dhat-out-file={s}", .{lane.out_path}),37    });38    try wrapped.appendSlice(allocator, argv);39    return try wrapped.toOwnedSlice(allocator);40}4142pub fn summarize(43    allocator: std.mem.Allocator,44    lane: Lane,45    exit_code: i64,46    stderr_path: []const u8,47    tool_available: bool,48    max_benchmark_allocated_bytes: ?u64,49) !root.Capture {50    if (!tool_available) return missingTool(lane);51    var summary = capture.dhat.summarizeCaptureFile(52        allocator,53        lane.capture_path,54        lane.out_path,55        mode,56    ) catch |err| switch (err) {57        error.FileNotFound => return try failed(58            allocator,59            lane,60            exit_code,61            stderr_path,62            lane.capture_path,63        ),64        else => |actual| return actual,65    };66    if (contradictsOwnedAllocations(summary, max_benchmark_allocated_bytes)) {67        summary.failure = allocator_traffic_unobserved;68        try capture.dhat.writeSummaryFile(lane.summary_path, summary);69        return unobservedAllocatorTraffic(lane);70    }71    if (!std.mem.eql(u8, summary.state(), "summary_parsed")) {72        return try failed(allocator, lane, exit_code, stderr_path, lane.capture_path);73    }74    try capture.dhat.writeSummaryFile(lane.summary_path, summary);75    return .{76        .kind = kind,77        .tool = tool,78        .capture_path = lane.capture_path,79        .summary_path = lane.summary_path,80        .state = "summary_written",81    };82}8384fn contradictsOwnedAllocations(85    summary: capture.dhat.Summary,86    max_benchmark_allocated_bytes: ?u64,87) bool {88    const owned_bytes = max_benchmark_allocated_bytes orelse return false;89    if (owned_bytes == 0 or summary.failure != null) return false;90    if (!std.mem.eql(u8, summary.mode, mode)) return false;91    return summary.total_allocated.bytes == 0;92}9394fn unobservedAllocatorTraffic(lane: Lane) root.Capture {95    return .{96        .kind = kind,97        .tool = tool,98        .capture_path = lane.capture_path,99        .summary_path = lane.summary_path,100        .state = "evidence_invalid",101        .caveat_kind = allocator_traffic_unobserved,102        .caveat_message = "DHAT reported zero allocations while owned benchmark counters " ++103            "reported allocator traffic",104    };105}106107fn missingTool(lane: Lane) root.Capture {108    return .{109        .kind = kind,110        .tool = tool,111        .capture_path = lane.capture_path,112        .summary_path = lane.summary_path,113        .state = "tool_missing",114        .caveat_kind = "tool_unavailable",115        .caveat_message = "valgrind is not runnable on this host; heap evidence was not captured",116    };117}118119fn failed(120    allocator: std.mem.Allocator,121    lane: Lane,122    exit_code: i64,123    stderr_path: []const u8,124    capture_path: []const u8,125) !root.Capture {126    const row = try capture.caveat.classifyCommandCapture(allocator, .{127        .phase = kind,128        .exit_code = if (exit_code == 0) 1 else exit_code,129        .timed_out = false,130        .capture_path = capture_path,131    }) orelse try capture.caveat.classifyCommandCapture(allocator, .{132        .phase = kind,133        .exit_code = 1,134        .timed_out = false,135        .capture_path = stderr_path,136    }) orelse capture.caveat.classifyCommandText(.{137        .phase = kind,138        .exit_code = exit_code,139        .timed_out = false,140        .capture_path = capture_path,141    }, "");142    return .{143        .kind = kind,144        .tool = tool,145        .capture_path = lane.capture_path,146        .summary_path = lane.summary_path,147        .state = "tool_failed",148        .caveat_kind = row.kind,149        .caveat_message = row.message,150    };151}152153test "profiling dhat wraps direct binaries in valgrind" {154    var arena_state = std.heap.ArenaAllocator.init(std.testing.allocator);155    defer arena_state.deinit();156    const allocator = arena_state.allocator();157    const lane = try plan(allocator, .{}, "zig-out/profiling/run/workloads/w");158    const argv = [_][]const u8{ "zig-out/bin/mprompt-bench", "--workers", "128" };159    const wrapped = try wrapArgv(allocator, .{}, &argv, lane);160    try std.testing.expectEqualStrings("valgrind", wrapped[0]);161    try std.testing.expectEqualStrings("--tool=dhat", wrapped[1]);162    try std.testing.expectEqualStrings("--log-file=zig-out/profiling/run/workloads/w/dhat.capture.txt", wrapped[2]);163    try std.testing.expectEqualStrings("--dhat-out-file=zig-out/profiling/run/workloads/w/dhat.out", wrapped[3]);164    try std.testing.expectEqualStrings("zig-out/bin/mprompt-bench", wrapped[4]);165    try std.testing.expectEqualStrings("--workers", wrapped[wrapped.len - 2]);166}167168test "profiling dhat summarizes a valgrind capture" {169    var tmp = std.testing.tmpDir(.{});170    defer tmp.cleanup();171    var arena_state = std.heap.ArenaAllocator.init(std.testing.allocator);172    defer arena_state.deinit();173    const allocator = arena_state.allocator();174    const dir = try std.fs.path.join(allocator, &.{ ".zig-cache", "tmp", tmp.sub_path[0..] });175    const lane = try plan(allocator, .{}, dir);176    try sys.fs.writeFile(lane.capture_path,177        \\==100== DHAT, a dynamic heap analysis tool178        \\==100== Total:     1,000 bytes in 10 blocks179        \\==100== At t-gmax: 600 bytes in 4 blocks180        \\==100== At t-end:  0 bytes in 0 blocks181        \\==100== Reads:     2,000 bytes182        \\==100== Writes:    1,500 bytes183        \\184    );185    const stderr_path = try std.fs.path.join(allocator, &.{ dir, "stderr.txt" });186    try sys.fs.writeFile(stderr_path, "");187    const row = try summarize(allocator, lane, 0, stderr_path, true, 4_096);188    try std.testing.expectEqualStrings("summary_written", row.state);189    try std.testing.expect(row.caveat_kind == null);190    try std.testing.expect(sys.fs.exists(lane.summary_path));191}192193test "profiling dhat classifies a missing capture" {194    var tmp = std.testing.tmpDir(.{});195    defer tmp.cleanup();196    var arena_state = std.heap.ArenaAllocator.init(std.testing.allocator);197    defer arena_state.deinit();198    const allocator = arena_state.allocator();199    const dir = try std.fs.path.join(allocator, &.{ ".zig-cache", "tmp", tmp.sub_path[0..] });200    const lane = try plan(allocator, .{}, dir);201    const stderr_path = try std.fs.path.join(allocator, &.{ dir, "stderr.txt" });202    try sys.fs.writeFile(stderr_path, "");203    const row = try summarize(allocator, lane, 1, stderr_path, true, null);204    try std.testing.expectEqualStrings("tool_failed", row.state);205    try std.testing.expect(row.caveat_kind != null);206}207208test "profiling dhat reports missing tools as caveats" {209    var arena_state = std.heap.ArenaAllocator.init(std.testing.allocator);210    defer arena_state.deinit();211    const allocator = arena_state.allocator();212    const lane = try plan(allocator, .{}, "zig-out/profiling/run/workloads/w");213    const row = try summarize(214        allocator,215        lane,216        0,217        "missing-stderr.txt",218        false,219        null,220    );221    try std.testing.expectEqualStrings("tool_missing", row.state);222    try std.testing.expectEqualStrings("tool_unavailable", row.caveat_kind.?);223}224225test "profiling dhat rejects zero totals contradicted by owned allocations" {226    var tmp = std.testing.tmpDir(.{});227    defer tmp.cleanup();228    var arena_state = std.heap.ArenaAllocator.init(std.testing.allocator);229    defer arena_state.deinit();230    const allocator = arena_state.allocator();231    const dir = try std.fs.path.join(232        allocator,233        &.{ ".zig-cache", "tmp", tmp.sub_path[0..] },234    );235    const lane = try plan(allocator, .{}, dir);236    try sys.fs.writeFile(237        lane.capture_path,238        "==100== Total:     0 bytes in 0 blocks\n",239    );240    const stderr_path = try std.fs.path.join(allocator, &.{ dir, "stderr.txt" });241    try sys.fs.writeFile(stderr_path, "");242    const uncorroborated = try summarize(243        allocator,244        lane,245        0,246        stderr_path,247        true,248        null,249    );250    try std.testing.expectEqualStrings("summary_written", uncorroborated.state);251    const row = try summarize(allocator, lane, 0, stderr_path, true, 4_096);252    try std.testing.expectEqualStrings("evidence_invalid", row.state);253    try std.testing.expectEqualStrings(254        allocator_traffic_unobserved,255        row.caveat_kind.?,256    );257    const summary = try sys.fs.readFileAlloc(allocator, lane.summary_path, 8 * 1024);258    try std.testing.expect(std.mem.indexOf(259        u8,260        summary,261        "\"failure\": \"allocator_traffic_unobserved\"",262    ) != null);263}

1pub const dhat = runtime.dhat;