tiny.bench.ComparisonStorage

1pub const Storage = struct {2    phase: alloc_phase.capacity.Phase,3    capacity: capacity_mod.Capacity,4    bytes: []align(capacity_mod.storage_alignment) u8,5    in_use: bool = false,67    pub const Limits: type = capacity_mod.Limits;8    pub const Capacity: type = capacity_mod.Capacity;9    pub const Exhaustion: type = storage_exhaustion;10    pub const InitError = std.mem.Allocator.Error || capacity_mod.DeriveError;11    pub const AcquireError: type = Error;1213    pub const claim: alloc_phase.capacity.Declaration = .{14        .source = .{15            .id = "bench.comparison_storage",16            .kind = .phase_static,17            .limit_source = .caller,18            .storage = .{19                .covered = &.{20                    .{21                        .id = "bootstrap_effect_distribution_scratch",22                        .lifetime = .steady,23                        .detail = "bootstrap effect distribution scratch",24                    },25                    .{26                        .id = "median_and_resampling_sample_scratch",27                        .lifetime = .steady,28                        .detail = "median and resampling sample scratch",29                    },30                    .{31                        .id = "bootstrap_multiplicity_scratch",32                        .lifetime = .steady,33                        .detail = "bootstrap multiplicity scratch",34                    },35                },36                .excluded = &.{37                    "caller-owned parsed comparison datasets",38                    "caller-owned comparison rows and report output",39                },40            },41            .capacity = .{42                .inputs = &.{43                    alloc_phase.capacity.bindInput(Limits, "max_bootstrap_iterations", "max_bootstrap_iterations"),44                    alloc_phase.capacity.bindInput(Limits, "max_samples_per_series", "max_samples_per_series"),45                },46                .type_selectors = &.{47                    alloc_phase.capacity.bindType(f64, "f64"),48                    alloc_phase.capacity.bindType(u64, "u64"),49                    alloc_phase.capacity.bindType(u32, "u32"),50                },51                .nodes = &.{52                    .{ .input = 0 },53                    .{ .scale = .{ .node = 0, .coefficient = .{ .size_of_concrete_type = 0 } } },54                    .{ .constant = 1 },55                    .{ .scale = .{ .node = 2, .coefficient = .{ .size_of_concrete_type = 0 } } },56                    .{ .scale = .{ .node = 2, .coefficient = .{ .size_of_concrete_type = 1 } } },57                    .{ .maximum = .{ .left = 3, .right = 4 } },58                    .{ .scale = .{ .node = 2, .coefficient = .{ .size_of_concrete_type = 2 } } },59                    .{ .add = .{ .left = 5, .right = 6 } },60                    .{ .input = 1 },61                    .{ .product = .{ .left = 8, .right = 7 } },62                    .{ .add = .{ .left = 1, .right = 9 } },63                },64                .assertions = &.{.{65                    .scope = .closure_total,66                    .measure = .retained,67                    .relation = .exact,68                    .expression = 10,69                }},70            },71            .overload = .{72                .kind = .reject_before_mutation,73                .detail = "empty, zero-iteration, oversize, and concurrent requests fail before workspace mutation",74            },75            .risks = .{76                .transitive = .{77                    .status = .witnessed,78                    .detail = "f64 and u64 median sorting and bootstrap multiplicities use only slices acquired from the sealed region",79                },80                .foreign = .{81                    .status = .excluded,82                    .detail = "comparison analysis crosses no operating-system or foreign callback boundary",83                },84            },85            .obligations = &.{86                .{ .key = "bench_comparison_capacity", .role = .capacity_model },87                .{ .key = "bench_comparison_acquisition", .role = .custom },88                .{ .key = "bench_comparison_oom", .role = .custom },89                .{ .key = "bench_comparison_boundaries", .role = .overload },90                .{ .key = "bench_comparison_reuse", .role = .overload },91                .{ .key = "bench_comparison_sealed_f64_transitive_risk", .role = .transitive_risk },92                .{ .key = "bench_comparison_sealed_f64_foreign_risk", .role = .foreign_risk },93                .{ .key = "bench_comparison_rows", .role = .custom },94                .{ .key = "bench_comparison_sealed_u64", .role = .transitive_risk },95                .{ .key = "bench_comparison_command", .role = .custom },96            },97        },98        .bindings = .{99            .owner = @This(),100            .seal = .{101                .family = alloc_phase.capacity.selector(@This().activate),102                .premise = .{103                    .class = .checked_semantic_fact,104                    .authority = .checker,105                },106            },107            .teardown = .{108                .family = alloc_phase.capacity.selector(@This().deinit),109                .premise = .{110                    .class = .checked_semantic_fact,111                    .authority = .checker,112                },113            },114        },115    };116117    pub fn init(allocator: std.mem.Allocator, limits: Limits) InitError!Storage {118        const capacity = try Capacity.derive(limits);119        const bytes = try allocator.alignedAlloc(120            u8,121            .fromByteUnits(capacity_mod.storage_alignment),122            capacity.storage_bytes,123        );124        return .{125            .phase = .initialization,126            .capacity = capacity,127            .bytes = bytes,128        };129    }130131    pub fn activate(self: *Storage) void {132        std.debug.assert(self.phase == .initialization);133        std.debug.assert(self.bytes.len == self.capacity.storage_bytes);134        self.phase = .steady;135    }136137    pub fn acquireF64(138        self: *Storage,139        base_samples: usize,140        candidate_samples: usize,141        bootstrap_iterations: u32,142    ) AcquireError!F64Regions {143        const sample_count = try self.beginComparison(144            base_samples,145            candidate_samples,146            bootstrap_iterations,147        );148        return .{149            .effects = typedSlice(150                f64,151                self.bytes,152                self.capacity.effects_offset,153                bootstrap_iterations,154            ),155            .samples = typedSlice(156                f64,157                self.bytes,158                self.capacity.samples_offset,159                sample_count,160            ),161            .counts = typedSlice(162                u32,163                self.bytes,164                self.capacity.counts_offset,165                sample_count,166            ),167        };168    }169170    pub fn acquireU64(171        self: *Storage,172        base_samples: usize,173        candidate_samples: usize,174        bootstrap_iterations: u32,175    ) AcquireError!U64Regions {176        const sample_count = try self.beginComparison(177            base_samples,178            candidate_samples,179            bootstrap_iterations,180        );181        return .{182            .effects = typedSlice(183                f64,184                self.bytes,185                self.capacity.effects_offset,186                bootstrap_iterations,187            ),188            .samples = typedSlice(189                u64,190                self.bytes,191                self.capacity.samples_offset,192                sample_count,193            ),194            .counts = typedSlice(195                u32,196                self.bytes,197                self.capacity.counts_offset,198                sample_count,199            ),200        };201    }202203    pub fn acquireF64Samples(self: *Storage, sample_count: usize) AcquireError![]f64 {204        std.debug.assert(self.phase == .steady);205        if (self.in_use) return error.ComparisonStorageInUse;206        if (sample_count == 0) return error.EmptySampleSet;207        if (sample_count > self.capacity.limits.max_samples_per_series) {208            return error.SampleCapacityExceeded;209        }210        self.in_use = true;211        return typedSlice(212            f64,213            self.bytes,214            self.capacity.samples_offset,215            sample_count,216        );217    }218219    fn beginComparison(220        self: *Storage,221        base_samples: usize,222        candidate_samples: usize,223        bootstrap_iterations: u32,224    ) AcquireError!usize {225        std.debug.assert(self.phase == .steady);226        if (self.in_use) return error.ComparisonStorageInUse;227        if (base_samples == 0) return error.EmptyBaseSeries;228        if (candidate_samples == 0) return error.EmptyCandidateSeries;229        if (bootstrap_iterations == 0) return error.InvalidBootstrapIterations;230        if (base_samples > self.capacity.limits.max_samples_per_series) {231            return error.BaseSampleCapacityExceeded;232        }233        if (candidate_samples > self.capacity.limits.max_samples_per_series) {234            return error.CandidateSampleCapacityExceeded;235        }236        if (bootstrap_iterations > self.capacity.limits.max_bootstrap_iterations) {237            return error.BootstrapIterationCapacityExceeded;238        }239        self.in_use = true;240        return @max(base_samples, candidate_samples);241    }242243    pub fn reset(self: *Storage) void {244        std.debug.assert(self.phase == .steady);245        std.debug.assert(self.in_use);246        self.in_use = false;247    }248249    pub fn status(self: *const Storage) Status {250        return .{251            .phase = self.phase,252            .in_use = self.in_use,253            .storage_bytes = self.capacity.storage_bytes,254            .max_samples_per_series = self.capacity.limits.max_samples_per_series,255            .max_bootstrap_iterations = self.capacity.limits.max_bootstrap_iterations,256        };257    }258259    pub fn deinit(self: *Storage, allocator: std.mem.Allocator) void {260        std.debug.assert(self.phase != .teardown);261        std.debug.assert(!self.in_use);262        std.debug.assert(self.bytes.len == self.capacity.storage_bytes);263        self.phase = .teardown;264        allocator.free(self.bytes);265        self.bytes = &.{};266    }267};

1pub const ComparisonStorage = compare_mod.Storage;