tiny.choir.Context

1pub const Context = struct {2    phase: alloc_phase.capacity.Phase,3    capacity: Capacity,4    storage: [*]u8,5    memory: *memory_ctx.Memory,6    operation_storage_allocator: [@sizeOf(core.Operation.StorageAllocator)]u8 align(@alignOf(core.Operation.StorageAllocator)),7    dialect_registry: dialects.DialectRegistry,8    trait_registry: interfaces.TraitRegistry,9    type_interner: types.TypeInterner,10    attr_interner: attrs.AttributeInterner,11    resources: resources.Tracker,12    type_param_cache: types.TypeParamCache,13    dialect_load_transactions: std.ArrayListUnmanaged(transactions.DialectLoadTransaction),14    freeze_policy: freeze_ctx.Policy,15    threading_execution: threading.ExecutionState,16    diagnostic_engine: diagnostics.Engine,17    pass_runs: std.atomic.Value(PassRunAtomicInt),18    arithmetic_policy: interfaces.effects.ArithmeticPolicy = .{},1920    pub const Limits = memory_ctx.Limits;21    pub const minimum_alignment = memory_ctx.minimum_alignment;22    pub const maximum_storage_bytes = memory_ctx.maximum_storage_bytes;23    pub const Refusal = memory_ctx.Refusal;24    pub const refusal = memory_ctx.refusal;25    pub const Capacity = memory_ctx.Capacity;26    pub const Segment = memory_ctx.Segment;27    pub const Usage = memory_ctx.Usage;28    pub const Exhausted = memory_ctx.Exhausted;29    pub const InFlightDiagnostic = diagnostics.BoundInFlightDiagnostic(30        Context,31        diagnosticPayloadAllocator,32    );33    pub const Exhaustion = error{OutOfMemory};34    pub const InitError = error{ CapacityOverflow, OutOfMemory };3536    pub const claim: alloc_phase.capacity.Declaration = .{37        .source = .{38            .id = "choir.context",39            .kind = .phase_static,40            .limit_source = .caller,41            .storage = .{42                .covered = &.{43                    .{44                        .id = "dialect_registry_trait_and_configuration_table_storage",45                        .lifetime = .steady,46                        .detail = "dialect, registry, trait, and configuration table storage",47                    },48                    .{49                        .id = "interned_dialect_names",50                        .lifetime = .steady,51                        .detail = "interned dialect names",52                    },53                    .{54                        .id = "operation_type_attribute_and_dialect_interface_definitions",55                        .lifetime = .steady,56                        .detail = "operation, type, attribute, and dialect interface definitions",57                    },58                    .{59                        .id = "dialect_registration_transaction_journals",60                        .lifetime = .initialization,61                        .detail = "dialect registration transaction journals",62                    },63                    .{64                        .id = "interned_type_tables",65                        .lifetime = .steady,66                        .detail = "interned type tables",67                    },68                    .{69                        .id = "type_names_and_parameter_keys",70                        .lifetime = .steady,71                        .detail = "type names and parameter keys",72                    },73                    .{74                        .id = "type_objects_and_parsed_parameter_payloads",75                        .lifetime = .steady,76                        .detail = "type objects and parsed parameter payloads",77                    },78                    .{79                        .id = "interned_attribute_tables",80                        .lifetime = .steady,81                        .detail = "interned attribute tables",82                    },83                    .{84                        .id = "attribute_objects_and_retained_payloads",85                        .lifetime = .steady,86                        .detail = "attribute objects and retained payloads",87                    },88                    .{89                        .id = "fixed_shape_operation_storage_pools",90                        .lifetime = .steady,91                        .detail = "fixed-shape operation storage pools",92                    },93                    .{94                        .id = "regions_blocks_properties_operands_successors_and_o_5b44c1ea68c9",95                        .lifetime = .steady,96                        .detail = "regions, blocks, properties, operands, successors, and operation spills",97                    },98                    .{99                        .id = "diagnostic_handler_registry",100                        .lifetime = .steady,101                        .detail = "diagnostic handler registry",102                    },103                    .{104                        .id = "in_flight_diagnostic_messages_notes_and_metadata",105                        .lifetime = .steady,106                        .detail = "in-flight diagnostic messages, notes, and metadata",107                    },108                    .{109                        .id = "bounded_transient_formatting_parsing_verification_a_52aa670b3999",110                        .lifetime = .initialization,111                        .detail = "bounded transient formatting, parsing, verification, and lowering work",112                    },113                },114                .excluded = &.{115                    "caller allocator implementation state and an optional stable Context handle",116                    "caller-owned diagnostic capture buffers and foreign interface vtable state",117                    "pass managers, backends, extension registries, and other owners constructed beside Context",118                },119            },120            .capacity = .{121                .inputs = &.{122                    alloc_phase.capacity.bindInput(Limits, "attributes_payload_bytes", "attributes.payload_bytes"),123                    alloc_phase.capacity.bindInput(Limits, "attributes_table_bytes", "attributes.table_bytes"),124                    alloc_phase.capacity.bindInput(Limits, "configuration_interface_bytes", "configuration.interface_bytes"),125                    alloc_phase.capacity.bindInput(Limits, "configuration_name_bytes", "configuration.name_bytes"),126                    alloc_phase.capacity.bindInput(Limits, "configuration_table_bytes", "configuration.table_bytes"),127                    alloc_phase.capacity.bindInput(Limits, "configuration_transaction_bytes", "configuration.transaction_bytes"),128                    alloc_phase.capacity.bindInput(Limits, "diagnostics_handler_bytes", "diagnostics.handler_bytes"),129                    alloc_phase.capacity.bindInput(Limits, "diagnostics_payload_bytes", "diagnostics.payload_bytes"),130                    alloc_phase.capacity.bindInput(Limits, "operations_nested_bytes", "operations.nested_bytes"),131                    alloc_phase.capacity.bindInput(Limits, "operations_storage_bytes", "operations.storage_bytes"),132                    alloc_phase.capacity.bindInput(Limits, "transient_bytes", "transient_bytes"),133                    alloc_phase.capacity.bindInput(Limits, "types_key_bytes", "types.key_bytes"),134                    alloc_phase.capacity.bindInput(Limits, "types_payload_bytes", "types.payload_bytes"),135                    alloc_phase.capacity.bindInput(Limits, "types_table_bytes", "types.table_bytes"),136                },137                .type_selectors = &.{},138                .nodes = &.{139                    .{ .input = 0 },140                    .{ .input = 1 },141                    .{ .input = 2 },142                    .{ .input = 3 },143                    .{ .input = 4 },144                    .{ .input = 5 },145                    .{ .input = 6 },146                    .{ .input = 7 },147                    .{ .input = 8 },148                    .{ .input = 9 },149                    .{ .input = 10 },150                    .{ .input = 11 },151                    .{ .input = 12 },152                    .{ .input = 13 },153                    .{ .add = .{ .left = 0, .right = 1 } },154                    .{ .add = .{ .left = 14, .right = 2 } },155                    .{ .add = .{ .left = 15, .right = 3 } },156                    .{ .add = .{ .left = 16, .right = 4 } },157                    .{ .add = .{ .left = 17, .right = 5 } },158                    .{ .add = .{ .left = 18, .right = 6 } },159                    .{ .add = .{ .left = 19, .right = 7 } },160                    .{ .add = .{ .left = 20, .right = 8 } },161                    .{ .add = .{ .left = 21, .right = 9 } },162                    .{ .add = .{ .left = 22, .right = 10 } },163                    .{ .add = .{ .left = 23, .right = 11 } },164                    .{ .add = .{ .left = 24, .right = 12 } },165                    .{ .add = .{ .left = 25, .right = 13 } },166                },167                .assertions = &.{.{168                    .scope = .closure_total,169                    .measure = .retained,170                    .relation = .upper_bound,171                    .expression = 26,172                }},173            },174            .overload = .{175                .kind = .reject_before_mutation,176                .detail = "steady OutOfMemory denotes exhaustion of one named fixed segment; capacity arithmetic and allocation admissions fail before publishing partial state",177            },178            .risks = .{179                .transitive = .{180                    .status = .witnessed,181                    .detail = "all Context-retained nested owners draw from the named fixed segments acquired at construction",182                },183                .foreign = .{184                    .status = .excluded,185                    .detail = "opaque interface state and caller-owned diagnostic capture storage remain owned by their supplying APIs",186                },187            },188            .dependencies = &.{"choir.operation_fixed_storage"},189            .obligations = &.{190                .{ .key = "choir_context_capacity", .role = .capacity_model },191                .{ .key = "choir_context_capacity_overflow", .role = .overload },192                .{ .key = "choir_context_single_acquisition", .role = .transitive_risk },193                .{ .key = "choir_context_initialization_retry", .role = .overload },194                .{ .key = "choir_context_operation_exhaustion_overload", .role = .overload },195                .{ .key = "choir_context_operation_exhaustion_transitive_risk", .role = .transitive_risk },196                .{ .key = "choir_context_spill_exhaustion", .role = .overload },197                .{ .key = "choir_context_foreign_ownership", .role = .foreign_risk },198                .{ .key = "choir_context_diagnostic_exhaustion", .role = .overload },199                .{ .key = "choir_context_lazy_param_exhaustion", .role = .overload },200                .{ .key = "choir_context_attribute_exhaustion", .role = .overload },201            },202        },203        .bindings = .{204            .owner = @This(),205            .seal = .{206                .family = alloc_phase.capacity.selector(@This().activate),207                .premise = .{208                    .class = .checked_semantic_fact,209                    .authority = .checker,210                },211            },212            .teardown = .{213                .family = alloc_phase.capacity.selector(@This().deinit),214                .premise = .{215                    .class = .checked_semantic_fact,216                    .authority = .checker,217                },218            },219        },220    };221222    pub const Error = error{223        ContextFrozen,224        ContextMutationDuringMultithreadedExecution,225        UnknownDialect,226        DialectLoadCycle,227        UnknownOperation,228        UnknownType,229        DuplicateDialectLoader,230        DuplicateInterface,231        BackendDialectRequired,232        InvalidTranslationDialect,233    } || std.mem.Allocator.Error;234235    pub const RegisterTraitDefinitionError = Error || interfaces.TraitRegistry.RegisterError;236237    pub const RegisterError = Error || interfaces.OperationRegistry.GetOrCreateError || interfaces.OperationRegistry.RegisterInterfaceError;238    pub const RegisterTraitError = Error || interfaces.OperationRegistry.RegisterTraitError;239    pub const RegisterInherentAttributeNameError = Error || interfaces.OperationRegistry.RegisterInherentAttributeNameError;240    pub const RegisterTypeConstraintError = Error || interfaces.OperationRegistry.RegisterTypeConstraintError;241    pub const RegisterSegmentSpecError = Error || interfaces.OperationRegistry.RegisterSegmentSpecError;242    pub const RegisterTypeError = Error || interfaces.TypeRegistry.GetOrCreateError || interfaces.TypeRegistry.RegisterInterfaceError;243    pub const RegisterAttributeError = Error || interfaces.AttributeRegistry.RegisterError;244245    pub fn init(allocator: std.mem.Allocator, limits: Limits) InitError!Context {246        const capacity = try Capacity.derive(limits);247        const storage = allocator.rawAlloc(248            capacity.storage_bytes,249            capacity.storage_alignment,250            @returnAddress(),251        ) orelse return error.OutOfMemory;252        const memory = memory_ctx.Memory.init(storage, capacity);253        var context = Context{254            .phase = .initialization,255            .capacity = capacity,256            .storage = storage,257            .memory = memory,258            .operation_storage_allocator = undefined,259            .dialect_registry = dialects.DialectRegistry.init(260                memory.configuration_tables.allocator(),261                memory.configuration_interfaces.allocator(),262            ),263            .trait_registry = interfaces.TraitRegistry.init(),264            .type_interner = types.TypeInterner.init(265                memory.type_tables.allocator(),266                memory.type_keys.allocator(),267            ),268            .attr_interner = attrs.AttributeInterner.init(269                memory.attribute_tables.allocator(),270                memory.configuration_interfaces.allocator(),271            ),272            .resources = resources.Tracker.init(),273            .type_param_cache = .{},274            .dialect_load_transactions = .empty,275            .freeze_policy = freeze_ctx.Policy.init(),276            .threading_execution = threading.ExecutionState.init(),277            .diagnostic_engine = diagnostics.Engine.init(),278            .pass_runs = std.atomic.Value(PassRunAtomicInt).init(0),279        };280        operationStorageAllocator(&context).* = core.Operation.StorageAllocator.init(281            memory_ctx.operationStorageAllocator(context.memory),282        );283        return context;284    }285286    pub fn create(allocator: std.mem.Allocator, limits: Limits) InitError!*Context {287        const self = try allocator.create(Context);288        errdefer allocator.destroy(self);289        self.* = try init(allocator, limits);290        return self;291    }292293    pub fn activate(self: *Context) void {294        std.debug.assert(self.phase == .initialization);295        self.freeze();296        self.phase = .steady;297    }298299    pub fn capacityUsage(self: *const Context) Usage {300        return memory_ctx.cast(self.memory).usage();301    }302303    pub fn exhaustedSegment(self: *const Context) ?Segment {304        return memory_ctx.cast(self.memory).exhausted_segment;305    }306307    /// The segment a request found full and the size of that request, or308    /// null when no request has failed since the last `clearExhaustion`.309    pub fn exhaustion(self: *const Context) ?Exhausted {310        return memory_ctx.cast(self.memory).exhaustion();311    }312313    pub fn clearExhaustion(self: *Context) void {314        memory_ctx.cast(self.memory).exhausted_segment = null;315        memory_ctx.cast(self.memory).exhausted_request = 0;316    }317318    pub fn requireCapacity(319        self: *Context,320        segment: Segment,321        bytes: usize,322        alignment: std.mem.Alignment,323    ) Exhaustion!void {324        const memory = memory_ctx.cast(self.memory);325        if (!memory.hasCapacity(segment, bytes, alignment)) {326            memory.exhausted_segment = segment;327            memory.exhausted_request = bytes;328            return error.OutOfMemory;329        }330    }331332    pub fn deinit(self: *Context, allocator: std.mem.Allocator) void {333        std.debug.assert(self.phase != .teardown);334        self.resources.deinit();335        operationStorageAllocator(self).deinit();336        self.deinitTypeParamCache();337        transactions.deinitAll(self);338        self.trait_registry.deinit(memory_ctx.configurationTableAllocator(self.memory));339        self.dialect_registry.deinit(340            memory_ctx.configurationTableAllocator(self.memory),341            memory_ctx.configurationNameAllocator(self.memory),342            memory_ctx.configurationInterfaceAllocator(self.memory),343        );344        self.type_interner.deinit(345            memory_ctx.typeTableAllocator(self.memory),346            memory_ctx.typeKeyAllocator(self.memory),347            memory_ctx.typePayloadAllocator(self.memory),348        );349        self.attr_interner.deinit(memory_ctx.attributePayloadAllocator(self.memory));350        self.diagnostic_engine.deinit(memory_ctx.diagnosticHandlerAllocator(self.memory));351        const storage = self.storage;352        const capacity = self.capacity;353        self.phase = .teardown;354        self.* = undefined;355        allocator.rawFree(356            storage[0..capacity.storage_bytes],357            capacity.storage_alignment,358            @returnAddress(),359        );360    }361362    pub fn registerTraitDefinition(self: *Context, entry: interfaces.TraitEntry) RegisterTraitDefinitionError!void {363        try freeze_ctx.requireMutable(self);364        try self.trait_registry.register(365            memory_ctx.configurationTableAllocator(self.memory),366            entry,367        );368    }369370    pub fn lookupTrait(self: *const Context, trait_id: interfaces.TraitId) ?*const interfaces.TraitVTable {371        return self.trait_registry.lookup(trait_id);372    }373374    pub fn getDiagnosticEngine(self: *Context) *diagnostics.Engine {375        return &self.diagnostic_engine;376    }377378    pub fn registerDiagnosticHandler(379        self: *Context,380        handler: diagnostics.Handler,381    ) !diagnostics.Engine.HandlerId {382        return self.diagnostic_engine.registerHandler(383            memory_ctx.diagnosticHandlerAllocator(self.memory),384            handler,385        );386    }387388    pub fn eraseDiagnosticHandler(self: *Context, id: diagnostics.Engine.HandlerId) void {389        self.diagnostic_engine.eraseHandler(id);390    }391392    pub fn emitDiagnostic(393        self: *Context,394        diagnostic: diagnostics.Diagnostic,395    ) InFlightDiagnostic {396        return .{397            .context = self,398            .diagnostic = self.diagnostic_engine.emit(diagnostic),399        };400    }401402    pub fn captureDiagnostics(403        self: *Context,404        buffer: *diagnostics.CaptureBuffer,405    ) diagnostics.CaptureScope {406        return self.diagnostic_engine.capture(buffer);407    }408409    pub fn replayDiagnostics(410        self: *Context,411        buffer: *const diagnostics.CaptureBuffer,412    ) !diagnostics.HandlerResult {413        return self.diagnostic_engine.replay(buffer);414    }415416    pub fn enterMultithreadedExecution(self: *Context) threading.ExecutionGuard {417        return self.threading_execution.enter();418    }419420    pub fn isMultithreadedExecution(self: *const Context) bool {421        return self.threading_execution.isActive();422    }423424    pub fn recordPassRuns(self: *Context, additional: u64) void {425        var current = self.pass_runs.load(.monotonic);426        while (true) {427            const next = saturatingPassRunAdd(PassRunAtomicInt, current, additional);428            if (self.pass_runs.cmpxchgWeak(429                current,430                next,431                .monotonic,432                .monotonic,433            )) |observed| {434                current = observed;435            } else {436                return;437            }438        }439    }440441    pub fn passRunCount(self: *const Context) u64 {442        return @intCast(self.pass_runs.load(.monotonic));443    }444445    fn deinitTypeParamCache(self: *Context) void {446        var iter = self.type_param_cache.valueIterator();447        while (iter.next()) |payload| {448            payload.deinit(memory_ctx.typePayloadAllocator(self.memory), payload.ptr);449        }450        self.type_param_cache.deinit(memory_ctx.typeTableAllocator(self.memory));451    }452453    pub const appendDialectRegistry = dialect_ctx.appendDialectRegistry;454    pub const registerDialectLoader = dialect_ctx.registerDialectLoader;455    pub const registerBackendDialect = dialect_ctx.registerBackendDialect;456    pub const isBackendDialect = dialect_ctx.isBackendDialect;457    pub const addDialectExtension = dialect_ctx.addDialectExtension;458    pub const getOrLoadDialect = dialect_ctx.getOrLoadDialect;459    pub const isDialectLoaded = dialect_ctx.isDialectLoaded;460    pub const getDialect = dialect_ctx.getDialect;461    pub const ensureDialectForOperation = dialect_ctx.ensureDialectForOperation;462    pub const prepareDialectLoadRecordStorage = transactions.prepareRecordStorage;463    pub const registerDialectInterface = interface_ctx.registerDialectInterface;464    pub const getDialectInterface = interface_ctx.getDialectInterface;465    pub const registerDialectOpInterfaceFallback = interface_ctx.registerDialectOpInterfaceFallback;466    pub const getDialectOpInterfaceFallback = interface_ctx.getDialectOpInterfaceFallback;467    pub const registerDialectTypeInterfaceFallback = interface_ctx.registerDialectTypeInterfaceFallback;468    pub const getDialectTypeInterfaceFallback = interface_ctx.getDialectTypeInterfaceFallback;469    pub const requireRegistered = policy_ctx.requireRegistered;470    pub const allowUnregistered = policy_ctx.allowUnregistered;471    pub const getOperationRegistry = ops_ctx.getOperationRegistry;472    pub const lookupOperation = ops_ctx.lookupOperation;473    pub const registerOperation = ops_ctx.registerOperation;474    pub const registerOperationWithAttributeNameCapacity = ops_ctx.registerOperationWithAttributeNameCapacity;475    pub const registerOperationBatch = ops_ctx.registerOperationBatch;476    pub const registerOperationInterface = ops_ctx.registerOperationInterface;477    pub const registerOperationInterfaceExternal = ops_ctx.registerOperationInterfaceExternal;478    pub const registerOperationInherentAttributeName = ops_ctx.registerOperationInherentAttributeName;479    pub const registerOperationInherentAttributeNames = ops_ctx.registerOperationInherentAttributeNames;480    pub const registerOperationRequiredAttributeName = ops_ctx.registerOperationRequiredAttributeName;481    pub const registerOperationRequiredAttributeNames = ops_ctx.registerOperationRequiredAttributeNames;482    pub const registerOperationPropertiesModel = ops_ctx.registerOperationPropertiesModel;483    pub const registerOperationShape = ops_ctx.registerOperationShape;484    pub const registerOperationOperandSegments = ops_ctx.registerOperationOperandSegments;485    pub const registerOperationResultSegments = ops_ctx.registerOperationResultSegments;486    pub const registerOperationOperandTypeConstraint = ops_ctx.registerOperationOperandTypeConstraint;487    pub const registerOperationResultTypeConstraint = ops_ctx.registerOperationResultTypeConstraint;488    pub const registerOperationTraitId = ops_ctx.registerOperationTraitId;489    pub const registerOperationTrait = ops_ctx.registerOperationTrait;490    pub const allocateValueId = resources.allocateValueId;491    pub const operationCount = resources.operationCount;492    pub const operationCreationBoundary = resources.operationCreationBoundary;493    pub const eraseOperationsCreatedSince = resources.eraseOperationsCreatedSince;494    pub const containsOperation = resources.containsOperation;495    pub const createOperation = ops_ctx.createOperation;496    pub const untrackOperation = resources.untrackOperation;497    pub const getTypeRegistry = type_ctx.getTypeRegistry;498    pub const lookupType = type_ctx.lookupType;499    pub const registerType = type_ctx.registerType;500    pub const registerTypeBatch = type_ctx.registerTypeBatch;501    pub const registerTypeInterface = type_ctx.registerTypeInterface;502    pub const registerTypeInterfaceExternal = type_ctx.registerTypeInterfaceExternal;503    pub fn TypeInterfaceHandle(comptime IFace: type) type {504        return type_ctx.TypeInterfaceHandle(Context, IFace);505    }506    pub const typeInterface = type_ctx.typeInterface;507    pub const getTypeInterface = type_ctx.getTypeInterface;508    pub const getTypeParamPayloadRaw = type_ctx.getTypeParamPayloadRaw;509    pub const getTypeParamPayload = type_ctx.getTypeParamPayload;510    pub const getDialectType = type_ctx.getDialectType;511    pub const getDialectTypeWithKey = type_ctx.getDialectTypeWithKey;512    pub const getDialectTypeFromName = type_ctx.getDialectTypeFromName;513    pub const getDialectTypeFromNameWithKey = type_ctx.getDialectTypeFromNameWithKey;514    pub const lookupAttributeType = attr_ctx.lookupAttributeType;515    pub const registerAttributeType = attr_ctx.registerAttributeType;516    pub const registerAttributeInterfaceExternal = attr_ctx.registerAttributeInterfaceExternal;517    pub const getDialectAttr = attr_ctx.getDialectAttr;518    pub const getIntegerAttr = attr_ctx.getIntegerAttr;519    pub const getI64Attr = attr_ctx.getI64Attr;520    pub const getI32Attr = attr_ctx.getI32Attr;521    pub const getFloatAttr = attr_ctx.getFloatAttr;522    pub const getF64Attr = attr_ctx.getF64Attr;523    pub const getF32Attr = attr_ctx.getF32Attr;524    pub const getBoolAttr = attr_ctx.getBoolAttr;525    pub const getStringAttr = attr_ctx.getStringAttr;526    pub const getSymbolRefAttr = attr_ctx.getSymbolRefAttr;527    pub const getFlatSymbolRefAttr = attr_ctx.getFlatSymbolRefAttr;528    pub const getStringListAttr = attr_ctx.getStringListAttr;529    pub const getTypeListAttr = attr_ctx.getTypeListAttr;530    pub const getArrayAttr = attr_ctx.getArrayAttr;531    pub const freeze = freeze_ctx.freeze;532    pub const isFrozen = freeze_ctx.isFrozen;533};

1pub const Context = ir.Context;