tiny.profiling.driver.schedule

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

1const std = @import("std");2const pretty_usage = @import("pretty_usage");3const sys = @import("sys");4const catalog = @import("../root.zig").catalog;5const order = @import("../root.zig").order;6const plan = @import("../root.zig").plan;7const record = @import("../root.zig").record;8const InterleavedWorkload = @import("root.zig").model.InterleavedWorkload;9const RunProgress = @import("root.zig").model.RunProgress;10const WorkloadContext = @import("root.zig").model.WorkloadContext;11const absoluteExecutionArtifactEnv = @import("root.zig").paths.absoluteExecutionArtifactEnv;12const aggregateMeasuredCommand = @import("root.zig").acquire.aggregateMeasuredCommand;13const aggregateUnmeasuredFailure = @import("root.zig").acquire.aggregateUnmeasuredFailure;14const failureExitCode = @import("root.zig").validation.failureExitCode;15const initializeWorkload = @import("root.zig").prepare.initializeWorkload;16const makeResetTestPaths = @import("fixture/root.zig").makeResetTestPaths;17const prepareWorkload = @import("root.zig").prepare.prepareWorkload;18const recordCompletedWorkload = @import("root.zig").publish.recordCompletedWorkload;19const resetTestContext = @import("fixture/root.zig").resetTestContext;20const resetTestPrepared = @import("fixture/root.zig").resetTestPrepared;21const resetTestWorkload = @import("fixture/root.zig").resetTestWorkload;22const runMeasuredCommand = @import("root.zig").acquire.runMeasuredCommand;23const runWarmups = @import("root.zig").prepare.runWarmups;24const writeInterleaveProgress = @import("root.zig").progress.writeInterleaveProgress;2526pub fn runInterleavedWorkloads(27    context: *const WorkloadContext,28    seed: u64,29) !RunProgress {30    const backing_allocator = context.backing_allocator;31    const selected = try plan.collect(backing_allocator, context.request.selection);32    defer backing_allocator.free(selected);33    try order.validateDesign(selected.len, context.request.measure_repeat);34    const selected_names = try backing_allocator.alloc([]const u8, selected.len);35    defer backing_allocator.free(selected_names);36    for (selected, 0..) |workload, index| selected_names[index] = workload.name;37    const entries = try order.schedule(38        backing_allocator,39        selected.len,40        context.request.measure_repeat,41        seed,42    );43    defer backing_allocator.free(entries);44    const states = try backing_allocator.alloc(InterleavedWorkload, selected.len);45    defer backing_allocator.free(states);46    var initialized: usize = 0;47    defer for (states[0..initialized]) |*state| state.arena.deinit();4849    for (selected, 0..) |workload, index| {50        states[index] = .{51            .arena = std.heap.ArenaAllocator.init(backing_allocator),52            .workload = workload,53            .index = index,54            .prepared = undefined,55            .started_unix_ns = 0,56            .finished_unix_ns = 0,57            .setup = null,58            .prepare = null,59            .setup_failed = false,60            .prepare_failed = false,61            .execution = null,62        };63        initialized += 1;64        const allocator = states[index].arena.allocator();65        states[index].prepared = try prepareWorkload(allocator, context, workload);66        try pretty_usage.Terminal.stderr(allocator, .{}).writeTextFmt(67            "profile: {s}\n",68            .{states[index].prepared.command},69        );70        states[index].started_unix_ns = sys.time.realNanoTimestamp();71        try initializeInterleaved(allocator, context, &states[index]);72    }7374    try pretty_usage.Terminal.stderr(backing_allocator, .{}).writeTextFmt(75        "profile: random interleaving {d} process acquisitions across {d} workloads, seed {d}\n",76        .{ entries.len, selected.len, seed },77    );78    for (entries) |entry| {79        const state = &states[entry.workload_index];80        try runInterleavedEntry(context, state, entry, entries.len);81    }8283    var progress = RunProgress{84        .ran = states.len,85        .failures = 0,86        .first_failure_exit_code = 0,87        .stopped_early = false,88    };89    for (states) |*state| {90        if (state.execution == null) return error.InvalidInterleaveSchedule;91        const allocator = state.arena.allocator();92        const acquisition = try order.interleavedContext(93            allocator,94            selected_names,95            entries,96            state.index,97            context.request.measure_repeat,98            seed,99        );100        const exit_code = try recordCompletedWorkload(101            allocator,102            context,103            state.workload,104            state.index,105            state.prepared,106            state.completed(),107            acquisition,108            state.started_unix_ns,109            state.finished_unix_ns,110        );111        if (exit_code == 0) continue;112        progress.failures += 1;113        if (progress.first_failure_exit_code == 0) {114            progress.first_failure_exit_code = failureExitCode(exit_code);115        }116    }117    return progress;118}119120fn initializeInterleaved(121    allocator: std.mem.Allocator,122    context: *const WorkloadContext,123    state: *InterleavedWorkload,124) !void {125    const initialization = try initializeWorkload(126        allocator,127        context,128        state.prepared,129    );130    state.setup = initialization.setup;131    state.prepare = initialization.prepare;132    state.setup_failed = initialization.setup_failed;133    state.prepare_failed = initialization.prepare_failed;134    if (initialization.failure) |failure| {135        state.execution = failure;136        state.finished_unix_ns = sys.time.realNanoTimestamp();137    }138}139140fn runInterleavedEntry(141    context: *const WorkloadContext,142    state: *InterleavedWorkload,143    entry: order.Entry,144    entry_count: usize,145) !void {146    if (state.failed()) return;147    const allocator = state.arena.allocator();148    if (context.progress_output == .terminal) {149        try writeInterleaveProgress(150            allocator,151            state.workload.name,152            entry,153            entry_count,154            context.request.measure_repeat,155        );156    }157    if (!try interleavedWarmupSucceeded(allocator, context, state)) return;158    if (@as(usize, entry.repetition_index) != state.executions.items.len) {159        return error.InvalidInterleaveSchedule;160    }161    const execution_paths = try record.executionPaths(162        allocator,163        state.prepared.paths,164        context.request.measure_repeat,165        @as(usize, entry.repetition_index) + 1,166    );167    const artifacts = try absoluteExecutionArtifactEnv(allocator, execution_paths);168    const measurement = try runMeasuredCommand(169        allocator,170        context,171        state.workload,172        state.prepared,173        state.prepared.wrapped.argv,174        artifacts,175        .measurement,176        .measurement,177        entry.repetition_index + 1,178        &state.resets,179    );180    const result = measurement.execution;181    if (measurement.measured) {182        try state.executions.append(allocator, .{183            .index = @as(usize, entry.repetition_index) + 1,184            .result = result,185            .paths = execution_paths,186            .acquisition_position = entry.position,187        });188    } else {189        state.reset_failed = true;190    }191    if (measurement.host_state) |window| {192        try state.host_state_windows.append(allocator, window);193    }194    state.execution = aggregateMeasuredCommand(state.execution, measurement);195    state.finished_unix_ns = sys.time.realNanoTimestamp();196}197198fn interleavedWarmupSucceeded(199    allocator: std.mem.Allocator,200    context: *const WorkloadContext,201    state: *InterleavedWorkload,202) !bool {203    if (state.warmup_attempted) return true;204    state.warmup_attempted = true;205    const warmup = try runWarmups(206        allocator,207        context,208        state.workload,209        state.prepared,210        &state.resets,211    );212    state.warmup_executions = warmup.executions;213    const failure = warmup.failure orelse return true;214    state.warmup_failed = !warmup.reset_failed;215    state.reset_failed = warmup.reset_failed;216    state.execution = if (warmup.reset_failed)217        aggregateUnmeasuredFailure(null, failure)218    else219        failure;220    state.finished_unix_ns = sys.time.realNanoTimestamp();221    return false;222}223224test "profiling driver maps interleaved measured execution artifacts" {225    var tmp = std.testing.tmpDir(.{});226    defer tmp.cleanup();227    var arena_state = std.heap.ArenaAllocator.init(std.testing.allocator);228    defer arena_state.deinit();229    const allocator = arena_state.allocator();230    const root = try tmp.parent_dir.realPathFileAlloc(231        std.testing.io,232        tmp.sub_path[0..],233        allocator,234    );235    const paths = try makeResetTestPaths(allocator, root);236    var parent = sys.process.Environ.Map.init(allocator);237    try parent.put("PATH", "/usr/bin:/bin");238    var workload = resetTestWorkload(&.{"/bin/true"}, &.{});239    workload.reset = null;240    const child_argv = [_][]const u8{ "/bin/sh", "-c", "printf '%s' \"$BENCH_JSONL\"" };241    const context = resetTestContext(allocator, &parent, paths.run, 0, 3);242    var state = InterleavedWorkload{243        .arena = std.heap.ArenaAllocator.init(std.testing.allocator),244        .workload = workload,245        .index = 0,246        .prepared = undefined,247        .started_unix_ns = sys.time.realNanoTimestamp(),248        .finished_unix_ns = 0,249        .setup = null,250        .prepare = null,251        .setup_failed = false,252        .prepare_failed = false,253        .execution = null,254    };255    defer state.arena.deinit();256    const state_allocator = state.arena.allocator();257    state.prepared = try resetTestPrepared(258        state_allocator,259        &parent,260        workload,261        paths.workload,262        &child_argv,263    );264    try initializeInterleaved(state_allocator, &context, &state);265    for ([_]usize{ 2, 5, 6 }, 0..) |position, index| {266        try runInterleavedEntry(&context, &state, .{267            .workload_index = 0,268            .repetition_index = @intCast(index),269            .position = position,270        }, 6);271    }272    try std.testing.expectEqual(@as(usize, 3), state.executions.items.len);273    for (state.executions.items, [_]usize{ 2, 5, 6 }, 0..) |execution, position, index| {274        try std.testing.expectEqual(index + 1, execution.index);275        try std.testing.expectEqual(@as(?usize, position), execution.acquisition_position);276        try std.testing.expect((execution.result.pid orelse 0) > 0);277        const suffix = try std.fmt.allocPrint(allocator, "/{d:0>3}", .{index + 1});278        try std.testing.expect(std.mem.endsWith(u8, execution.paths.?.root, suffix));279    }280}281282test "profiling driver suppresses interleaved positions after preparation failure" {283    var tmp = std.testing.tmpDir(.{});284    defer tmp.cleanup();285    var arena_state = std.heap.ArenaAllocator.init(std.testing.allocator);286    defer arena_state.deinit();287    const allocator = arena_state.allocator();288    const root = try tmp.parent_dir.realPathFileAlloc(289        std.testing.io,290        tmp.sub_path[0..],291        allocator,292    );293    const paths = try makeResetTestPaths(allocator, root);294    var parent = sys.process.Environ.Map.init(allocator);295    try parent.put("PATH", "/usr/bin:/bin");296    const environment = [_]catalog.EnvironmentOverride{.{297        .name = "HOME",298        .value = root,299    }};300    var workload = resetTestWorkload(&.{301        "/bin/sh",302        "-c",303        "printf reset > \"$HOME/reset\"",304    }, &environment);305    workload.prepare = .{ .argv = &.{306        "/bin/sh",307        "-c",308        "printf interleaved-prepare; exit 17",309    } };310    const child_argv = [_][]const u8{311        "/bin/sh",312        "-c",313        "printf product > \"$HOME/product\"",314    };315    const context = resetTestContext(allocator, &parent, paths.run, 0, 3);316    var state = InterleavedWorkload{317        .arena = std.heap.ArenaAllocator.init(std.testing.allocator),318        .workload = workload,319        .index = 0,320        .prepared = undefined,321        .started_unix_ns = sys.time.realNanoTimestamp(),322        .finished_unix_ns = 0,323        .setup = null,324        .prepare = null,325        .setup_failed = false,326        .prepare_failed = false,327        .execution = null,328    };329    defer state.arena.deinit();330    const state_allocator = state.arena.allocator();331    state.prepared = try resetTestPrepared(332        state_allocator,333        &parent,334        workload,335        paths.workload,336        &child_argv,337    );338    try initializeInterleaved(state_allocator, &context, &state);339    for (0..3) |index| {340        try runInterleavedEntry(&context, &state, .{341            .workload_index = 0,342            .repetition_index = @intCast(index),343            .position = index + 1,344        }, 3);345    }346    try std.testing.expect(state.failed());347    try std.testing.expect(!state.setup_failed);348    try std.testing.expect(state.prepare_failed);349    try std.testing.expectEqual(@as(i64, 17), state.execution.?.exit_code);350    try std.testing.expect(state.execution.?.pid == null);351    try std.testing.expectEqual(@as(u64, 0), state.execution.?.wall_ns);352    try std.testing.expect(state.execution.?.resource_usage_source == null);353    try std.testing.expect(state.execution.?.maxrss_kib == null);354    try std.testing.expectEqual(@as(usize, 0), state.resets.items.len);355    try std.testing.expectEqual(@as(usize, 0), state.executions.items.len);356    try std.testing.expectEqual(@as(usize, 0), state.host_state_windows.items.len);357    const prepare = state.prepare.?;358    try std.testing.expect((prepare.execution.pid orelse 0) > 0);359    try std.testing.expectEqual(@as(i64, 17), prepare.execution.exit_code);360    try std.testing.expectEqualStrings(361        "interleaved-prepare",362        try sys.fs.readFileAlloc(allocator, prepare.stdout_path, 4096),363    );364    const suppressed_paths = [_][]const u8{ "reset", "product" };365    for (suppressed_paths) |name| {366        const path = try std.fs.path.join(allocator, &.{ root, name });367        try std.testing.expectError(error.FileNotFound, sys.fs.statFile(path));368    }369}370371test "profiling driver skips later interleaved positions after reset failure" {372    var tmp = std.testing.tmpDir(.{});373    defer tmp.cleanup();374    var arena_state = std.heap.ArenaAllocator.init(std.testing.allocator);375    defer arena_state.deinit();376    const allocator = arena_state.allocator();377    const root = try tmp.parent_dir.realPathFileAlloc(378        std.testing.io,379        tmp.sub_path[0..],380        allocator,381    );382    const paths = try makeResetTestPaths(allocator, root);383    var base_environment = sys.process.Environ.Map.init(allocator);384    try base_environment.put("PATH", "/usr/bin:/bin");385    const environment = [_]catalog.EnvironmentOverride{.{ .name = "HOME", .value = root }};386    const reset_argv = [_][]const u8{387        "/bin/sh",388        "-c",389        "count=0; test ! -f \"$HOME/reset-count\" || count=$(cat \"$HOME/reset-count\"); count=$((count + 1)); printf '%s' \"$count\" > \"$HOME/reset-count\"; printf 'reset\\n' >> \"$HOME/order\"; test \"$count\" -lt 2 || exit 11",390    };391    const child_argv = [_][]const u8{392        "/bin/sh",393        "-c",394        "printf 'child\\n' >> \"$HOME/order\"",395    };396    var workload = resetTestWorkload(&reset_argv, &environment);397    workload.prepare = .{ .argv = &.{398        "/bin/sh",399        "-c",400        "printf 'prepare\\n' >> \"$HOME/order\"",401    } };402    const context = resetTestContext(allocator, &base_environment, paths.run, 0, 3);403    var state = InterleavedWorkload{404        .arena = std.heap.ArenaAllocator.init(std.testing.allocator),405        .workload = workload,406        .index = 0,407        .prepared = undefined,408        .started_unix_ns = sys.time.realNanoTimestamp(),409        .finished_unix_ns = 0,410        .setup = null,411        .prepare = null,412        .setup_failed = false,413        .prepare_failed = false,414        .execution = null,415    };416    defer state.arena.deinit();417    const state_allocator = state.arena.allocator();418    state.prepared = try resetTestPrepared(419        state_allocator,420        &base_environment,421        workload,422        paths.workload,423        &child_argv,424    );425    try initializeInterleaved(state_allocator, &context, &state);426    try std.testing.expect(!state.prepare_failed);427    try std.testing.expect((state.prepare.?.execution.pid orelse 0) > 0);428    try runInterleavedEntry(&context, &state, .{429        .workload_index = 0,430        .repetition_index = 0,431        .position = 1,432    }, 3);433    try runInterleavedEntry(&context, &state, .{434        .workload_index = 0,435        .repetition_index = 1,436        .position = 2,437    }, 3);438    try runInterleavedEntry(&context, &state, .{439        .workload_index = 0,440        .repetition_index = 2,441        .position = 3,442    }, 3);443    try std.testing.expect(state.failed());444    try std.testing.expect(state.reset_failed);445    try std.testing.expectEqual(@as(usize, 2), state.resets.items.len);446    try std.testing.expectEqual(@as(usize, 1), state.executions.items.len);447    var expected = state.executions.items[0].result;448    expected.pid = null;449    expected.exit_code = 11;450    try std.testing.expect(std.meta.eql(expected, state.execution.?));451    const order_path = try std.fs.path.join(allocator, &.{ root, "order" });452    const order_text = try sys.fs.readFileAlloc(allocator, order_path, 4096);453    try std.testing.expectEqualStrings("prepare\nreset\nchild\nreset\n", order_text);454}