tiny.profiling.plan
Defined in tiny.profiling.
API (10)
Actions
Public operations.
Selection.countSelection.selectedallocationCoveragecollectobserveAllocationCoverageprecedingNamesvalidateFilters
Types and contracts
Public types and contracts.
Values and defaults
Public values and defaults.
Source
Source: src/profiling/plan.zig
zig
const std = @import("std");const catalog = @import("catalog.zig");pub const max_workloads_per_run: usize = 256;comptime { std.debug.assert(catalog.workloads.len <= max_workloads_per_run);}pub const Selection = struct { suite: catalog.Suite = .standard, filters: []const []const u8 = &.{}, pub fn selected(self: Selection, workload: catalog.Workload) bool { if (self.filters.len == 0) return workload.includedIn(self.suite); for (self.filters) |filter| { if (workload.matches(filter)) return true; } return false; } pub fn count(self: Selection) usize { var result: usize = 0; for (catalog.workloads) |workload| { if (self.selected(workload)) result += 1; } return result; }};pub const AllocationCoverage = struct { workloads: usize = 0, counters_supported: usize = 0, counters_unknown: usize = 0, counters_unsupported: usize = 0, traces_supported: usize = 0, traces_default: usize = 0, traces_unknown: usize = 0, traces_unsupported: usize = 0, priority_workloads: usize = 0, priority_counters_supported: usize = 0, priority_traces_supported: usize = 0, priority_counter_gaps: usize = 0, priority_trace_gaps: usize = 0,};pub fn observeAllocationCoverage(result: *AllocationCoverage, workload: catalog.Workload) void { result.workloads += 1; switch (workload.allocation_tracking.counters) { .supported => result.counters_supported += 1, .unknown => result.counters_unknown += 1, .unsupported => result.counters_unsupported += 1, } switch (workload.allocation_tracking.trace) { .opt_in => result.traces_supported += 1, .default_on => { result.traces_supported += 1; result.traces_default += 1; }, .unknown => result.traces_unknown += 1, .unsupported => result.traces_unsupported += 1, } if (!workload.isAllocationPriority()) return; result.priority_workloads += 1; if (workload.supportsAllocationCounters()) { result.priority_counters_supported += 1; } else { result.priority_counter_gaps += 1; } if (workload.supportsAllocationTrace()) { result.priority_traces_supported += 1; } else { result.priority_trace_gaps += 1; }}pub fn allocationCoverage(selection: Selection) AllocationCoverage { var result: AllocationCoverage = .{}; for (catalog.workloads) |workload| { if (!selection.selected(workload)) continue; observeAllocationCoverage(&result, workload); } std.debug.assert(result.workloads == result.counters_supported + result.counters_unknown + result.counters_unsupported); std.debug.assert(result.workloads == result.traces_supported + result.traces_unknown + result.traces_unsupported); std.debug.assert(result.priority_workloads == result.priority_counters_supported + result.priority_counter_gaps); std.debug.assert(result.priority_workloads == result.priority_traces_supported + result.priority_trace_gaps); std.debug.assert(result.traces_default <= result.traces_supported); std.debug.assert(result.workloads <= catalog.workloads.len); return result;}pub fn validateFilters(filters: []const []const u8) !void { for (filters) |filter| { if (catalog.find(filter) == null) return error.UnknownWorkload; }}pub fn collect(allocator: std.mem.Allocator, selection: Selection) ![]catalog.Workload { var workloads: std.ArrayList(catalog.Workload) = .empty; for (catalog.workloads) |workload| { if (selection.selected(workload)) try workloads.append(allocator, workload); } return try workloads.toOwnedSlice(allocator);}pub fn precedingNames( allocator: std.mem.Allocator, selection: Selection, target: catalog.Workload,) ![]const []const u8 { std.debug.assert(selection.selected(target)); var names: std.ArrayList([]const u8) = .empty; for (catalog.workloads) |workload| { if (std.mem.eql(u8, workload.name, target.name)) return try names.toOwnedSlice(allocator); if (selection.selected(workload)) try names.append(allocator, workload.name); } unreachable;}test "profiling plan selects suites and filters" { const smoke = Selection{ .suite = .smoke }; try std.testing.expect(smoke.count() > 0); try std.testing.expect(smoke.count() < (Selection{ .suite = .all }).count()); const filtered = Selection{ .suite = .all, .filters = &.{"gui-bench"} }; try std.testing.expectEqual(@as(usize, 1), filtered.count()); try std.testing.expect(filtered.selected(catalog.find("gui.paint").?));}test "profiling plan validates filters through catalog aliases" { try validateFilters(&.{ "smg.graph", "smg-bench" }); try std.testing.expectError(error.UnknownWorkload, validateFilters(&.{"missing"}));}test "nightly smoke selects both Chic families with allocation evidence" { const smoke = Selection{ .suite = .smoke }; var coverage: AllocationCoverage = .{}; for (catalog.workloads) |workload| { if (!smoke.selected(workload) or !std.mem.eql(u8, workload.package, "lib/chic")) continue; try std.testing.expect(std.mem.eql(u8, workload.name, "chic.engine") or std.mem.eql(u8, workload.name, "chic.host")); observeAllocationCoverage(&coverage, workload); } try std.testing.expectEqual(@as(usize, 2), coverage.workloads); try std.testing.expectEqual(@as(usize, 2), coverage.counters_supported); try std.testing.expectEqual(@as(usize, 2), coverage.traces_default);}test "profiling plan retains selected workload predecessors" { var arena_state = std.heap.ArenaAllocator.init(std.testing.allocator); defer arena_state.deinit(); const allocator = arena_state.allocator(); const selection = Selection{ .suite = .all }; const selected = try collect(allocator, selection); try std.testing.expect(selected.len >= 2); const predecessors = try precedingNames(allocator, selection, selected[1]); try std.testing.expectEqual(@as(usize, 1), predecessors.len); try std.testing.expectEqualStrings(selected[0].name, predecessors[0]);}test "profiling plan reports allocation observability coverage" { const coverage = allocationCoverage(.{ .suite = .all }); try std.testing.expectEqual(catalog.workloads.len, coverage.workloads); try std.testing.expect(coverage.priority_workloads > 0); try std.testing.expect(coverage.traces_default > 0); try std.testing.expectEqual(@as(usize, 0), coverage.priority_counter_gaps); try std.testing.expectEqual(@as(usize, 0), coverage.priority_trace_gaps);}test "profiling plan allocation coverage follows filters" { const coverage = allocationCoverage(.{ .suite = .all, .filters = &.{ "gpalloc.allocator", "gpalloc.compare", "smt.sat" }, }); try std.testing.expectEqual(@as(usize, 3), coverage.workloads); try std.testing.expectEqual(@as(usize, 3), coverage.counters_supported); try std.testing.expectEqual(@as(usize, 0), coverage.counters_unsupported); try std.testing.expectEqual(@as(usize, 3), coverage.traces_supported); try std.testing.expectEqual(@as(usize, 1), coverage.traces_default); try std.testing.expectEqual(@as(usize, 0), coverage.traces_unsupported); try std.testing.expectEqual(@as(usize, 2), coverage.priority_workloads); try std.testing.expectEqual(@as(usize, 0), coverage.priority_counter_gaps); try std.testing.expectEqual(@as(usize, 0), coverage.priority_trace_gaps);}const CoverageCase = struct { name: []const u8, counters: catalog.AllocationCounterSupport, trace: catalog.AllocationTracePolicy, priority: bool,};const coverage_cases = [_]CoverageCase{ .{ .name = "chic.engine", .counters = .supported, .trace = .default_on, .priority = false, }, .{ .name = "chic.host", .counters = .supported, .trace = .default_on, .priority = false, }, .{ .name = "gpalloc.allocator", .counters = .supported, .trace = .opt_in, .priority = true, }, .{ .name = "bumpalo.allocator", .counters = .supported, .trace = .default_on, .priority = true, }, .{ .name = "vt.snapshot.ready", .counters = .supported, .trace = .opt_in, .priority = false, }, .{ .name = "mprompt.effect", .counters = .unknown, .trace = .unknown, .priority = false, }, .{ .name = "machine.native", .counters = .unsupported, .trace = .unsupported, .priority = false, },};const coverage_render_bytes: usize = 1024;fn countIf(value: bool) usize { return @intFromBool(value);}fn renderCoverage( buffer: []u8, subject: []const u8, coverage: AllocationCoverage,) ![]const u8 { return try std.fmt.bufPrint(buffer, "subject={s}\n" ++ "workloads={d}\n" ++ "counters_supported={d}\ncounters_unknown={d}\ncounters_unsupported={d}\n" ++ "traces_supported={d}\ntraces_default={d}\n" ++ "traces_unknown={d}\ntraces_unsupported={d}\n" ++ "priority_workloads={d}\npriority_counters_supported={d}\n" ++ "priority_traces_supported={d}\n" ++ "priority_counter_gaps={d}\npriority_trace_gaps={d}", .{ subject, coverage.workloads, coverage.counters_supported, coverage.counters_unknown, coverage.counters_unsupported, coverage.traces_supported, coverage.traces_default, coverage.traces_unknown, coverage.traces_unsupported, coverage.priority_workloads, coverage.priority_counters_supported, coverage.priority_traces_supported, coverage.priority_counter_gaps, coverage.priority_trace_gaps, });}fn expectCoverage( subject: []const u8, expected: AllocationCoverage, observed: AllocationCoverage,) !void { var expected_buffer: [coverage_render_bytes]u8 = undefined; var observed_buffer: [coverage_render_bytes]u8 = undefined; const expected_text = try renderCoverage(&expected_buffer, subject, expected); const observed_text = try renderCoverage(&observed_buffer, subject, observed); try std.testing.expectEqualStrings(expected_text, observed_text);}fn declaredCoverage(expected: CoverageCase) AllocationCoverage { const traced = expected.trace == .opt_in or expected.trace == .default_on; const supported = expected.counters == .supported; const priority = expected.priority; return .{ .workloads = 1, .counters_supported = countIf(supported), .counters_unknown = countIf(expected.counters == .unknown), .counters_unsupported = countIf(expected.counters == .unsupported), .traces_supported = countIf(traced), .traces_default = countIf(expected.trace == .default_on), .traces_unknown = countIf(expected.trace == .unknown), .traces_unsupported = countIf(expected.trace == .unsupported), .priority_workloads = countIf(priority), .priority_counters_supported = countIf(priority and supported), .priority_traces_supported = countIf(priority and traced), .priority_counter_gaps = countIf(priority and !supported), .priority_trace_gaps = countIf(priority and !traced), };}fn coverageFixture( name: []const u8, component: []const u8, tracking: catalog.AllocationTracking,) catalog.Workload { return .{ .name = name, .package = "lib/fixture", .step = "fixture-bench", .summary = "allocation coverage fixture", .tier = .smoke, .surface = .benchmark, .allocation_tracking = tracking, .priority_component = component, };}test "profiling plan coverage classifies named workload declarations" { for (coverage_cases) |expected| { const observed = allocationCoverage(.{ .suite = .all, .filters = &.{expected.name} }); try expectCoverage(expected.name, declaredCoverage(expected), observed); }}test "profiling plan coverage counts allocator priority gaps" { const gapped = coverageFixture("fixture.gapped", "allocator", .{ .counters = .unknown, .trace = .unknown, }); var gapped_coverage: AllocationCoverage = .{}; observeAllocationCoverage(&gapped_coverage, gapped); try expectCoverage(gapped.name, .{ .workloads = 1, .counters_unknown = 1, .traces_unknown = 1, .priority_workloads = 1, .priority_counter_gaps = 1, .priority_trace_gaps = 1, }, gapped_coverage); const refused = coverageFixture("fixture.refused", "allocator", .{ .counters = .unsupported, .trace = .unsupported, }); var refused_coverage: AllocationCoverage = .{}; observeAllocationCoverage(&refused_coverage, refused); try expectCoverage(refused.name, .{ .workloads = 1, .counters_unsupported = 1, .traces_unsupported = 1, .priority_workloads = 1, .priority_counter_gaps = 1, .priority_trace_gaps = 1, }, refused_coverage);}test "profiling plan coverage counts a compliant allocator priority workload" { const compliant = coverageFixture("fixture.compliant", "allocator", .{ .counters = .supported, .trace = .default_on, .budget = .{ .previous_successful_run = 10 }, }); var coverage: AllocationCoverage = .{}; observeAllocationCoverage(&coverage, compliant); try expectCoverage(compliant.name, .{ .workloads = 1, .counters_supported = 1, .traces_supported = 1, .traces_default = 1, .priority_workloads = 1, .priority_counters_supported = 1, .priority_traces_supported = 1, }, coverage);}test "profiling workload bound remains above the current catalog" { try std.testing.expect(catalog.workloads.len < max_workloads_per_run);}Source: src/profiling/root.zig:35
zig
pub const plan = @import("plan.zig");Audit
| Definitions | 11 |
|---|---|
| Public names | 11 |
| Members | 15 |
| Version | 26.7.0 |
| Revision | daab053ee433 |