lib/tracy/src/cli/args/compare.zig

daab053ee43316e1809a84551d573ddd1e5bf3d2

 1 const std = @import("std");
 2 const scalar = @import("scalar.zig");
 3 const types = @import("types.zig");
 4 
 5 pub fn parse(args: []const []const u8) !types.CompareArgs {
 6     if (args.len < 2) return error.InvalidArguments;
 7     var parsed = types.CompareArgs{
 8         .baseline_path = args[0],
 9         .run_path = args[1],
10     };
11     var index: usize = 2;
12     while (index < args.len) : (index += 1) {
13         if (std.mem.eql(u8, args[index], "--format")) {
14             index += 1;
15             if (index >= args.len) return error.InvalidArguments;
16             if (std.mem.eql(u8, args[index], "text")) {
17                 parsed.format = .text;
18             } else if (std.mem.eql(u8, args[index], "jsonl")) {
19                 parsed.format = .jsonl;
20             } else {
21                 return error.UnsupportedFormat;
22             }
23         } else if (std.mem.eql(u8, args[index], "--top")) {
24             index += 1;
25             if (index >= args.len) return error.InvalidArguments;
26             parsed.options.top = try scalar.parsePositiveUsize(args[index]);
27         } else if (std.mem.eql(u8, args[index], "--min-zone-delta-ns")) {
28             index += 1;
29             if (index >= args.len) return error.InvalidArguments;
30             parsed.options.min_zone_delta_ns = try scalar.parseU64(args[index]);
31         } else if (std.mem.eql(u8, args[index], "--frame-budget-ns")) {
32             index += 1;
33             if (index >= args.len) return error.InvalidArguments;
34             parsed.options.frame_budget_ns = try scalar.parsePositiveU64(args[index]);
35         } else if (std.mem.eql(u8, args[index], "--min-frame-delta-ns")) {
36             index += 1;
37             if (index >= args.len) return error.InvalidArguments;
38             parsed.options.min_frame_delta_ns = try scalar.parseU64(args[index]);
39         } else if (std.mem.eql(u8, args[index], "--min-gpu-delta-ns")) {
40             index += 1;
41             if (index >= args.len) return error.InvalidArguments;
42             parsed.options.min_gpu_delta_ns = try scalar.parseU64(args[index]);
43         } else if (std.mem.eql(u8, args[index], "--min-memory-delta-bytes")) {
44             index += 1;
45             if (index >= args.len) return error.InvalidArguments;
46             parsed.options.min_memory_delta_bytes = try scalar.parseU64(args[index]);
47         } else if (std.mem.eql(u8, args[index], "--min-memory-lifetime-delta-ns")) {
48             index += 1;
49             if (index >= args.len) return error.InvalidArguments;
50             parsed.options.min_memory_lifetime_delta_ns = try scalar.parseU64(args[index]);
51         } else if (std.mem.eql(u8, args[index], "--include-stable")) {
52             parsed.options.include_stable = true;
53         } else {
54             return error.UnknownArgument;
55         }
56     }
57     return parsed;
58 }
59 
60 test "compare args parse filters and format" {
61     const parsed = try parse(&.{
62         "base.jsonl",
63         "run.jsonl",
64         "--format",
65         "jsonl",
66         "--top",
67         "4",
68         "--min-zone-delta-ns",
69         "100",
70         "--frame-budget-ns",
71         "20",
72         "--min-frame-delta-ns",
73         "30",
74         "--min-gpu-delta-ns",
75         "40",
76         "--min-memory-delta-bytes",
77         "64",
78         "--min-memory-lifetime-delta-ns",
79         "80",
80         "--include-stable",
81     });
82     try std.testing.expectEqualStrings("base.jsonl", parsed.baseline_path);
83     try std.testing.expectEqualStrings("run.jsonl", parsed.run_path);
84     try std.testing.expectEqual(types.Format.jsonl, parsed.format);
85     try std.testing.expectEqual(@as(usize, 4), parsed.options.top);
86     try std.testing.expectEqual(@as(u64, 100), parsed.options.min_zone_delta_ns);
87     try std.testing.expectEqual(@as(?u64, 20), parsed.options.frame_budget_ns);
88     try std.testing.expectEqual(@as(u64, 30), parsed.options.min_frame_delta_ns);
89     try std.testing.expectEqual(@as(u64, 40), parsed.options.min_gpu_delta_ns);
90     try std.testing.expectEqual(@as(u64, 64), parsed.options.min_memory_delta_bytes);
91     try std.testing.expectEqual(
92         @as(u64, 80),
93         parsed.options.min_memory_lifetime_delta_ns,
94     );
95     try std.testing.expect(parsed.options.include_stable);
96 }