tiny.coz.Runtime

1pub const Runtime = struct {2    allocator: ?std.mem.Allocator = null,3    profiler: Profiler = .{},4    profile_writer: ?*std.Io.Writer = null,5    profile_writer_mutex: std.atomic.Mutex = .unlocked,6    source_scope: debug_info.Scope = .{},7    resolve_sample_locations: bool = false,8    runtime_start_ns: u64 = 0,9    sampling_handler: ?signals.Installed = null,10    sample_thread: ?*thread.Thread = null,11    experiment_worker: ?sys.thread.JoinHandle = null,12    experiment_worker_running: std.atomic.Value(bool) = .init(false),13    experiment_worker_error: ?anyerror = null,14    experiment_worker_options: ExperimentStepOptions = .{},15    profiler_installed: bool = false,16    current_thread_started: bool = false,1718    pub fn start(self: *Runtime, allocator: std.mem.Allocator, options: RuntimeOptions) !void {19        if (self.profiler_installed) return error.RuntimeAlreadyStarted;2021        self.allocator = allocator;22        self.runtime_start_ns = timestampNs();23        errdefer self.shutdown();2425        installProfiler(allocator, &self.profiler);26        self.profiler_installed = true;2728        if (options.install_signal_handler) {29            self.sampling_handler = installSamplingHandler();30        }3132        if (options.start_current_thread) {33            current_thread = try thread.Thread.openAndStartCurrent(options.sampler_options);34            self.sample_thread = &current_thread;35            self.current_thread_started = true;36        }3738        self.source_scope = options.source_scope;39        self.resolve_sample_locations = options.resolve_sample_locations;40        if (options.experiment_duration_ns) |duration_ns| {41            self.profiler.experiment_duration_ns = duration_ns;42        }4344        if (options.profile_writer) |writer| {45            try self.profiler.writeStartup(writer, self.runtime_start_ns);46            self.profile_writer = writer;47        }4849        if (options.start_experiment_worker) {50            if (self.profile_writer == null) return error.ProfileWriterUnavailable;51            try self.startExperimentWorker(options.experiment_step_options);52        }53    }5455    pub fn startIfAvailable(self: *Runtime, allocator: std.mem.Allocator, options: RuntimeOptions) !bool {56        self.start(allocator, options) catch |err| {57            if (runtimeUnavailable(err)) return false;58            return err;59        };60        return true;61    }6263    pub fn runExperimentStep(self: *Runtime, options: ExperimentStepOptions) !ExperimentStepResult {64        return self.runExperimentStepWithWait(options, waitNs, true);65    }6667    fn runExperimentStepWithWait(68        self: *Runtime,69        options: ExperimentStepOptions,70        wait_fn: sampler.WaitFn,71        drain_current_thread: bool,72    ) !ExperimentStepResult {73        const allocator = self.allocator orelse return error.RuntimeNotStarted;74        const writer = self.profile_writer orelse return error.ProfileWriterUnavailable;7576        if (drain_current_thread and self.current_thread_started) {77            _ = try current_thread.processDefault(&self.profiler, waitNs);78        }7980        lockMutex(&self.profile_writer_mutex);81        defer self.profile_writer_mutex.unlock();8283        const result = try self.profiler.runExperimentStep(allocator, writer, options, wait_fn);84        if (result.emitted) try writer.flush();85        return result;86    }8788    pub fn stop(self: *Runtime) !void {89        var first_error: ?anyerror = null;90        var loss_counter: profile.LossCounter = .unsupported;91        var terminal_status: profile.TerminalStatus = .not_started;9293        self.stopExperimentWorker() catch |err| rememberRuntimeError(&first_error, err);9495        if (self.current_thread_started) {96            var stopped = true;97            current_thread.sampler.stop() catch |err| {98                stopped = false;99                rememberRuntimeError(&first_error, err);100            };101            var drained = true;102            _ = current_thread.drainDefault(&self.profiler) catch |err| failed: {103                drained = false;104                rememberRuntimeError(&first_error, err);105                break :failed 0;106            };107            terminal_status = if (!drained)108                .drain_failed109            else if (!stopped)110                .stop_failed111            else112                .complete;113            loss_counter = profileLossCounter(current_thread.sampler.readLossCounter());114            current_thread.close();115            current_thread = .{};116            self.sample_thread = null;117            self.current_thread_started = false;118        }119120        if (self.sampling_handler) |*handler| {121            handler.restore();122            self.sampling_handler = null;123        }124125        if (self.profiler_installed) {126            uninstallProfiler(&self.profiler);127            self.profiler_installed = false;128        }129130        if (self.profile_writer) |writer| {131            if (self.allocator) |allocator| {132                lockMutex(&self.profile_writer_mutex);133                defer self.profile_writer_mutex.unlock();134                self.profiler.writeRuntimeAndSamples(135                    allocator,136                    writer,137                    elapsedSinceNs(self.runtime_start_ns),138                    loss_counter,139                    terminal_status,140                ) catch |err| rememberRuntimeError(&first_error, err);141                writer.flush() catch |err| rememberRuntimeError(&first_error, err);142            }143            self.profile_writer = null;144        }145146        if (self.allocator) |allocator| {147            self.profiler.deinit(allocator);148            self.allocator = null;149        }150151        self.runtime_start_ns = 0;152        self.source_scope = .{};153        self.resolve_sample_locations = false;154155        if (first_error) |err| return err;156    }157158    pub fn shutdown(self: *Runtime) void {159        self.stop() catch {};160    }161162    fn startExperimentWorker(self: *Runtime, options: ExperimentStepOptions) !void {163        if (self.experiment_worker != null) return error.ExperimentWorkerAlreadyStarted;164165        self.experiment_worker_options = options;166        self.experiment_worker_error = null;167        self.experiment_worker_running.store(true, .release);168        errdefer self.experiment_worker_running.store(false, .release);169        self.experiment_worker = try sys.thread.spawn(experimentWorkerMain, .{self});170    }171172    fn stopExperimentWorker(self: *Runtime) !void {173        if (self.experiment_worker) |worker| {174            self.experiment_worker_running.store(false, .release);175            worker.join();176            self.experiment_worker = null;177        } else {178            self.experiment_worker_running.store(false, .release);179        }180181        if (self.experiment_worker_error) |err| {182            self.experiment_worker_error = null;183            return err;184        }185    }186187    fn runExperimentWorkerStepWithWait(188        self: *Runtime,189        prng: *std.Random.DefaultPrng,190        wait_fn: sampler.WaitFn,191    ) !ExperimentStepResult {192        var options = self.experiment_worker_options;193        options.running = &self.experiment_worker_running;194        if (options.fixed_speedup_percent == null) {195            const draw_value = prng.random().intRangeAtMost(u64, 0, experiment.Draw.maxDraw());196            options.draw = try experiment.Draw.init(draw_value);197        }198        return self.runExperimentStepWithWait(options, wait_fn, false);199    }200201    fn drainSampleThread(self: *Runtime) !usize {202        if (!self.resolve_sample_locations) return 0;203        const allocator = self.allocator orelse return 0;204        const sample_thread = self.sample_thread orelse return 0;205        return sample_thread.drainResolvedDefault(&self.profiler, allocator, self.source_scope);206    }207};

1pub const Runtime = runtime.Runtime;