tiny.profiling.driver.control

1const std = @import("std");2const catalog = @import("../root.zig").catalog;3const execute = @import("../root.zig").execute;4const host = @import("../root.zig").host;5const perturbation = @import("../root.zig").perturbation;6const record = @import("../root.zig").record;7const MeasuredCommand = @import("root.zig").model.MeasuredCommand;8const MeasuredWorkload = @import("root.zig").model.MeasuredWorkload;9const PreparedWorkload = @import("root.zig").model.PreparedWorkload;10const WorkloadContext = @import("root.zig").model.WorkloadContext;11const aggregateMeasuredCommand = @import("root.zig").acquire.aggregateMeasuredCommand;12const aggregateUnmeasuredFailure = @import("root.zig").acquire.aggregateUnmeasuredFailure;13const combineExecutionResults = @import("root.zig").acquire.combineExecutionResults;14const runChildAcquisition = @import("root.zig").acquire.runChildAcquisition;15const runMeasuredCommand = @import("root.zig").acquire.runMeasuredCommand;16const writeCaptureControlProgress = @import("root.zig").progress.writeCaptureControlProgress;1718pub fn runCaptureControlPlan(19    allocator: std.mem.Allocator,20    context: *const WorkloadContext,21    workload: catalog.Workload,22    prepared: PreparedWorkload,23    capture_env: execute.ArtifactEnv,24    resets: *std.ArrayList(record.Reset),25) !MeasuredWorkload {26    const options = context.request.capture_control;27    const seed = perturbation.workloadSeed(options.seed, workload.name);28    const configuration = perturbation.Configuration{29        .host_kind = context.request.host_lanes.kind(),30        .tracy = context.request.tracy,31        .allocations = context.request.trace_allocations or32            workload.tracesAllocationsByDefault(),33    };34    std.debug.assert(configuration.any());35    const orders = try perturbation.schedule(allocator, options.repeat, seed);36    const pairs = try allocator.alloc(perturbation.Pair, orders.len);37    for (pairs, orders, 0..) |*pair, pair_order, index| {38        pair.* = .{ .index = @intCast(index + 1), .order = pair_order };39    }40    const control_paths = try perturbation.makePaths(allocator, prepared.paths.root);41    if (!captureControlAvailable(context, prepared)) {42        const measurement = try runMeasuredCommand(43            allocator,44            context,45            workload,46            prepared,47            prepared.wrapped.argv,48            capture_env,49            .capture,50            .capture,51            1,52            resets,53        );54        const result = measurement.execution;55        return .{56            .aggregate = aggregateMeasuredCommand(null, measurement),57            .executions = if (measurement.measured)58                try allocator.dupe(record.MeasuredExecution, &.{.{59                    .index = 1,60                    .result = result,61                    .paths = null,62                }})63            else64                &.{},65            .host_state_windows = if (measurement.host_state) |window|66                try allocator.dupe(host.state.Window, &.{window})67            else68                &.{},69            .reset_failed = !measurement.measured,70            .perturbation = .{71                .state = captureUnavailableState(measurement.measured),72                .base_seed = options.seed,73                .workload_seed = seed,74                .pairs = pairs,75                .configuration = configuration,76                .control_artifacts = control_paths,77            },78        };79    }80    const absolute_control_paths = try perturbation.makePaths(81        allocator,82        prepared.absolute_root,83    );84    var capture_executions: std.ArrayList(record.MeasuredExecution) = .empty;85    var host_state_windows: std.ArrayList(host.state.Window) = .empty;86    var capture_aggregate: ?execute.Result = null;87    var external_failure: ?execute.Result = null;88    var incomplete = false;89    var reset_failed = false;90    pair_loop: for (pairs) |*pair| {91        if (context.progress_output == .terminal) {92            try writeCaptureControlProgress(93                allocator,94                workload.name,95                pair.*,96                pairs.len,97            );98        }99        switch (pair.order) {100            .control_first => {101                const control_measurement = try runControlCondition(102                    allocator,103                    context,104                    prepared,105                    absolute_control_paths.artifactEnv(),106                    pair.index,107                    resets,108                );109                if (!retainMeasuredCondition(110                    &pair.control,111                    control_measurement,112                    &reset_failed,113                    &external_failure,114                )) {115                    incomplete = true;116                    break :pair_loop;117                }118                if (control_measurement.host_state) |window| {119                    try host_state_windows.append(allocator, window);120                }121                if (pair.control.?.exit_code != 0) {122                    external_failure = pair.control.?;123                    incomplete = true;124                    break :pair_loop;125                }126                const capture_measurement = try runCaptureCondition(127                    allocator,128                    context,129                    workload,130                    prepared,131                    capture_env,132                    pair.index,133                    resets,134                );135                if (!retainMeasuredCondition(136                    &pair.capture,137                    capture_measurement,138                    &reset_failed,139                    &external_failure,140                )) {141                    incomplete = true;142                    break :pair_loop;143                }144                if (capture_measurement.host_state) |window| {145                    try host_state_windows.append(allocator, window);146                }147                try appendCaptureExecution(148                    allocator,149                    &capture_executions,150                    &capture_aggregate,151                    pair.capture.?,152                );153                if (pair.capture.?.exit_code != 0) {154                    incomplete = true;155                    break :pair_loop;156                }157            },158            .capture_first => {159                const capture_measurement = try runCaptureCondition(160                    allocator,161                    context,162                    workload,163                    prepared,164                    capture_env,165                    pair.index,166                    resets,167                );168                if (!retainMeasuredCondition(169                    &pair.capture,170                    capture_measurement,171                    &reset_failed,172                    &external_failure,173                )) {174                    incomplete = true;175                    break :pair_loop;176                }177                if (capture_measurement.host_state) |window| {178                    try host_state_windows.append(allocator, window);179                }180                try appendCaptureExecution(181                    allocator,182                    &capture_executions,183                    &capture_aggregate,184                    pair.capture.?,185                );186                if (pair.capture.?.exit_code != 0) {187                    incomplete = true;188                    break :pair_loop;189                }190                const control_measurement = try runControlCondition(191                    allocator,192                    context,193                    prepared,194                    absolute_control_paths.artifactEnv(),195                    pair.index,196                    resets,197                );198                if (!retainMeasuredCondition(199                    &pair.control,200                    control_measurement,201                    &reset_failed,202                    &external_failure,203                )) {204                    incomplete = true;205                    break :pair_loop;206                }207                if (control_measurement.host_state) |window| {208                    try host_state_windows.append(allocator, window);209                }210                if (pair.control.?.exit_code != 0) {211                    external_failure = pair.control.?;212                    incomplete = true;213                    break :pair_loop;214                }215            },216        }217    }218    const aggregate = finalizeCaptureAggregate(219        capture_aggregate,220        external_failure,221    );222    return .{223        .aggregate = aggregate,224        .executions = try capture_executions.toOwnedSlice(allocator),225        .host_state_windows = try host_state_windows.toOwnedSlice(allocator),226        .reset_failed = reset_failed,227        .perturbation = .{228            .state = if (incomplete) .incomplete else .complete,229            .base_seed = options.seed,230            .workload_seed = seed,231            .pairs = pairs,232            .configuration = configuration,233            .control_artifacts = control_paths,234        },235    };236}237238fn retainMeasuredCondition(239    destination: *?execute.Result,240    measurement: MeasuredCommand,241    reset_failed: *bool,242    external_failure: *?execute.Result,243) bool {244    if (!measurement.measured) {245        std.debug.assert(measurement.host_state == null);246        reset_failed.* = true;247        external_failure.* = measurement.execution;248        return false;249    }250    std.debug.assert(measurement.host_state != null);251    destination.* = measurement.execution;252    return true;253}254255fn captureUnavailableState(measured: bool) perturbation.State {256    return if (measured) .capture_unavailable else .incomplete;257}258259fn finalizeCaptureAggregate(260    capture: ?execute.Result,261    external_failure: ?execute.Result,262) execute.Result {263    if (external_failure) |failure| {264        return aggregateUnmeasuredFailure(capture, failure);265    }266    return capture.?;267}268269fn captureControlAvailable(270    context: *const WorkloadContext,271    prepared: PreparedWorkload,272) bool {273    if (context.request.tracy or context.request.trace_allocations) return true;274    if (!context.request.host_lanes.any()) return false;275    return context.tool_probe.available and !prepared.execution_plan.missing_bin;276}277278fn runControlCondition(279    allocator: std.mem.Allocator,280    context: *const WorkloadContext,281    prepared: PreparedWorkload,282    artifacts: execute.ArtifactEnv,283    phase_index: usize,284    resets: *std.ArrayList(record.Reset),285) !MeasuredCommand {286    var control = context.request.control;287    control.causal = false;288    return try runChildAcquisition(289        allocator,290        context,291        prepared,292        prepared.execution_plan.argv,293        artifacts,294        false,295        false,296        control,297        .capture_control,298        .capture_control,299        phase_index,300        resets,301    );302}303304fn runCaptureCondition(305    allocator: std.mem.Allocator,306    context: *const WorkloadContext,307    workload: catalog.Workload,308    prepared: PreparedWorkload,309    artifacts: execute.ArtifactEnv,310    phase_index: usize,311    resets: *std.ArrayList(record.Reset),312) !MeasuredCommand {313    try host.resetCaptureArtifacts(prepared.wrapped);314    return try runMeasuredCommand(315        allocator,316        context,317        workload,318        prepared,319        prepared.wrapped.argv,320        artifacts,321        .capture,322        .capture,323        phase_index,324        resets,325    );326}327328fn appendCaptureExecution(329    allocator: std.mem.Allocator,330    executions: *std.ArrayList(record.MeasuredExecution),331    aggregate: *?execute.Result,332    execution: execute.Result,333) !void {334    try executions.append(allocator, .{335        .index = executions.items.len + 1,336        .result = execution,337        .paths = null,338    });339    aggregate.* = if (aggregate.*) |current|340        combineExecutionResults(current, execution)341    else342        execution;343}344345test "profiling driver does not relabel reset failures as capture conditions" {346    var destination: ?execute.Result = null;347    var reset_failed = false;348    var first_failure: ?execute.Result = null;349    const kept = retainMeasuredCondition(350        &destination,351        .{352            .execution = .{ .pid = 707, .exit_code = 9, .wall_ns = 4 },353            .host_state = null,354            .measured = false,355        },356        &reset_failed,357        &first_failure,358    );359    try std.testing.expect(!kept);360    try std.testing.expect(destination == null);361    try std.testing.expect(reset_failed);362    try std.testing.expectEqual(@as(?u64, 707), first_failure.?.pid);363    try std.testing.expectEqual(364        perturbation.State.incomplete,365        captureUnavailableState(false),366    );367    try std.testing.expectEqual(368        perturbation.State.capture_unavailable,369        captureUnavailableState(true),370    );371}372373test "profiling driver excludes unmeasured failures from aggregate resources" {374    const measured = execute.Result{375        .pid = 101,376        .exit_code = 0,377        .wall_ns = 12,378        .resource_usage_source = .wait4_rusage,379        .maxrss_kib = 42,380        .user_s = 1.5,381        .system_s = 0.5,382        .minor_page_faults = 3,383        .major_page_faults = 1,384        .voluntary_context_switches = 4,385        .involuntary_context_switches = 2,386    };387    const reset = execute.Result{388        .pid = 202,389        .exit_code = 13,390        .wall_ns = 99,391        .resource_usage_source = .wait4_rusage,392        .maxrss_kib = 900,393    };394    var expected = measured;395    expected.pid = null;396    expected.exit_code = 13;397    try std.testing.expect(std.meta.eql(398        expected,399        finalizeCaptureAggregate(measured, reset),400    ));401    const empty = finalizeCaptureAggregate(null, reset);402    try std.testing.expectEqual(@as(i64, 13), empty.exit_code);403    try std.testing.expectEqual(@as(u64, 0), empty.wall_ns);404    try std.testing.expect(empty.pid == null);405    try std.testing.expect(empty.resource_usage_source == null);406    try std.testing.expect(empty.maxrss_kib == null);407}408409test "profiling driver keeps failed measured capture process evidence" {410    const capture = execute.Result{411        .pid = 303,412        .exit_code = 7,413        .wall_ns = 15,414        .resource_usage_source = .wait4_rusage,415        .maxrss_kib = 44,416    };417    const aggregate = finalizeCaptureAggregate(capture, null);418    try std.testing.expect(std.meta.eql(capture, aggregate));419}

1pub const control = @import("control.zig");