tiny.profiling.experiment.parse

1const std = @import("std");2const sys = @import("sys");34const profiling = @import("../root.zig");5const model = @import("model.zig");6const json = profiling.json;7const scenario = profiling.scenario;89pub fn load(10    allocator: std.mem.Allocator,11    path: []const u8,12) !model.Plan {13    const text = try sys.fs.readFileAlloc(14        allocator,15        path,16        model.maximum_plan_bytes,17    );18    const value = try std.json.parseFromSliceLeaky(19        std.json.Value,20        allocator,21        text,22        .{},23    );24    return try parse(allocator, value);25}2627pub fn parse(28    allocator: std.mem.Allocator,29    value: std.json.Value,30) !model.Plan {31    const object = try json.object(value);32    const actual_schema = json.string(object.get("schema")) orelse33        return error.InvalidExperimentSchema;34    if (!std.mem.eql(u8, actual_schema, model.schema)) {35        return error.InvalidExperimentSchema;36    }37    const plan = model.Plan{38        .name = try requiredString(object, "name"),39        .scenario = try scenario.parse(40            allocator,41            object.get("scenario") orelse return error.MissingScenario,42        ),43        .baseline = try parseVariant(allocator, object, "baseline"),44        .candidate = try parseVariant(allocator, object, "candidate"),45        .metric = model.Metric.parse(46            try requiredString(object, "metric"),47        ) orelse return error.InvalidExperimentMetric,48        .practical_effect_percent = json.asF64(49            object.get("practical_effect_percent"),50        ) orelse return error.InvalidPracticalEffect,51        .seed = json.asU64(object.get("seed")) orelse52            return error.InvalidExperimentSeed,53        .design = try parseDesign(object.get("design")),54    };55    try plan.validate();56    return plan;57}5859fn parseVariant(60    allocator: std.mem.Allocator,61    object: std.json.ObjectMap,62    field: []const u8,63) !model.Variant {64    const value = object.get(field) orelse return error.MissingVariant;65    const variant = try json.object(value);66    const binary = json.string(variant.get("binary"));67    const ref_name = json.string(variant.get("ref"));68    if ((binary == null) == (ref_name == null)) return error.InvalidVariant;69    if (binary) |path| return .{ .binary = path };70    return .{ .git_ref = .{71        .name = ref_name.?,72        .build = try parseBuild(allocator, variant.get("build")),73    } };74}7576fn parseBuild(77    allocator: std.mem.Allocator,78    value: ?std.json.Value,79) !?model.Build {80    const actual = value orelse return null;81    const object = try json.object(actual);82    return .{83        .argv = try parseArguments(allocator, object.get("argv")),84        .artifact = try requiredString(object, "artifact"),85        .cwd = json.string(object.get("cwd")),86    };87}8889fn parseArguments(90    allocator: std.mem.Allocator,91    value: ?std.json.Value,92) ![]const []const u8 {93    const rows = try json.array(value orelse return error.InvalidVariantBuild);94    if (rows.items.len == 0 or95        rows.items.len > scenario.maximum_arguments)96    {97        return error.InvalidVariantBuild;98    }99    const result = try allocator.alloc([]const u8, rows.items.len);100    for (rows.items, 0..) |item, index| {101        const argument = json.string(item) orelse102            return error.InvalidVariantBuild;103        if (argument.len == 0 or104            argument.len > scenario.maximum_string_bytes)105        {106            return error.InvalidVariantBuild;107        }108        result[index] = argument;109    }110    return result;111}112113fn parseDesign(value: ?std.json.Value) !model.Design {114    const actual = value orelse return .{};115    const object = try json.object(actual);116    return .{117        .calibration_pairs = try optionalUsize(118            object,119            "calibration_pairs",120            model.default_calibration_pairs,121        ),122        .minimum_evaluation_pairs = try optionalUsize(123            object,124            "minimum_evaluation_pairs",125            model.default_minimum_evaluation_pairs,126        ),127        .maximum_evaluation_pairs = try optionalUsize(128            object,129            "maximum_evaluation_pairs",130            model.default_maximum_evaluation_pairs,131        ),132    };133}134135fn optionalUsize(136    object: std.json.ObjectMap,137    field: []const u8,138    default: usize,139) !usize {140    const value = object.get(field) orelse return default;141    return std.math.cast(142        usize,143        json.asU64(value) orelse return error.InvalidExperimentDesign,144    ) orelse error.InvalidExperimentDesign;145}146147fn requiredString(148    object: std.json.ObjectMap,149    field: []const u8,150) ![]const u8 {151    return json.string(object.get(field)) orelse error.InvalidExperimentPlan;152}153154test "profiling experiment parses binary scenario plans" {155    var arena_state = std.heap.ArenaAllocator.init(std.testing.allocator);156    defer arena_state.deinit();157    const allocator = arena_state.allocator();158    const value = try std.json.parseFromSliceLeaky(159        std.json.Value,160        allocator,161        \\{"schema":"tiny.profiling.experiment/v1","name":"startup",162        \\ "scenario":{"schema":"tiny.profiling.scenario/v1","name":"cli",163        \\   "argv":["{binary}","--version"],"oracle":{"exit_code":0}},164        \\ "baseline":{"binary":"base"},"candidate":{"binary":"candidate"},165        \\ "metric":"wall_ns","practical_effect_percent":5,"seed":42,166        \\ "design":{"calibration_pairs":6,"maximum_evaluation_pairs":40}}167    ,168        .{},169    );170    const plan = try parse(allocator, value);171    try std.testing.expectEqual(model.Metric.wall_ns, plan.metric);172    try std.testing.expectEqual(@as(usize, 6), plan.design.calibration_pairs);173    try std.testing.expectEqual(174        @as(usize, 40),175        plan.design.maximum_evaluation_pairs,176    );177}178179test "profiling experiment requires builds for ref command scenarios" {180    var arena_state = std.heap.ArenaAllocator.init(std.testing.allocator);181    defer arena_state.deinit();182    const allocator = arena_state.allocator();183    const value = try std.json.parseFromSliceLeaky(184        std.json.Value,185        allocator,186        \\{"schema":"tiny.profiling.experiment/v1","name":"startup",187        \\ "scenario":{"schema":"tiny.profiling.scenario/v1","name":"cli",188        \\   "argv":["{binary}"]},189        \\ "baseline":{"ref":"main"},"candidate":{"binary":"candidate"},190        \\ "metric":"wall_ns","practical_effect_percent":5,"seed":42}191    ,192        .{},193    );194    try std.testing.expectError(195        error.RefCommandRequiresBuild,196        parse(allocator, value),197    );198}

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