tiny.accy.preparation.pipeline

1pub const ContractPreparationResult = struct {2    module: *contract.ContractJob,3    elapsed_ns: u64,4    stats: BackendPreparationStats,5    initial_choir_ops: u64,6    semantic_fingerprint: ?u64,7    started_at: i128,8    finished_at: i128,910    pub fn deinit(self: *ContractPreparationResult) void {11        self.module.deinit();12        self.* = undefined;13    }14};

1pub const DispatchPreparationResult = struct {2    module: *dispatch.DispatchJob,3    elapsed_ns: u64,4    stats: BackendPreparationStats,5    /// A caller reads this field to show whether the dispatch plans of two runs look alike. The6    /// field holds a 64-bit summary of the plans made by the dispatch stage, for display in a run7    /// stamp, the per-stage display record built for people reading a run. No product key or reuse8    /// decision reads it.9    plan_fingerprint: u64,1011    pub fn deinit(self: *DispatchPreparationResult) void {12        self.module.deinit();13        self.* = undefined;14    }15};

1pub const KernelPreparationResult = struct {2    module: *kernel_product.KernelJob,3    elapsed_ns: u64,4    stats: BackendPreparationStats,5    /// A caller reads this field to show whether the kernel plans of two runs look alike. The field6    /// holds a 64-bit summary of the kernel outline and generated kernels made by the kernel stage,7    /// for display in run stamps. No product key or reuse decision reads it.8    plan_fingerprint: u64,910    pub fn deinit(self: *KernelPreparationResult) void {11        self.module.deinit();12        self.* = undefined;13    }14};

1pub const MemoryPreparationResult = struct {2    module: *memory_product.MemoryJob,3    elapsed_ns: u64,4    stats: BackendPreparationStats,5    /// A caller reads this field to show whether the memory plans of two runs look alike. The field6    /// holds a 64-bit summary of the buffer, memory-space and layout plans made by the memory7    /// stage, for display in run stamps. No product key or reuse decision reads it.8    plan_fingerprint: u64,910    pub fn deinit(self: *MemoryPreparationResult) void {11        self.module.deinit();12        self.* = undefined;13    }14};

1pub const PipelineError = error{2    PassFailed,3};

1pub const TargetPreparationResult = struct {2    module: *target_product.TargetJob,3    elapsed_ns: u64,4    stats: BackendPreparationStats,5    finished_at: i128,67    pub fn deinit(self: *TargetPreparationResult) void {8        self.module.deinit();9        self.* = undefined;10    }11};

1pub const TensorPreparationResult = struct {2    module: *tensor.TensorJob,3    elapsed_ns: u64,4    stats: BackendPreparationStats,56    pub fn deinit(self: *TensorPreparationResult) void {7        self.module.deinit();8        self.* = undefined;9    }10};

1pub const BackendPreparedJob = struct {2    allocator: std.mem.Allocator,3    ctx: *ir.Context,4    choir_module: *ir.Operation,5    target_module: ?*target_product.TargetJob,6    run: BackendPreparationRun,78    pub fn deinit(self: *BackendPreparedJob) void {9        if (self.target_module) |module| module.deinit();10        self.* = undefined;11    }1213    pub fn passContext(self: *BackendPreparedJob) passes.PassContext {14        return self.target_module.?.passContext();15    }1617    pub fn targetModule(self: *const BackendPreparedJob) !*target_product.TargetJob {18        return self.target_module orelse error.MissingTargetProduct;19    }2021    pub fn kernelizationProduct(self: *const BackendPreparedJob) !*const kernelization.KernelizationAnalysis {22        return (try self.targetModule()).kernelizationProduct();23    }2425    pub fn generatedKernelCount(self: *const BackendPreparedJob) !usize {26        const product = try self.kernelizationProduct();27        return product.kernelCount();28    }2930    pub fn productStamps(self: *const BackendPreparedJob) !BackendPreparationProductStamps {31        return product_mod.stampsFromRun(self.run);32    }3334    pub fn generatedKernelSummary(35        self: *const BackendPreparedJob,36        kernel_index: usize,37    ) !kernelization.GeneratedKernelSummary {38        const product = try self.kernelizationProduct();39        return product.kernelSummary(kernel_index);40    }4142    pub fn generatedKernelProgram(43        self: *const BackendPreparedJob,44        kernel_index: usize,45    ) !*const kernelization.GeneratedKernelProgram {46        const product = try self.kernelizationProduct();47        return product.kernelProgram(kernel_index);48    }4950    pub fn generatedKernelSummaryForWork(51        self: *const BackendPreparedJob,52        work_item_id: usize,53    ) !kernelization.GeneratedKernelSummary {54        const product = try self.kernelizationProduct();55        return product.kernelSummaryForWork(work_item_id);56    }5758    pub fn generatedKernelProgramForWork(59        self: *const BackendPreparedJob,60        work_item_id: usize,61    ) !*const kernelization.GeneratedKernelProgram {62        const product = try self.kernelizationProduct();63        return product.kernelProgramForWork(work_item_id);64    }6566    pub fn copyGeneratedKernelSummaries(67        self: *const BackendPreparedJob,68        result_allocator: std.mem.Allocator,69    ) !kernelization.GeneratedKernelSummaries {70        const product = try self.kernelizationProduct();71        return product.copyKernelSummaries(result_allocator);72    }73};

1pub const BackendPreparationProductKeys = struct {2    semantic: ?choir.product.incremental.ProductKey = null,3    contract: choir.product.incremental.ProductKey,4    tensor: choir.product.incremental.ProductKey,5    dispatch: choir.product.incremental.ProductKey,6    memory: choir.product.incremental.ProductKey,7    kernel: choir.product.incremental.ProductKey,8    target: choir.product.incremental.ProductKey,9};

1pub const BackendPreparationProductStamps = struct {2    semantic: ?choir.product.incremental.ProductStamp = null,3    contract: choir.product.incremental.ProductStamp,4    tensor: choir.product.incremental.ProductStamp,5    dispatch: choir.product.incremental.ProductStamp,6    memory: choir.product.incremental.ProductStamp,7    kernel: choir.product.incremental.ProductStamp,8    target: choir.product.incremental.ProductStamp,9};

1/// A caller holds this as the finished result of one compile, to read any stage or to launch the2/// final one: the result holds one sealed stage record for each of the seven stages, and each is3/// checked to belong to its stage and to depend on the stage before it. The result holds no mutable4/// compiler job, so nothing can change a stage after the result is made. `retain` returns another5/// owner of the same records, and `deinit` releases this owner's references.6pub const BackendPreparedModule = opaque {7    const Data = struct {8        allocator: std.mem.Allocator,9        records: [7]*const revision.Revision,10    };1112    const stages = [_]publication.Stage{13        .semantic, .contract, .tensor, .dispatch, .memory, .kernel, .target,14    };1516    pub fn create(17        allocator: std.mem.Allocator,18        records: [7]*const revision.Revision,19    ) !*BackendPreparedModule {20        inline for (stages, 0..) |selected, index| {21            const item = records[index];22            if (!std.mem.eql(u8, item.address().stage, selected.name())) return error.WrongStage;23            try item.requireGates(&.{ choir.product.operation.schema_identity, selected.schema() });24            if (index != 0) try requirePredecessor(item, records[index - 1]);25        }26        const owned = try allocator.create(Data);27        errdefer allocator.destroy(owned);28        var retained: usize = 0;29        errdefer for (records[0..retained]) |item| item.release();30        for (records) |item| {31            _ = try item.retain();32            retained += 1;33        }34        owned.* = .{ .allocator = allocator, .records = records };35        return @ptrCast(owned);36    }3738    fn requirePredecessor(item: *const revision.Revision, previous: *const revision.Revision) !void {39        item.requireDependency("source", previous) catch |err| switch (err) {40            error.UndeclaredProductInput => return error.UnboundProductInput,41        };42    }4344    fn data(self: *const BackendPreparedModule) *const Data {45        return @ptrCast(@alignCast(self));46    }4748    pub fn deinit(self: *BackendPreparedModule) void {49        const owned = self.data();50        for (owned.records) |item| item.release();51        owned.allocator.destroy(@constCast(owned));52    }5354    pub fn retain(55        self: *const BackendPreparedModule,56        allocator: std.mem.Allocator,57    ) !*BackendPreparedModule {58        return create(allocator, self.data().records);59    }6061    /// A caller reads one sealed stage record, for example the final one to emit device code: the62    /// call returns the record for `selected`. The record is borrowed from this result, and a63    /// caller that needs it after the result is released retains it.64    pub fn stage(65        self: *const BackendPreparedModule,66        comptime selected: publication.Stage,67    ) *const revision.Revision {68        return self.data().records[@backingInt(selected)];69    }7071    pub fn productKeys(self: *const BackendPreparedModule) BackendPreparationProductKeys {72        return .{73            .semantic = choir.product.incremental.productKey(self.stage(.semantic).metadata()),74            .contract = choir.product.incremental.productKey(self.stage(.contract).metadata()),75            .tensor = choir.product.incremental.productKey(self.stage(.tensor).metadata()),76            .dispatch = choir.product.incremental.productKey(self.stage(.dispatch).metadata()),77            .memory = choir.product.incremental.productKey(self.stage(.memory).metadata()),78            .kernel = choir.product.incremental.productKey(self.stage(.kernel).metadata()),79            .target = choir.product.incremental.productKey(self.stage(.target).metadata()),80        };81    }8283    pub fn productGraph(84        self: *const BackendPreparedModule,85        allocator: std.mem.Allocator,86    ) !choir.product.incremental.ProductGraph {87        return graphFromKeys(allocator, self.productKeys());88    }89};

1pub const BackendPreparationFailure = struct {2    pipeline_name: ?[]const u8 = null,3    failure_kind: ?BackendPreparationFailureKind = null,4    pass_name: ?[]const u8 = null,5    target_op_name: ?[]const u8 = null,6    target_symbol_name: ?[]const u8 = null,7    verifier_error_name: ?[]const u8 = null,8    worker_count: usize = 0,910    pub fn deinit(self: *BackendPreparationFailure, allocator: std.mem.Allocator) void {11        if (self.pass_name) |name| allocator.free(name);12        if (self.target_op_name) |name| allocator.free(name);13        if (self.target_symbol_name) |name| allocator.free(name);14        if (self.verifier_error_name) |name| allocator.free(name);15        self.* = .{};16    }1718    pub fn capture(19        self: *BackendPreparationFailure,20        allocator: std.mem.Allocator,21        pipeline_name: []const u8,22        reproducer: *const passes.PassFailureReproducer,23    ) !void {24        self.deinit(allocator);25        errdefer self.deinit(allocator);2627        self.pipeline_name = pipeline_name;28        self.failure_kind = reproducer.failure_kind;29        self.worker_count = reproducer.worker_count;30        self.pass_name = try dupeOptional(allocator, reproducer.pass_name);31        self.target_op_name = try dupeOptional(allocator, reproducer.target_op_name);32        self.target_symbol_name = try dupeOptional(allocator, reproducer.target_symbol_name);33        self.verifier_error_name = try dupeOptional(allocator, reproducer.verifier_error_name);34    }3536    fn dupeOptional(allocator: std.mem.Allocator, value: ?[]const u8) !?[]const u8 {37        if (value) |text| return try allocator.dupe(u8, text);38        return null;39    }40};

1pub const BackendPreparationRun = struct {2    total_ns: u64,3    contract_ns: u64 = 0,4    tensor_ns: u64 = 0,5    dispatch_ns: u64 = 0,6    memory_ns: u64 = 0,7    kernel_ns: u64 = 0,8    target_ns: u64 = 0,9    initial_choir_ops: u64,10    final_choir_ops: u64,11    semantic_fingerprint: ?u64 = null,12    contract_fingerprint: u64 = 0,13    tensor_fingerprint: u64 = 0,14    /// A caller reads this field to show whether the dispatch plans of two runs look alike. The15    /// field holds a 64-bit summary of the plans made by the dispatch stage, zero when the stage16    /// has not run. It is for display, and no product key or reuse decision reads it.17    dispatch_fingerprint: u64 = 0,18    /// A caller reads this field to show whether the memory plans of two runs look alike. The field19    /// holds a 64-bit summary of the buffer, memory-space and layout plans made by the memory20    /// stage, zero when the stage has not run. It is for display, and no product key or reuse21    /// decision reads it.22    memory_fingerprint: u64 = 0,23    /// A caller reads this field to show whether the kernel plans of two runs look alike. The field24    /// holds a 64-bit summary of the kernel outline and generated kernels made by the kernel stage,25    /// zero when the stage has not run. It is for display, and no product key or reuse decision26    /// reads it.27    kernel_fingerprint: u64 = 0,28    target_fingerprint: u64 = 0,29    contract_stats: BackendPreparationStats = .{},30    tensor_stats: BackendPreparationStats = .{},31    dispatch_stats: BackendPreparationStats = .{},32    memory_stats: BackendPreparationStats = .{},33    kernel_stats: BackendPreparationStats = .{},34    target_stats: BackendPreparationStats = .{},35    target_profile: ?target_profile.BackendTargetProfile = null,36};

1pub const BackendPreparationRunOptions = struct {2    timing: ?*BackendPreparationTiming = null,3    failure: ?*BackendPreparationFailure = null,4    target_profile: ?target_profile.BackendTargetProfile = null,5    generated_scan_schedules: []const target_profile.GeneratedScanScheduleDecision = &.{},6    generated_row_pipeline_schedules: []const target_profile.GeneratedRowPipelineScheduleDecision = &.{},7    tensor: stage.TensorLoweringOptions = .{},8    now: *const fn () i128 = sys.time.nanoTimestamp,9};

1pub const BackendPreparationStats = struct {2    pass_runs: u64 = 0,3    pass_failures: u64 = 0,4    passes_modified: u64 = 0,5    analysis_hits: u64 = 0,6    analysis_misses: u64 = 0,7    analyses_invalidated: u64 = 0,8};

1pub const BackendPreparationTiming = struct {2    inner: passes.TimingInstrumentation,34    pub const TimingOptions: type = passes.PassTimingOptions;5    pub const AllocationSnapshot: type = passes.PassAllocationSnapshot;6    pub const AllocationSnapshotProvider: type =7        passes.PassAllocationSnapshotProvider;89    pub fn init(allocator: std.mem.Allocator) BackendPreparationTiming {10        return .{ .inner = passes.TimingInstrumentation.init(allocator) };11    }1213    pub fn initWithOptions(allocator: std.mem.Allocator, options: TimingOptions) BackendPreparationTiming {14        return .{ .inner = passes.TimingInstrumentation.initWithOptions(allocator, options) };15    }1617    pub fn deinit(self: *BackendPreparationTiming) void {18        self.inner.deinit();19        self.* = undefined;20    }2122    fn instrumentation(self: *BackendPreparationTiming) passes.PassInstrumentation {23        return self.inner.instrumentation();24    }2526    pub fn getPassTime(self: *const BackendPreparationTiming, name: []const u8) ?i128 {27        return self.inner.getPassTime(name);28    }2930    pub fn getPassCount(self: *const BackendPreparationTiming, name: []const u8) ?u64 {31        return self.inner.getPassCount(name);32    }3334    pub fn getPassOpCountBefore(self: *const BackendPreparationTiming, name: []const u8) ?u64 {35        return self.inner.getPassOpCountBefore(name);36    }3738    pub fn getPassOpCountAfter(self: *const BackendPreparationTiming, name: []const u8) ?u64 {39        return self.inner.getPassOpCountAfter(name);40    }4142    pub fn getPassOpCountDelta(self: *const BackendPreparationTiming, name: []const u8) ?i128 {43        return self.inner.getPassOpCountDelta(name);44    }4546    pub fn setAllocationSnapshotProvider(47        self: *BackendPreparationTiming,48        provider: ?AllocationSnapshotProvider,49    ) void {50        self.inner.setAllocationSnapshotProvider(provider);51    }5253    pub fn getPassAllocCount(self: *const BackendPreparationTiming, name: []const u8) ?u64 {54        return self.inner.getPassAllocCount(name);55    }5657    pub fn getPassFreeCount(self: *const BackendPreparationTiming, name: []const u8) ?u64 {58        return self.inner.getPassFreeCount(name);59    }6061    pub fn getPassAllocBytes(self: *const BackendPreparationTiming, name: []const u8) ?u64 {62        return self.inner.getPassAllocBytes(name);63    }6465    pub fn getAnalysisTime(self: *const BackendPreparationTiming, name: []const u8) ?i128 {66        return self.inner.getAnalysisTime(name);67    }6869    pub fn getAnalysisCount(self: *const BackendPreparationTiming, name: []const u8) ?u64 {70        return self.inner.getAnalysisCount(name);71    }7273    pub fn collectsPassIrSizes(self: *const BackendPreparationTiming) bool {74        return self.inner.collectsPassIrSizes();75    }76};

1pub const BackendPreparationStage = struct {2    name: []const u8,3    description: []const u8,4    pass: passes.Pass,5    analysis_name: ?[]const u8 = null,6    options: []const passes.PassOptionSpec = &.{},7    build_with_options: ?passes.PassOptionsBuilderFn = null,89    fn registration(self: BackendPreparationStage) passes.PassRegistration {10        return .{11            .name = self.name,12            .description = self.description,13            .pass = self.pass,14            .options = self.options,15            .build_with_options = self.build_with_options,16        };17    }18};

1pub const TensorLoweringOptions = struct {2    activation: activation_lowering.Options = .{},3    einsum: einsum_lowering.Options = .{},4    indexing: indexing_lowering.Options = .{},5    loss: loss_lowering.Options = .{},67    pub fn eql(self: TensorLoweringOptions, other: TensorLoweringOptions) bool {8        return self.activation.eql(other.activation) and9            self.einsum.eql(other.einsum) and10            self.indexing.eql(other.indexing) and11            self.loss.eql(other.loss);12    }13};

1pub fn prepareContractJobFromSemanticModule(2    allocator: std.mem.Allocator,3    module: *semantic.SemanticModule,4    options: BackendPreparationRunOptions,5) !*contract.ContractJob {6    const result = try prepareContractJobFromSemanticModuleWithRun(7        allocator,8        module,9        options,10    );11    return result.module;12}

1pub fn prepareContractJobFromSemanticModuleWithRun(2    allocator: std.mem.Allocator,3    module: *semantic.SemanticModule,4    options: BackendPreparationRunOptions,5) !ContractPreparationResult {6    var module_owned = true;7    errdefer if (module_owned) module.deinit();89    try module.verify();1011    const initial_choir_ops = countOperationTree(module.choir_module);12    const semantic_fingerprint = try module.fingerprint(allocator);1314    var analysis_cache = passes.AnalysisCache.init(allocator, null);15    defer analysis_cache.deinit();1617    var pm = passes.PassManager.init(allocator);18    defer pm.deinit();19    if (options.timing) |timing| try run_mod.addTimingInstrumentation(&pm, timing);20    try recipe.configure(&pm, .contract, &options);2122    const contract_start = options.now();23    if (pm.runWithAnalysisCache(24        module.choir_module,25        module.context(),26        &analysis_cache,27        recipe.runOptions(),28    ) == .failure) {29        return preparationPassFailed(allocator, options, stage_mod.contract_pipeline_name, &pm);30    }31    const contract_end = options.now();3233    const contract_module = try contract.ContractJob.init(allocator, module);34    module_owned = false;35    return .{36        .module = contract_module,37        .elapsed_ns = nsBetween(contract_start, contract_end),38        .stats = run_mod.backendPreparationStats(pm.stats),39        .initial_choir_ops = initial_choir_ops,40        .semantic_fingerprint = semantic_fingerprint,41        .started_at = contract_start,42        .finished_at = contract_end,43    };44}

1pub fn prepareDispatchJobFromTensorJob(2    allocator: std.mem.Allocator,3    module: *tensor.TensorJob,4    options: BackendPreparationRunOptions,5) !*dispatch.DispatchJob {6    const result = try prepareDispatchJobFromTensorJobWithRun(7        allocator,8        module,9        options,10    );11    return result.module;12}

1pub fn prepareDispatchJobFromTensorJobWithRun(2    allocator: std.mem.Allocator,3    module: *tensor.TensorJob,4    options: BackendPreparationRunOptions,5) !DispatchPreparationResult {6    var module_owned = true;7    errdefer if (module_owned) module.deinit();89    try module.verify();1011    var pm = passes.PassManager.init(allocator);12    defer pm.deinit();13    if (options.timing) |timing| try run_mod.addTimingInstrumentation(&pm, timing);14    try recipe.configure(&pm, .dispatch, &options);1516    const dispatch_start = options.now();17    if (pm.runWithAnalysisCache(18        module.choir_module,19        module.context(),20        &module.analysis_cache,21        recipe.runOptions(),22    ) == .failure) {23        return preparationPassFailed(allocator, options, stage_mod.dispatch_pipeline_name, &pm);24    }25    const dispatch_end = options.now();2627    const plan_fingerprint = try stage_fingerprint.dispatch(28        allocator,29        module,30        stage_mod.dispatch_pipeline_name,31    );32    const dispatch_module = try dispatch.DispatchJob.init(allocator, module);33    module_owned = false;34    return .{35        .module = dispatch_module,36        .elapsed_ns = nsBetween(dispatch_start, dispatch_end),37        .stats = run_mod.backendPreparationStats(pm.stats),38        .plan_fingerprint = plan_fingerprint,39    };40}

1pub fn prepareKernelJobFromMemoryJob(2    allocator: std.mem.Allocator,3    module: *memory_product.MemoryJob,4    options: BackendPreparationRunOptions,5) !*kernel_product.KernelJob {6    const result = try prepareKernelJobFromMemoryJobWithRun(7        allocator,8        module,9        options,10    );11    return result.module;12}

1pub fn prepareKernelJobFromMemoryJobWithRun(2    allocator: std.mem.Allocator,3    module: *memory_product.MemoryJob,4    options: BackendPreparationRunOptions,5) !KernelPreparationResult {6    var module_owned = true;7    errdefer if (module_owned) module.deinit();89    try module.verify();1011    var pm = passes.PassManager.init(allocator);12    defer pm.deinit();13    if (options.timing) |timing| try run_mod.addTimingInstrumentation(&pm, timing);14    try recipe.configure(&pm, .kernel, &options);1516    try recipe.applyTargetOptions(allocator, module.choir_module, options);17    const kernel_start = options.now();18    if (pm.runWithAnalysisCache(19        module.choir_module,20        module.context(),21        &module.dispatch_module.tensor_module.analysis_cache,22        recipe.runOptions(),23    ) == .failure) {24        return preparationPassFailed(allocator, options, stage_mod.kernel_pipeline_name, &pm);25    }26    const kernel_end = options.now();2728    const plan_fingerprint = try stage_fingerprint.kernel(29        allocator,30        module,31        stage_mod.kernel_pipeline_name,32    );33    const kernel_module = try kernel_product.KernelJob.init(allocator, module);34    module_owned = false;35    return .{36        .module = kernel_module,37        .elapsed_ns = nsBetween(kernel_start, kernel_end),38        .stats = run_mod.backendPreparationStats(pm.stats),39        .plan_fingerprint = plan_fingerprint,40    };41}

1pub fn prepareMemoryJobFromDispatchJob(2    allocator: std.mem.Allocator,3    module: *dispatch.DispatchJob,4    options: BackendPreparationRunOptions,5) !*memory_product.MemoryJob {6    const result = try prepareMemoryJobFromDispatchJobWithRun(7        allocator,8        module,9        options,10    );11    return result.module;12}

1pub fn prepareMemoryJobFromDispatchJobWithRun(2    allocator: std.mem.Allocator,3    module: *dispatch.DispatchJob,4    options: BackendPreparationRunOptions,5) !MemoryPreparationResult {6    var module_owned = true;7    errdefer if (module_owned) module.deinit();89    try module.verify();1011    var pm = passes.PassManager.init(allocator);12    defer pm.deinit();13    if (options.timing) |timing| try run_mod.addTimingInstrumentation(&pm, timing);14    try recipe.configure(&pm, .memory, &options);1516    const memory_start = options.now();17    if (pm.runWithAnalysisCache(18        module.choir_module,19        module.context(),20        &module.tensor_module.analysis_cache,21        recipe.runOptions(),22    ) == .failure) {23        return preparationPassFailed(allocator, options, stage_mod.memory_pipeline_name, &pm);24    }25    const memory_end = options.now();2627    const plan_fingerprint = try stage_fingerprint.memory(28        allocator,29        module,30        stage_mod.memory_pipeline_name,31    );32    const memory_module = try memory_product.MemoryJob.init(allocator, module);33    module_owned = false;34    return .{35        .module = memory_module,36        .elapsed_ns = nsBetween(memory_start, memory_end),37        .stats = run_mod.backendPreparationStats(pm.stats),38        .plan_fingerprint = plan_fingerprint,39    };40}

1pub fn prepareTargetJobFromKernelJob(2    allocator: std.mem.Allocator,3    module: *kernel_product.KernelJob,4    options: BackendPreparationRunOptions,5) !*target_product.TargetJob {6    const result = try prepareTargetJobFromKernelJobWithRun(7        allocator,8        module,9        options,10    );11    return result.module;12}

1pub fn prepareTargetJobFromKernelJobWithRun(2    allocator: std.mem.Allocator,3    module: *kernel_product.KernelJob,4    options: BackendPreparationRunOptions,5) !TargetPreparationResult {6    var module_owned = true;7    errdefer if (module_owned) module.deinit();89    var target_result = try prepareTargetProductFromKernelJobWithRun(allocator, module, options);10    var target_result_owned = true;11    errdefer if (target_result_owned) target_result.deinit();12    const target_module = try target_product.TargetJob.init(13        allocator,14        module,15        target_result.choir_module,16        target_result.analysis_cache,17        target_result.kernelization_product,18    );19    target_result_owned = false;20    module_owned = false;21    return .{22        .module = target_module,23        .elapsed_ns = target_result.elapsed_ns,24        .stats = target_result.stats,25        .finished_at = target_result.finished_at,26    };27}

1pub fn prepareTensorJobFromContractJob(2    allocator: std.mem.Allocator,3    module: *contract.ContractJob,4    options: BackendPreparationRunOptions,5) !*tensor.TensorJob {6    const result = try prepareTensorJobFromContractJobWithRun(7        allocator,8        module,9        options,10    );11    return result.module;12}

1pub fn prepareTensorJobFromContractJobWithRun(2    allocator: std.mem.Allocator,3    module: *contract.ContractJob,4    options: BackendPreparationRunOptions,5) !TensorPreparationResult {6    var module_owned = true;7    errdefer if (module_owned) module.deinit();89    try module.verify();1011    var analysis_cache = passes.AnalysisCache.init(allocator, null);12    var cache_owned = true;13    errdefer if (cache_owned) analysis_cache.deinit();1415    var pm = passes.PassManager.init(allocator);16    defer pm.deinit();17    if (options.timing) |timing| try run_mod.addTimingInstrumentation(&pm, timing);18    try recipe.configure(&pm, .tensor, &options);1920    const tensor_start = options.now();21    if (pm.runWithAnalysisCache(22        module.choir_module,23        module.context(),24        &analysis_cache,25        recipe.runOptions(),26    ) == .failure) {27        return preparationPassFailed(allocator, options, stage_mod.tensor_pipeline_name, &pm);28    }29    const tensor_end = options.now();3031    const tensor_module = try tensor.TensorJob.init(allocator, module, analysis_cache);32    module_owned = false;33    cache_owned = false;34    return .{35        .module = tensor_module,36        .elapsed_ns = nsBetween(tensor_start, tensor_end),37        .stats = run_mod.backendPreparationStats(pm.stats),38    };39}

1pub fn runTargetPipeline(2    allocator: std.mem.Allocator,3    choir_module: *ir.Operation,4    ctx: *ir.Context,5) !void {6    return try runTargetPipelineWithOptions(allocator, choir_module, ctx, .{});7}

1pub fn runTargetPipelineWithDiagnostics(2    allocator: std.mem.Allocator,3    choir_module: *ir.Operation,4    ctx: *ir.Context,5    options: passes.PassManagerRunOptions,6    failure: ?*run_mod.BackendPreparationFailure,7) !void {8    var pm = passes.PassManager.init(allocator);9    defer pm.deinit();10    try recipe.configure(&pm, .target, &.{});11    if (pm.runWithOptions(choir_module, ctx, options) == .failure) return passFailed(allocator, failure, stage_mod.target_pipeline_name, &pm);12}

1pub fn runTargetPipelineWithOptions(2    allocator: std.mem.Allocator,3    choir_module: *ir.Operation,4    ctx: *ir.Context,5    options: passes.PassManagerRunOptions,6) !void {7    return try runTargetPipelineWithDiagnostics(allocator, choir_module, ctx, options, null);8}

1pub const loss_lowering_pass_name = "accy-choir-loss-lower";

1pub fn prepareBackendJobFromContractJob(2    allocator: std.mem.Allocator,3    module: *contract.ContractJob,4    options: BackendPreparationRunOptions,5) !BackendPreparedJob {6    const initial_choir_ops = countOperationTree(module.choir_module);7    const total_start = options.now();8    const tensor_result = try prepareTensorJobFromContractJobWithRun(9        allocator,10        module,11        options,12    );13    return try prepareBackendJobFromTensorPreparationResult(14        allocator,15        tensor_result,16        options,17        0,18        .{},19        initial_choir_ops,20        null,21        total_start,22    );23}

1pub fn prepareBackendJobFromContractPreparationResult(2    allocator: std.mem.Allocator,3    result: ContractPreparationResult,4    options: BackendPreparationRunOptions,5    total_start: i128,6) !BackendPreparedJob {7    var contract_result = result;8    var contract_owned = true;9    errdefer if (contract_owned) contract_result.deinit();1011    const contract_ns = result.elapsed_ns;12    const contract_stats = result.stats;13    const initial_choir_ops = result.initial_choir_ops;14    const semantic_fingerprint = result.semantic_fingerprint;15    contract_owned = false;16    const tensor_result = try prepareTensorJobFromContractJobWithRun(17        allocator,18        contract_result.module,19        options,20    );21    return try prepareBackendJobFromTensorPreparationResult(22        allocator,23        tensor_result,24        options,25        contract_ns,26        contract_stats,27        initial_choir_ops,28        semantic_fingerprint,29        total_start,30    );31}

1pub fn prepareBackendJobFromDispatchPreparationResult(2    allocator: std.mem.Allocator,3    result: DispatchPreparationResult,4    options: BackendPreparationRunOptions,5    contract_ns: u64,6    contract_stats: BackendPreparationStats,7    tensor_ns: u64,8    tensor_stats: BackendPreparationStats,9    initial_choir_ops: u64,10    semantic_fingerprint: ?u64,11    total_start: i128,12) !BackendPreparedJob {13    var dispatch_result = result;14    var dispatch_owned = true;15    errdefer if (dispatch_owned) dispatch_result.deinit();1617    const dispatch_ns = result.elapsed_ns;18    const dispatch_stats = result.stats;19    const dispatch_fingerprint = result.plan_fingerprint;20    dispatch_owned = false;21    const memory_result = try prepareMemoryJobFromDispatchJobWithRun(22        allocator,23        dispatch_result.module,24        options,25    );26    return try prepareBackendJobFromMemoryPreparationResult(27        allocator,28        memory_result,29        options,30        contract_ns,31        contract_stats,32        tensor_ns,33        tensor_stats,34        dispatch_ns,35        dispatch_stats,36        dispatch_fingerprint,37        initial_choir_ops,38        semantic_fingerprint,39        total_start,40    );41}

1pub fn prepareBackendJobFromKernelPreparationResult(2    allocator: std.mem.Allocator,3    result: KernelPreparationResult,4    options: BackendPreparationRunOptions,5    contract_ns: u64,6    contract_stats: BackendPreparationStats,7    tensor_ns: u64,8    tensor_stats: BackendPreparationStats,9    dispatch_ns: u64,10    dispatch_stats: BackendPreparationStats,11    dispatch_fingerprint: u64,12    memory_ns: u64,13    memory_stats: BackendPreparationStats,14    memory_fingerprint: u64,15    initial_choir_ops: u64,16    semantic_fingerprint: ?u64,17    total_start: i128,18) !BackendPreparedJob {19    var kernel_result = result;20    var kernel_owned = true;21    errdefer if (kernel_owned) kernel_result.deinit();2223    const kernel_ns = result.elapsed_ns;24    const kernel_stats = result.stats;25    const kernel_fingerprint = result.plan_fingerprint;26    kernel_owned = false;27    const target_result = try prepareTargetJobFromKernelJobWithRun(28        allocator,29        kernel_result.module,30        options,31    );32    return try prepareBackendJobFromTargetPreparationResult(33        allocator,34        target_result,35        options,36        contract_ns,37        contract_stats,38        tensor_ns,39        tensor_stats,40        dispatch_ns,41        dispatch_stats,42        dispatch_fingerprint,43        memory_ns,44        memory_stats,45        memory_fingerprint,46        kernel_ns,47        kernel_stats,48        kernel_fingerprint,49        initial_choir_ops,50        semantic_fingerprint,51        total_start,52    );53}

1pub fn prepareBackendJobFromMemoryPreparationResult(2    allocator: std.mem.Allocator,3    result: MemoryPreparationResult,4    options: BackendPreparationRunOptions,5    contract_ns: u64,6    contract_stats: BackendPreparationStats,7    tensor_ns: u64,8    tensor_stats: BackendPreparationStats,9    dispatch_ns: u64,10    dispatch_stats: BackendPreparationStats,11    dispatch_fingerprint: u64,12    initial_choir_ops: u64,13    semantic_fingerprint: ?u64,14    total_start: i128,15) !BackendPreparedJob {16    var memory_result = result;17    var memory_owned = true;18    errdefer if (memory_owned) memory_result.deinit();1920    const memory_ns = result.elapsed_ns;21    const memory_stats = result.stats;22    const memory_fingerprint = result.plan_fingerprint;23    memory_owned = false;24    const kernel_result = try prepareKernelJobFromMemoryJobWithRun(25        allocator,26        memory_result.module,27        options,28    );29    return try prepareBackendJobFromKernelPreparationResult(30        allocator,31        kernel_result,32        options,33        contract_ns,34        contract_stats,35        tensor_ns,36        tensor_stats,37        dispatch_ns,38        dispatch_stats,39        dispatch_fingerprint,40        memory_ns,41        memory_stats,42        memory_fingerprint,43        initial_choir_ops,44        semantic_fingerprint,45        total_start,46    );47}

1pub fn prepareBackendJobFromSemanticModule(2    allocator: std.mem.Allocator,3    module: *semantic.SemanticModule,4    options: BackendPreparationRunOptions,5) !BackendPreparedJob {6    return try prepareOwnedSemanticModuleForBackend(7        allocator,8        module,9        options,10        options.now(),11    );12}

1pub fn prepareBackendJobFromTargetPreparationResult(2    allocator: std.mem.Allocator,3    result: TargetPreparationResult,4    options: BackendPreparationRunOptions,5    contract_ns: u64,6    contract_stats: BackendPreparationStats,7    tensor_ns: u64,8    tensor_stats: BackendPreparationStats,9    dispatch_ns: u64,10    dispatch_stats: BackendPreparationStats,11    dispatch_fingerprint: u64,12    memory_ns: u64,13    memory_stats: BackendPreparationStats,14    memory_fingerprint: u64,15    kernel_ns: u64,16    kernel_stats: BackendPreparationStats,17    kernel_fingerprint: u64,18    initial_choir_ops: u64,19    semantic_fingerprint: ?u64,20    total_start: i128,21) !BackendPreparedJob {22    var target_result = result;23    var target_owned = true;24    errdefer if (target_owned) target_result.deinit();2526    target_owned = false;27    return try prepareOwnedTargetJob(28        allocator,29        target_result.module,30        options,31        contract_ns,32        contract_stats,33        tensor_ns,34        tensor_stats,35        dispatch_ns,36        dispatch_stats,37        dispatch_fingerprint,38        memory_ns,39        memory_stats,40        memory_fingerprint,41        kernel_ns,42        kernel_stats,43        kernel_fingerprint,44        result.elapsed_ns,45        result.stats,46        initial_choir_ops,47        semantic_fingerprint,48        total_start,49        result.finished_at,50    );51}

1pub fn prepareBackendJobFromTensorPreparationResult(2    allocator: std.mem.Allocator,3    result: TensorPreparationResult,4    options: BackendPreparationRunOptions,5    contract_ns: u64,6    contract_stats: BackendPreparationStats,7    initial_choir_ops: u64,8    semantic_fingerprint: ?u64,9    total_start: i128,10) !BackendPreparedJob {11    var tensor_result = result;12    var tensor_owned = true;13    errdefer if (tensor_owned) tensor_result.deinit();1415    const tensor_ns = result.elapsed_ns;16    const tensor_stats = result.stats;17    tensor_owned = false;18    const dispatch_result = try prepareDispatchJobFromTensorJobWithRun(19        allocator,20        tensor_result.module,21        options,22    );23    return try prepareBackendJobFromDispatchPreparationResult(24        allocator,25        dispatch_result,26        options,27        contract_ns,28        contract_stats,29        tensor_ns,30        tensor_stats,31        initial_choir_ops,32        semantic_fingerprint,33        total_start,34    );35}

1pub fn runBackendPreparationPipelineFromSemanticModule(2    allocator: std.mem.Allocator,3    module: *semantic.SemanticModule,4    options: BackendPreparationRunOptions,5) !BackendPreparationRun {6    var prepared = try prepareBackendJobFromSemanticModule(allocator, module, options);7    defer prepared.deinit();8    return prepared.run;9}

1pub const schedule_planning_pass_name = "accy-choir-plan-schedule";

1pub const shape_layout_pass_name = "accy-choir-shape-layout-propagate";

1pub const accy_choir_package_extension = choir.extensions.PackageExtension{2    .name = "accy-choir",3    .passes = &accy_choir_pass_registrations,4    .pipelines = &.{ contract_pipeline_registration, tensor_pipeline_registration, dispatch_pipeline_registration, memory_pipeline_registration, kernel_pipeline_registration, target_pipeline_registration },5};

1pub const accy_choir_pass_registrations = allPassRegistrations();

1pub fn activationLoweringPass() passes.Pass {2    return activation_lowering.activationLoweringPass();3}

1pub fn activationLoweringPassWithOptions(options: *const activation_lowering.Options) passes.Pass {2    return activation_lowering.activationLoweringPassWithOptions(options);3}

1pub fn addContractPipeline(pm: *passes.PassManager) !void {2    try contract_pipeline_registration.addTo(&pm.root);3}

1pub fn addDispatchPipeline(pm: *passes.PassManager) !void {2    try dispatch_pipeline_registration.addTo(&pm.root);3}

1pub fn addKernelPipeline(pm: *passes.PassManager) !void {2    try kernel_pipeline_registration.addTo(&pm.root);3}

1pub fn addMemoryPipeline(pm: *passes.PassManager) !void {2    try memory_pipeline_registration.addTo(&pm.root);3}

1pub fn addTargetPipeline(pm: *passes.PassManager) !void {2    try target_pipeline_registration.addTo(&pm.root);3}

1pub fn addTensorPipeline(pm: *passes.PassManager) !void {2    try tensor_pipeline_registration.addTo(&pm.root);3}

1pub fn addTensorPipelineWithOptions(pm: *passes.PassManager, options: *const TensorLoweringOptions) !void {2    try pm.addPass(activationLoweringPassWithOptions(&options.activation));3    try pm.addPass(einsumLoweringPassWithOptions(&options.einsum));4    try pm.addPass(indexingLoweringPassWithOptions(&options.indexing));5    try pm.addPass(lossLoweringPassWithOptions(&options.loss));6}

1pub fn backendLegalizationPass() passes.Pass {2    return backend_legalization.backendLegalizationPass();3}

1pub fn bufferizationPlanningPass() passes.Pass {2    return bufferization.bufferizationPlanningPass();3}

1pub fn canonicalizationPass() passes.Pass {2    return canonicalization.canonicalizationPass();3}

1pub fn constantFoldingPass() passes.Pass {2    return constant_folding.constantFoldingPass();3}

1pub fn contractAnalysisName(index: usize) []const u8 {2    return contract_analysis_names[index];3}

1pub fn contractPassName(index: usize) []const u8 {2    return contract_stages[index].name;3}

1pub const contract_pass_plan = passes.PassPlan{ .steps = &contract_plan_steps };

1pub const contract_pass_registrations = stagePassRegistrations(contract_stages);

1pub const contract_pipeline_description =2    "Normalize semantic Accy Choir into the backend contract product";

1pub const contract_pipeline_name = "accy-choir-contract";

1pub const contract_pipeline_registration = passes.PipelineRegistration{2    .name = contract_pipeline_name,3    .description = contract_pipeline_description,4    .build = buildContractPipeline,5};

1pub const contract_stages = [_]BackendPreparationStage{2    .{3        .name = canonicalization_pass_name,4        .description = canonicalization.canonicalization_pass_description,5        .pass = canonicalizationPass(),6    },7    .{8        .name = saturation_pass_name,9        .description = saturation.saturation_pass_description,10        .pass = tensorSaturationPass(),11    },12    .{13        .name = shape_layout_pass_name,14        .description = shape_analysis.shape_layout_pass_description,15        .pass = shapeLayoutPropagationPass(),16        .analysis_name = shape_analysis.shape_layout_analysis_descriptor.name,17    },18    .{19        .name = constant_folding_pass_name,20        .description = constant_folding.constant_folding_pass_description,21        .pass = constantFoldingPass(),22    },23};

1pub fn dispatchAnalysisName(index: usize) []const u8 {2    return dispatch_analysis_names[index];3}

1pub fn dispatchPassName(index: usize) []const u8 {2    return dispatch_stages[index].name;3}

1pub const dispatch_pass_plan = passes.PassPlan{ .steps = &dispatch_plan_steps };