tiny.profiling.host.coverage

1const std = @import("std");2const capture = @import("capture");3const sys = @import("sys");45const root = @import("root.zig");67pub const tool = "kcov";8pub const kind = "source_coverage";9pub const directory_name = "coverage";10pub const summary_name = "coverage.summary.json";11pub const lines_name = "coverage.lines.jsonl";1213const include_dirs = [_][]const u8{14    "src",15    "lib",16    "tools",17    "fun",18    "research",19    "verification",20    "build",21};2223pub const Options = struct {};2425pub const Lane = struct {26    directory_path: []const u8,27    summary_path: []const u8,28    lines_path: []const u8,29};3031pub fn plan(allocator: std.mem.Allocator, options: Options, workload_root: []const u8) !Lane {32    _ = options;33    return .{34        .directory_path = try std.fs.path.join(allocator, &.{ workload_root, directory_name }),35        .summary_path = try std.fs.path.join(allocator, &.{ workload_root, summary_name }),36        .lines_path = try std.fs.path.join(allocator, &.{ workload_root, lines_name }),37    };38}3940pub fn wrapArgv(allocator: std.mem.Allocator, options: Options, argv: []const []const u8, lane: Lane) ![]const []const u8 {41    _ = options;42    const include_arg = try includePathArg(allocator);43    const wrapped = try allocator.alloc([]const u8, argv.len + 4);44    wrapped[0] = tool;45    wrapped[1] = "--clean";46    wrapped[2] = include_arg;47    wrapped[3] = lane.directory_path;48    for (argv, 0..) |arg, index| wrapped[index + 4] = arg;49    return wrapped;50}5152pub fn summarize(53    allocator: std.mem.Allocator,54    lane: Lane,55    exit_code: i64,56    stderr_path: []const u8,57    tool_available: bool,58    workload_name: []const u8,59) !root.Capture {60    if (!tool_available) return missingTool(lane);61    const cov_xml = findCovXml(allocator, lane.directory_path) catch |err| switch (err) {62        error.FileNotFound => return try failed(allocator, lane, exit_code, stderr_path),63        else => |actual| return actual,64    };65    const summary = try capture.coverage.parseCoberturaFile(allocator, cov_xml);66    if (summary.instrumented_lines == 0) return try failed(allocator, lane, exit_code, stderr_path);67    try capture.coverage.writeLinesJsonlFile(lane.lines_path, summary, workload_name);68    try capture.coverage.writeSummaryFile(lane.summary_path, summary, lines_name);69    return .{70        .kind = kind,71        .tool = tool,72        .capture_path = cov_xml,73        .summary_path = lane.summary_path,74        .state = "summary_written",75    };76}7778fn includePathArg(allocator: std.mem.Allocator) ![]const u8 {79    const cwd = try sys.fs.cwdAlloc(allocator);80    var out: std.Io.Writer.Allocating = .init(allocator);81    errdefer out.deinit();82    try out.writer.writeAll("--include-path=");83    for (include_dirs, 0..) |dir, index| {84        if (index != 0) try out.writer.writeByte(',');85        const path = try std.fs.path.join(allocator, &.{ cwd, dir });86        try out.writer.writeAll(path);87    }88    return try out.toOwnedSlice();89}9091fn findCovXml(allocator: std.mem.Allocator, directory: []const u8) anyerror![]const u8 {92    const entries = try sys.fs.listDirAlloc(allocator, directory);93    defer sys.fs.freeEntries(allocator, entries);94    for (entries) |entry| {95        if (entry.kind == .file and std.mem.eql(u8, entry.name, "cov.xml")) return try allocator.dupe(u8, entry.path);96    }97    for (entries) |entry| {98        if (entry.kind != .directory) continue;99        if (findCovXml(allocator, entry.path)) |path| return path else |err| switch (err) {100            error.FileNotFound => {},101            else => |actual| return actual,102        }103    }104    return error.FileNotFound;105}106107fn missingTool(lane: Lane) root.Capture {108    return .{109        .kind = kind,110        .tool = tool,111        .capture_path = lane.directory_path,112        .summary_path = lane.summary_path,113        .state = "tool_missing",114        .caveat_kind = "tool_unavailable",115        .caveat_message = "kcov is not runnable on this host; source-line coverage was not captured",116    };117}118119fn failed(allocator: std.mem.Allocator, lane: Lane, exit_code: i64, stderr_path: []const u8) !root.Capture {120    const row = try capture.caveat.classifyCommandCapture(allocator, .{121        .phase = kind,122        .exit_code = if (exit_code == 0) 1 else exit_code,123        .timed_out = false,124        .capture_path = stderr_path,125    }) orelse capture.caveat.classifyCommandText(.{126        .phase = kind,127        .exit_code = exit_code,128        .timed_out = false,129        .capture_path = stderr_path,130    }, "");131    return .{132        .kind = kind,133        .tool = tool,134        .capture_path = lane.directory_path,135        .summary_path = lane.summary_path,136        .state = "tool_failed",137        .caveat_kind = row.kind,138        .caveat_message = row.message,139    };140}141142test "profiling coverage wraps workload argv in kcov" {143    var arena_state = std.heap.ArenaAllocator.init(std.testing.allocator);144    defer arena_state.deinit();145    const allocator = arena_state.allocator();146    const lane = try plan(allocator, .{}, "zig-out/profiling/run/workloads/w");147    const argv = [_][]const u8{ "zig-out/bin/w-bench", "--x" };148    const wrapped = try wrapArgv(allocator, .{}, &argv, lane);149    try std.testing.expectEqualStrings("kcov", wrapped[0]);150    try std.testing.expectEqualStrings("--clean", wrapped[1]);151    try std.testing.expect(std.mem.startsWith(u8, wrapped[2], "--include-path="));152    try std.testing.expectEqualStrings("zig-out/profiling/run/workloads/w/coverage", wrapped[3]);153    try std.testing.expectEqualStrings("zig-out/bin/w-bench", wrapped[4]);154}155156test "profiling coverage summarizes a kcov directory" {157    var tmp = std.testing.tmpDir(.{});158    defer tmp.cleanup();159    var arena_state = std.heap.ArenaAllocator.init(std.testing.allocator);160    defer arena_state.deinit();161    const allocator = arena_state.allocator();162    const dir = try std.fs.path.join(allocator, &.{ ".zig-cache", "tmp", tmp.sub_path[0..] });163    const lane = try plan(allocator, .{}, dir);164    const nested = try std.fs.path.join(allocator, &.{ lane.directory_path, "bench.abc" });165    try sys.fs.createDirPath(nested);166    const cov_xml = try std.fs.path.join(allocator, &.{ nested, "cov.xml" });167    try sys.fs.writeFile(cov_xml,168        \\<coverage>169        \\  <sources><source>/repo/</source></sources>170        \\  <class name="a" filename="src/a.zig"><lines>171        \\    <line number="1" hits="1"/>172        \\  </lines></class>173        \\</coverage>174    );175    const stderr_path = try std.fs.path.join(allocator, &.{ dir, "stderr.txt" });176    try sys.fs.writeFile(stderr_path, "");177    const row = try summarize(allocator, lane, 0, stderr_path, true, "w");178    try std.testing.expectEqualStrings("summary_written", row.state);179    try std.testing.expectEqualStrings(cov_xml, row.capture_path);180    try std.testing.expect(sys.fs.exists(lane.summary_path));181    try std.testing.expect(sys.fs.exists(lane.lines_path));182}

1pub const coverage = runtime.coverage;