tiny.profiling.driver.prepare

1const std = @import("std");2const sys = @import("sys");3const catalog = @import("../root.zig").catalog;4const execute = @import("../root.zig").execute;5const host = @import("../root.zig").host;6const record = @import("../root.zig").record;7const Initialization = @import("root.zig").model.Initialization;8const PreparedWorkload = @import("root.zig").model.PreparedWorkload;9const SetupOutcome = @import("root.zig").model.SetupOutcome;10const WarmupWorkload = @import("root.zig").model.WarmupWorkload;11const WorkloadContext = @import("root.zig").model.WorkloadContext;12const absolutePath = @import("root.zig").paths.absolutePath;13const absoluteWarmupArtifactEnv = @import("root.zig").paths.absoluteWarmupArtifactEnv;14const aggregateUnmeasuredFailure = @import("root.zig").acquire.aggregateUnmeasuredFailure;15const buildArgs = @import("root.zig").validation.buildArgs;16const effectiveChildEnvironment = @import("root.zig").environment.effectiveChildEnvironment;17const runReset = @import("root.zig").acquire.runReset;18const validatePreparedChildConfiguration = @import("root.zig").validation.validatePreparedChildConfiguration;19const warmupBenchControl = @import("root.zig").environment.warmupBenchControl;20const workloadBenchControl = @import("root.zig").environment.workloadBenchControl;21const writeWarmupProgress = @import("root.zig").progress.writeWarmupProgress;2223pub fn prepareWorkload(24    allocator: std.mem.Allocator,25    context: *const WorkloadContext,26    workload: catalog.Workload,27) !PreparedWorkload {28    std.debug.assert(context.request.selection.selected(workload));29    std.debug.assert(workload.name.len > 0);30    const build_args = try buildArgs(31        allocator,32        context.request.host_lanes.buildArgs(),33        context.request.tracy,34        context.metadata.optimize,35    );36    const paths = try record.makeWorkloadPaths(allocator, context.paths, workload.name);37    const absolute_root = try absolutePath(allocator, paths.root);38    const runtime = try catalog.resolveRuntime(allocator, workload, absolute_root);39    var resolved_workload = workload;40    if (resolved_workload.bin) |*bin| bin.args = runtime.bin_args;41    const execution_plan = try execute.plan(42        allocator,43        context.zig_command,44        resolved_workload,45        context.request.forwarded,46        context.request.execution_scope.directFor(workload) or47            context.request.host_lanes.requiresDirect(),48        build_args,49    );50    try validatePreparedChildConfiguration(workload, execution_plan);51    const child_environment = if (runtime.environment.len == 0)52        null53    else54        try execute.environmentWithOverrides(55            allocator,56            context.environ_map,57            runtime.environment,58        );59    const wrapped = if (execution_plan.missing_bin)60        host.Wrapped{ .argv = execution_plan.argv }61    else62        try host.wrap(63            allocator,64            context.request.host_lanes,65            execution_plan.argv,66            absolute_root,67            context.tool_probe.available,68        );69    return .{70        .execution_plan = execution_plan,71        .runtime = runtime,72        .child_environment = child_environment,73        .paths = paths,74        .absolute_root = absolute_root,75        .wrapped = wrapped,76        .command = try execute.commandText(77            allocator,78            execution_plan.cwd,79            execution_plan.setup_argv,80            wrapped.argv,81        ),82    };83}8485fn runSetup(86    allocator: std.mem.Allocator,87    context: *const WorkloadContext,88    prepared: PreparedWorkload,89) !SetupOutcome {90    const setup_argv = prepared.execution_plan.setup_argv orelse return .{91        .setup = null,92        .failure = null,93    };94    const result = try execute.runCommand(95        context.process_io,96        context.environ_map,97        prepared.execution_plan.cwd,98        setup_argv,99        prepared.paths.setup_stdout,100        prepared.paths.setup_stderr,101    );102    return .{103        .setup = .{104            .command = try execute.commandText(105                allocator,106                prepared.execution_plan.cwd,107                null,108                setup_argv,109            ),110            .pid = result.pid,111            .exit_code = result.exit_code,112            .wall_ns = result.wall_ns,113            .stdout_path = prepared.paths.setup_stdout,114            .stderr_path = prepared.paths.setup_stderr,115        },116        .failure = if (result.exit_code == 0) null else result,117    };118}119120pub fn initializeWorkload(121    allocator: std.mem.Allocator,122    context: *const WorkloadContext,123    prepared: PreparedWorkload,124) !Initialization {125    const setup = try runSetup(allocator, context, prepared);126    if (setup.failure) |failure| {127        return .{128            .setup = setup.setup,129            .prepare = null,130            .setup_failed = true,131            .prepare_failed = false,132            .failure = failure,133        };134    }135    const preparation = try runPrepare(allocator, context, prepared);136    const prepare_failed = if (preparation) |command|137        command.execution.exit_code != 0138    else139        false;140    return .{141        .setup = setup.setup,142        .prepare = preparation,143        .setup_failed = false,144        .prepare_failed = prepare_failed,145        .failure = if (preparation) |command|146            if (prepare_failed)147                aggregateUnmeasuredFailure(null, command.execution)148            else149                null150        else151            null,152    };153}154155fn runPrepare(156    allocator: std.mem.Allocator,157    context: *const WorkloadContext,158    prepared: PreparedWorkload,159) !?execute.CommandResult {160    const command = prepared.runtime.prepare orelse return null;161    std.debug.assert(prepared.execution_plan.direct);162    return try execute.runRecordedCommand(163        allocator,164        context.process_io,165        effectiveChildEnvironment(context, &prepared),166        command.cwd,167        command.argv,168        prepared.paths.prepare_stdout,169        prepared.paths.prepare_stderr,170    );171}172173pub fn runWarmups(174    allocator: std.mem.Allocator,175    context: *const WorkloadContext,176    workload: catalog.Workload,177    prepared: PreparedWorkload,178    resets: *std.ArrayList(record.Reset),179) !WarmupWorkload {180    if (context.request.warmup_repeat == 0) return .{ .executions = &.{} };181    try sys.fs.createDirPath(prepared.paths.warmup.root);182    const env_paths = try absoluteWarmupArtifactEnv(allocator, prepared.paths.warmup);183    var executions: std.ArrayList(execute.Result) = .empty;184    var failure: ?execute.Result = null;185    var reset_failed = false;186    for (0..context.request.warmup_repeat) |index| {187        if (context.progress_output == .terminal) {188            try writeWarmupProgress(189                allocator,190                workload.name,191                index,192                context.request.warmup_repeat,193            );194        }195        if (try runReset(196            allocator,197            context,198            prepared,199            .warmup,200            index + 1,201            resets,202        )) |result| {203            failure = result;204            reset_failed = true;205            break;206        }207        const result = try execute.runChild(208            allocator,209            context.process_io,210            effectiveChildEnvironment(context, &prepared),211            prepared.execution_plan.cwd,212            prepared.execution_plan.argv,213            env_paths,214            false,215            false,216            warmupBenchControl(workloadBenchControl(217                context.request.control,218                prepared.runtime.environment,219            )),220        );221        try executions.append(allocator, result);222        if (result.exit_code != 0) {223            failure = result;224            break;225        }226    }227    return .{228        .executions = try executions.toOwnedSlice(allocator),229        .failure = failure,230        .reset_failed = reset_failed,231    };232}

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