tiny.bench.ProfilingSession

1pub const ProfilingSession = struct {2    coz_session: CozSession = .{},3    tracy_file: tracy.File = .{},4    tracy_started: bool = false,5    tracy_output: ?[]const u8 = null,6    tracy_summary: ?[]const u8 = null,7    tracy_summary_options: tracy.summary.Options = .{},8    perf_region: ?sys.perf.CounterRegion = null,9    perf_artifact: ?[]const u8 = null,10    perf_result: ?sys.perf.CountResult = null,11    allocator: ?Allocator = null,12    capabilities: [5]Capability = undefined,13    capability_count: usize = 0,14    artifacts: [8]Artifact = undefined,15    artifact_count: usize = 0,1617    pub fn start(self: *ProfilingSession, allocator: Allocator, options: ProfilingSessionOptions) !void {18        self.deinit();19        self.reset();20        self.allocator = allocator;21        errdefer self.deinit();2223        if (options.coz_output) |path| {24            try ensureParent(path);25            try self.coz_session.startWithOutputPath(allocator, path);26            self.addCapability(.{27                .name = .coz,28                .state = if (self.coz_session.enabled) .enabled else .unavailable,29                .requested = true,30                .artifact = path,31                .reason = if (self.coz_session.enabled) null else "coz runtime unavailable",32            });33            self.addArtifact("coz_output", path);34        } else {35            self.addCapability(.{36                .name = .coz,37                .state = .disabled,38                .reason = "no coz output path configured",39            });40        }41        if (options.coz_summary) |path| self.addArtifact("coz_summary", path);4243        if (options.tracy_output) |path| {44            self.tracy_output = path;45            self.tracy_summary = options.tracy_summary;46            self.tracy_summary_options = options.tracy_summary_options;47            if (!tracy.enabled) {48                self.addCapability(.{49                    .name = .tracy,50                    .state = .unavailable,51                    .requested = true,52                    .artifact = path,53                    .reason = "tracy build option disabled",54                });55                if (options.require_tracy) return error.TracyUnavailable;56            } else {57                try ensureParent(path);58                try self.tracy_file.open(path);59                self.tracy_started = try tracy.start(self.tracy_file.interface().?, .{ .name = options.name });60                self.addCapability(.{61                    .name = .tracy,62                    .state = if (self.tracy_started) .enabled else .unavailable,63                    .requested = true,64                    .artifact = path,65                    .reason = if (self.tracy_started) null else "tracy runtime unavailable",66                });67            }68            self.addArtifact("tracy_output", path);69            if (options.tracy_summary) |summary_path| self.addArtifact("tracy_summary", summary_path);70        } else {71            self.addCapability(.{72                .name = .tracy,73                .state = if (tracy.enabled) .disabled else .unavailable,74                .reason = if (tracy.enabled) "no tracy output path configured" else "tracy build option disabled",75            });76        }7778        self.addCapability(.{79            .name = .stabilizer,80            .state = if (options.stabilizer_config != null) .enabled else .disabled,81            .requested = options.stabilizer_config != null,82            .reason = if (options.stabilizer_config != null) null else "layout randomization disabled",83            .stabilizer_config = options.stabilizer_config,84        });8586        if (options.memtrace_summary) |path| self.addArtifact("memtrace_summary", path);87        if (options.memtrace_events) |path| self.addArtifact("memtrace_events", path);88        self.addCapability(.{89            .name = .memtrace,90            .state = if (options.memtrace_summary != null or options.memtrace_events != null) .enabled else .disabled,91            .requested = options.memtrace_summary != null or options.memtrace_events != null,92            .artifact = options.memtrace_summary orelse options.memtrace_events,93            .reason = if (options.memtrace_summary != null or options.memtrace_events != null) null else "no memtrace artifact configured",94        });9596        if (options.perf_artifact) |path| self.addArtifact("perf_counter", path);97        self.perf_artifact = options.perf_artifact;98        if (options.perf_counter) |counter| {99            self.perf_region = sys.perf.CounterRegion.start(counter, options.perf_counter_options) catch |err| {100                self.addCapability(.{101                    .name = .perf,102                    .state = .unavailable,103                    .requested = true,104                    .artifact = options.perf_artifact,105                    .reason = @errorName(err),106                });107                return;108            };109            self.addCapability(.{110                .name = .perf,111                .state = .enabled,112                .requested = true,113                .artifact = options.perf_artifact,114            });115        } else {116            self.addCapability(.{117                .name = .perf,118                .state = .disabled,119                .requested = options.perf_artifact != null,120                .artifact = options.perf_artifact,121                .reason = if (options.perf_artifact != null) "no perf counter configured" else "no perf counter artifact configured",122            });123        }124    }125126    pub fn finish(self: *ProfilingSession) !void {127        var first_error: ?anyerror = null;128        self.finishPerfCounter() catch |err| rememberSessionError(&first_error, err);129        const write_tracy_summary = self.tracy_started;130        if (self.tracy_started) {131            tracy.stop();132            self.tracy_started = false;133        }134        self.tracy_file.finish() catch |err| rememberSessionError(&first_error, err);135        if (write_tracy_summary) self.writeTracySummary() catch |err| rememberSessionError(&first_error, err);136        self.coz_session.finish() catch |err| rememberSessionError(&first_error, err);137        if (first_error) |err| return err;138    }139140    pub fn deinit(self: *ProfilingSession) void {141        if (self.perf_region) |*region| {142            if (region.active) _ = region.stop() catch {};143            region.deinit();144            self.perf_region = null;145        }146        if (self.tracy_started) {147            tracy.stop();148            self.tracy_started = false;149        }150        self.tracy_file.close();151        self.coz_session.deinit();152    }153154    pub fn report(self: *const ProfilingSession) ProfilingReport {155        return .{156            .capabilities = self.capabilities[0..self.capability_count],157            .artifacts = self.artifacts[0..self.artifact_count],158        };159    }160161    fn reset(self: *ProfilingSession) void {162        self.capability_count = 0;163        self.artifact_count = 0;164        self.tracy_started = false;165        self.tracy_output = null;166        self.tracy_summary = null;167        self.tracy_summary_options = .{};168        self.perf_region = null;169        self.perf_artifact = null;170        self.perf_result = null;171        self.allocator = null;172    }173174    fn addCapability(self: *ProfilingSession, capability: Capability) void {175        self.capabilities[self.capability_count] = capability;176        self.capability_count += 1;177    }178179    fn addArtifact(self: *ProfilingSession, name: []const u8, path: []const u8) void {180        self.artifacts[self.artifact_count] = .{ .name = name, .path = path };181        self.artifact_count += 1;182    }183184    fn setCapability(self: *ProfilingSession, capability: Capability) void {185        for (self.capabilities[0..self.capability_count]) |*existing| {186            if (existing.name == capability.name) {187                existing.* = capability;188                return;189            }190        }191        self.addCapability(capability);192    }193194    fn finishPerfCounter(self: *ProfilingSession) !void {195        var region = self.perf_region orelse return;196        self.perf_region = null;197        defer region.deinit();198        if (!region.active) return;199        const result = region.stop() catch |err| {200            self.setCapability(.{201                .name = .perf,202                .state = .unavailable,203                .requested = true,204                .artifact = self.perf_artifact,205                .reason = @errorName(err),206            });207            return err;208        };209        self.perf_result = result;210        if (self.perf_artifact) |path| try writePerfCounterResultFile(path, result);211    }212213    fn writeTracySummary(self: *ProfilingSession) !void {214        const trace_path = self.tracy_output orelse return;215        const summary_path = self.tracy_summary orelse return;216        const allocator = self.allocator orelse return error.ProfilingSessionNotStarted;217        try writeTracySummaryJsonlFile(allocator, summary_path, trace_path, self.tracy_summary_options);218    }219};

1pub const ProfilingSession = instrumentation.ProfilingSession;