tiny.trace.TraceWriterStorage

1pub const Storage = struct {2    phase: alloc_phase.capacity.Phase,3    capacity: capacity_mod.Capacity,4    bytes: []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 = @import("storage.zig").Exhaustion;10    pub const InitError = std.mem.Allocator.Error || capacity_mod.DeriveError;1112    pub const claim: alloc_phase.capacity.Declaration = .{13        .source = .{14            .id = "trace.trace_writer_storage",15            .kind = .phase_static,16            .limit_source = .caller,17            .storage = .{18                .covered = &.{19                    .{20                        .id = "retained_trace_path_and_manifest_identity_bytes",21                        .lifetime = .steady,22                        .detail = "retained trace path and manifest identity bytes",23                    },24                    .{25                        .id = "phase_shared_bounded_binary_event_block_and_manifes_21808f4010ec",26                        .lifetime = .steady,27                        .detail = "phase-shared bounded binary event block and manifest encoding scratch",28                    },29                    .{30                        .id = "manifest_file_i_o_and_two_simultaneous_path_construction_buffers",31                        .lifetime = .steady,32                        .detail = "manifest file I/O and two simultaneous path-construction buffers",33                    },34                    .{35                        .id = "bounded_lib_sql_wal_pager_transaction_and_checkpoint_heap",36                        .lifetime = .steady,37                        .detail = "bounded lib/sql WAL pager transaction and checkpoint heap",38                    },39                },40                .excluded = &.{41                    "filesystem implementation and kernel file state",42                    "recording Session state and event payload pointees",43                    "trace reader parsing and replay storage",44                },45            },46            .capacity = .{47                .inputs = &.{48                    alloc_phase.capacity.bindInput(Limits, "build_id_bytes", "build_id_bytes"),49                    alloc_phase.capacity.bindInput(Limits, "endian_bytes", "endian_bytes"),50                    alloc_phase.capacity.bindInput(Limits, "event_bytes", "event_bytes"),51                    alloc_phase.capacity.bindInput(Limits, "manifest_io_bytes", "manifest_io_bytes"),52                    alloc_phase.capacity.bindInput(Limits, "mode_bytes", "mode_bytes"),53                    alloc_phase.capacity.bindInput(Limits, "root_path_bytes", "root_path_bytes"),54                    alloc_phase.capacity.bindInput(Limits, "target_triple_bytes", "target_triple_bytes"),55                },56                .type_selectors = &.{},57                .nodes = &.{58                    .{ .input = 0 },59                    .{ .input = 1 },60                    .{ .input = 2 },61                    .{ .input = 3 },62                    .{ .input = 4 },63                    .{ .input = 5 },64                    .{ .input = 6 },65                    .{ .add = .{ .left = 0, .right = 1 } },66                    .{ .add = .{ .left = 7, .right = 2 } },67                    .{ .add = .{ .left = 8, .right = 3 } },68                    .{ .add = .{ .left = 9, .right = 4 } },69                    .{ .add = .{ .left = 10, .right = 5 } },70                    .{ .add = .{ .left = 11, .right = 6 } },71                },72                .assertions = &.{.{73                    .scope = .closure_total,74                    .measure = .retained,75                    .relation = .upper_bound,76                    .expression = 12,77                }},78            },79            .overload = .{80                .kind = .reject_before_mutation,81                .detail = "open rejects every retained byte region at max plus one before acquiring storage or mutating the trace path",82            },83            .risks = .{84                .transitive = .{85                    .status = .witnessed,86                    .detail = "open, binary block encode, SQL append, bounded checkpoint, and finish consume only preflighted writer regions after activation",87                },88                .foreign = .{89                    .status = .excluded,90                    .detail = "filesystem calls and kernel buffering remain effects outside the caller allocator and this storage owner",91                },92            },93            .dependencies = &.{ "sql.wal_writer", "sql.file_transaction_staging" },94            .obligations = &.{95                .{ .key = "trace_trace_writer_capacity", .role = .capacity_model },96                .{ .key = "trace_trace_writer_acquisition", .role = .custom },97                .{ .key = "trace_trace_writer_oom", .role = .custom },98                .{ .key = "trace_trace_writer_boundary", .role = .overload },99                .{ .key = "trace_trace_writer_open_atomic", .role = .overload },100                .{ .key = "trace_trace_writer_sealed", .role = .transitive_risk },101                .{ .key = "trace_trace_writer_rollover", .role = .foreign_risk },102                .{ .key = "trace_trace_writer_root", .role = .custom },103                .{ .key = "trace_trace_writer_tuning", .role = .custom },104            },105        },106        .bindings = .{107            .owner = @This(),108            .seal = .{109                .family = alloc_phase.capacity.selector(@This().activate),110                .premise = .{111                    .class = .checked_semantic_fact,112                    .authority = .checker,113                },114            },115            .teardown = .{116                .family = alloc_phase.capacity.selector(@This().deinit),117                .premise = .{118                    .class = .checked_semantic_fact,119                    .authority = .checker,120                },121            },122        },123    };124125    pub fn init(allocator: std.mem.Allocator, limits: Limits) InitError!Storage {126        const capacity = try Capacity.derive(limits);127        return .{128            .phase = .initialization,129            .capacity = capacity,130            .bytes = try allocator.alloc(u8, capacity.storage_bytes),131        };132    }133134    pub fn activate(self: *Storage) void {135        std.debug.assert(self.phase == .initialization);136        std.debug.assert(self.bytes.len == self.capacity.storage_bytes);137        self.phase = .steady;138    }139140    pub fn acquire(self: *Storage, usage: Usage) Storage.Exhaustion!Regions {141        std.debug.assert(self.phase == .steady);142        if (self.in_use) return error.WriterStorageInUse;143        if (usage.root_path_bytes > self.capacity.root_path_bytes) return error.RootPathCapacityExceeded;144        if (usage.target_triple_bytes > self.capacity.target_triple_bytes) return error.TargetTripleCapacityExceeded;145        if (usage.build_id_bytes > self.capacity.build_id_bytes) return error.BuildIdCapacityExceeded;146        if (usage.mode_bytes > self.capacity.mode_bytes) return error.ModeCapacityExceeded;147        if (usage.endian_bytes > self.capacity.endian_bytes) return error.EndianCapacityExceeded;148        if (usage.event_bytes > self.capacity.event_bytes) return error.EventCapacityExceeded;149        self.in_use = true;150        return .{151            .root_path = self.region(self.capacity.root_path_offset, usage.root_path_bytes),152            .target_triple = self.region(self.capacity.target_triple_offset, usage.target_triple_bytes),153            .build_id = self.region(self.capacity.build_id_offset, usage.build_id_bytes),154            .mode = self.region(self.capacity.mode_offset, usage.mode_bytes),155            .endian = self.region(self.capacity.endian_offset, usage.endian_bytes),156            .block = self.region(self.capacity.block_offset, self.capacity.block_bytes),157            .manifest_io = self.region(self.capacity.manifest_io_offset, self.capacity.manifest_io_bytes),158            .sql = self.region(self.capacity.sql_offset, self.capacity.sql_bytes),159            .manifest = self.region(self.capacity.manifest_offset, self.capacity.manifest_bytes),160            .paths = .{161                self.region(self.capacity.path_offsets[0], self.capacity.path_bytes),162                self.region(self.capacity.path_offsets[1], self.capacity.path_bytes),163            },164        };165    }166167    pub fn release(self: *Storage) void {168        std.debug.assert(self.phase == .steady);169        std.debug.assert(self.in_use);170        self.in_use = false;171    }172173    pub fn status(self: *const Storage) Status {174        return .{175            .phase = self.phase,176            .in_use = self.in_use,177            .storage_bytes = self.capacity.storage_bytes,178            .event_bytes = self.capacity.event_bytes,179            .block_bytes = self.capacity.block_bytes,180            .manifest_io_bytes = self.capacity.manifest_io_bytes,181            .sql_bytes = self.capacity.sql_bytes,182        };183    }184185    pub fn deinit(self: *Storage, allocator: std.mem.Allocator) void {186        std.debug.assert(self.phase != .teardown);187        std.debug.assert(!self.in_use);188        std.debug.assert(self.bytes.len == self.capacity.storage_bytes);189        self.phase = .teardown;190        allocator.free(self.bytes);191        self.bytes = &.{};192    }193194    fn region(self: *Storage, offset: usize, count: usize) []u8 {195        return self.bytes[offset..][0..count];196    }197};

1pub const TraceWriterStorage = store.WriterStorage;