tiny.accy.artifact

1/// Short-lived compile state rebuilt from the dispatch, memory, kernel, and2/// target results of one finished preparation: the schedule plan, the buffer,3/// memory-space and layout plans, the kernel outlines, the generated kernel4/// programs, and the target settings. A compiler of device code uses this to5/// recover the plans of a finished compile inside memory the caller provides.6/// `create` allocates the job and all of its contents inside the caller's7/// `workspace`, and a workspace that runs out gives `error.WorkExhausted`. The8/// job requires each stage record to match: the target record must hold exactly9/// one program root (`error.InvalidStageRoots`), and the dispatch, memory, and10/// kernel records must decode to that same program11/// (`error.IncompatibleStageImages`). The job keeps no pointer to the prepared12/// module, no stage-record key, and no mutable semantic module. The job works13/// out each kernel's legality for the target again from the restored plans and14/// keeps that result with the rest. `destroy` releases the job's contents, and15/// the workspace itself stays with the caller.16pub const InputJob = struct {17    fixed: fixed.Tracked,18    context: ?*ir.Context = null,19    decoded: ?choir.bytecode.DecodedModule = null,20    target: ?records.codec.Decoded(records.target.Record) = null,21    schedule: ?preparation.schedule.SchedulePlanAnalysis = null,22    buffers: ?preparation.bufferization.BufferPlanAnalysis = null,23    spaces: ?preparation.memory.MemorySpacePlanAnalysis = null,24    layouts: ?preparation.layout.LayoutPlanAnalysis = null,25    outlines: ?preparation.kernelization.product.KernelOutlinePlanAnalysis = null,26    generated: ?preparation.kernelization.KernelizationAnalysis = null,27    legal: ?preparation.backend.BackendLegalizationAnalysis = null,2829    pub fn create(30        workspace: []u8,31        prepared: *const Prepared,32        comptime configuration: Configuration,33    ) !*InputJob {34        return initialize(workspace, prepared, configuration) catch |err| {35            return if (err == error.OutOfMemory) error.WorkExhausted else err;36        };37    }3839    fn initialize(40        workspace: []u8,41        prepared: *const Prepared,42        comptime configuration: Configuration,43    ) !*InputJob {44        var initial = fixed.Tracked.init(workspace);45        const self = try initial.allocator().create(InputJob);46        self.* = .{ .fixed = initial };47        errdefer self.destroy();48        const allocator = self.fixed.allocator();49        self.context = try ir.Context.create(allocator, configuration.context);50        const context = self.context.?;51        (try choir.product.recipe.decode(prepared.stage(.target).inputs().policy)).restore(context);52        try configuration.register(context);53        const image = try open(prepared, allocator, .target, configuration);54        defer image.destroy();55        const root = image.root(0) orelse return error.InvalidStageRoots;56        if (image.root(1) != null) return error.InvalidStageRoots;57        self.decoded = try choir.bytecode.decodeModule(allocator, context, root.bytes);58        self.target = try records.codec.decode(allocator, records.target.Record, .target, image.stage());59        clearTargetAttributes(self.decoded.?.module);60        inline for (.{ .dispatch, .memory, .kernel }) |stage| {61            try self.requireSameProgram(prepared, stage, configuration);62        }63        var references = try References.init(allocator, self.decoded.?.module, configuration.image.entities);64        defer references.deinit();65        try self.restoreDispatch(prepared, &references, configuration);66        try self.restoreMemory(prepared, &references, configuration);67        try self.restoreKernel(prepared, &references, configuration);68        try self.restoreTarget(configuration);69        return self;70    }7172    pub fn destroy(self: *InputJob) void {73        const allocator = self.fixed.allocator();74        if (self.legal) |*value| value.deinit();75        if (self.generated) |*value| value.deinit();76        if (self.outlines) |*value| value.deinit();77        if (self.layouts) |*value| value.deinit();78        if (self.spaces) |*value| value.deinit();79        if (self.buffers) |*value| value.deinit();80        if (self.schedule) |*value| value.deinit();81        if (self.target) |*value| value.deinit();82        if (self.decoded) |*value| value.deinit();83        if (self.context) |context| {84            context.deinit(allocator);85            allocator.destroy(context);86        }87    }8889    /// Returns pointers into this job's own fields: the program root, the90    /// target profile, and each restored plan. A caller passes the returned91    /// plans to the artifact compiler. The pointers stay valid until `destroy`92    /// runs or the caller writes over the workspace.93    pub fn plans(self: *const InputJob) plan.PlanInputs {94        return .{95            .root = self.decoded.?.module,96            .profile = self.target.?.value.profile,97            .schedule = &self.schedule.?,98            .buffers = &self.buffers.?,99            .spaces = &self.spaces.?,100            .layouts = &self.layouts.?,101            .outlines = &self.outlines.?,102            .generated = &self.generated.?,103            .legal = &self.legal.?,104            .target = &self.target.?.value,105        };106    }107108    fn requireSameProgram(109        self: *InputJob,110        prepared: *const Prepared,111        comptime stage: publication.Stage,112        comptime configuration: Configuration,113    ) !void {114        const allocator = self.fixed.allocator();115        const image = try open(prepared, allocator, stage, configuration);116        defer image.destroy();117        if (image.root(1) != null) return error.InvalidStageRoots;118        var context = try ir.Context.init(allocator, configuration.context);119        defer context.deinit(allocator);120        (try choir.product.recipe.decode(prepared.stage(stage).inputs().policy)).restore(&context);121        try configuration.register(&context);122        const root = image.root(0) orelse return error.InvalidStageRoots;123        var decoded = try choir.bytecode.decodeModule(allocator, &context, root.bytes);124        defer decoded.deinit();125        clearTargetAttributes(decoded.module);126        choir.bytecode.qualification.compare(allocator, decoded.module, self.decoded.?.module, decoded.resources, self.decoded.?.resources, configuration.codec) catch |err| {127            return if (err == error.UnencodableProduct) error.IncompatibleStageImages else err;128        };129    }130131    fn restoreDispatch(self: *InputJob, prepared: *const Prepared, refs: *const References, comptime configuration: Configuration) !void {132        const allocator = self.fixed.allocator();133        const image = try open(prepared, allocator, .dispatch, configuration);134        defer image.destroy();135        var record = try records.codec.decode(allocator, records.dispatch.Record, .dispatch, image.stage());136        defer record.deinit();137        self.schedule = preparation.schedule.SchedulePlanAnalysis.init(allocator);138        const output = &self.schedule.?;139        copyCounters(output, record.value.schedule);140        for (record.value.schedule.work_items, 0..) |item, index| {141            const value = try project(preparation.schedule.ScheduleWorkItem, allocator, item, refs);142            try output.work_items.append(allocator, value);143            try output.root_to_item.putNoClobber(value.root, index);144        }145    }146147    fn restoreMemory(self: *InputJob, prepared: *const Prepared, refs: *const References, comptime configuration: Configuration) !void {148        const allocator = self.fixed.allocator();149        const image = try open(prepared, allocator, .memory, configuration);150        defer image.destroy();151        var record = try records.codec.decode(allocator, records.memory.Record, .memory, image.stage());152        defer record.deinit();153        self.buffers = preparation.bufferization.BufferPlanAnalysis.init(allocator);154        self.spaces = preparation.memory.MemorySpacePlanAnalysis.init(allocator);155        self.layouts = preparation.layout.LayoutPlanAnalysis.init(allocator);156        const buffers = &self.buffers.?;157        const spaces = &self.spaces.?;158        const layouts = &self.layouts.?;159        copyCounters(buffers, record.value.buffers);160        copyCounters(spaces, record.value.spaces);161        copyCounters(layouts, record.value.layouts);162        for (record.value.buffers.slots) |item| {163            const value = try project(preparation.bufferization.BufferSlot, allocator, item, refs);164            try buffers.slots.append(allocator, value);165        }166        for (record.value.bindings) |binding| {167            const value = try refs.value(binding.value);168            try buffers.value_to_slot.putNoClobber(value, binding.slot_id);169        }170        for (record.value.buffers.elisions, 0..) |item, index| {171            const value = try project(preparation.bufferization.FusionElision, allocator, item, refs);172            try buffers.elisions.append(allocator, value);173            try buffers.value_to_elision.putNoClobber(value.value, index);174        }175        for (record.value.spaces.assignments, 0..) |item, index| {176            const value = try project(preparation.memory.MemorySpaceAssignment, allocator, item, refs);177            try spaces.assignments.append(allocator, value);178            try spaces.slot_to_assignment.putNoClobber(value.slot_id, index);179        }180        for (record.value.layouts.assignments, 0..) |item, index| {181            const value = try project(preparation.layout.LayoutAssignment, allocator, item, refs);182            try layouts.assignments.append(allocator, value);183            try layouts.slot_to_assignment.putNoClobber(value.slot_id, index);184        }185    }186187    fn restoreKernel(self: *InputJob, prepared: *const Prepared, refs: *const References, comptime configuration: Configuration) !void {188        const allocator = self.fixed.allocator();189        const image = try open(prepared, allocator, .kernel, configuration);190        defer image.destroy();191        var record = try records.codec.decode(allocator, records.kernel.Record, .kernel, image.stage());192        defer record.deinit();193        self.outlines = preparation.kernelization.product.KernelOutlinePlanAnalysis.init(allocator);194        const output = &self.outlines.?;195        copyCounters(output, record.value.outlines);196        for (record.value.outlines.kernels) |item| {197            const value = try project(preparation.kernelization.product.KernelOutline, allocator, item, refs);198            try output.kernels.append(allocator, value);199            try output.work_to_kernel.putNoClobber(value.work_item_id, value.id);200        }201    }202203    fn restoreTarget(self: *InputJob, comptime configuration: Configuration) !void {204        const allocator = self.fixed.allocator();205        const source = self.target.?.value;206        const context = self.context.?;207        const root = self.decoded.?.module;208        if (source.profile) |profile| try preparation.setBackendTargetProfile(context, root, profile);209        if (source.generated_scan_schedules) |value| {210            try root.setAttr(preparation.target.generated_scan_schedule_attr_name, try context.getStringAttr(value));211        }212        if (source.generated_row_pipeline_schedules) |value| {213            try root.setAttr(preparation.target.generated_row_pipeline_schedule_attr_name, try context.getStringAttr(value));214        }215        self.generated = try preparation.kernelization.KernelizationAnalysis.init(allocator, configuration.context);216        const output = &self.generated.?;217        try output.reserveKernelCapacity(source.kernels.len);218        for (source.kernels, 0..) |item, index| {219            var value = try preparation.publication.restoreKernel(allocator, item.lowered, compilationConfiguration(configuration));220            errdefer value.deinit(allocator);221            try output.work_to_kernel.putNoClobber(value.work_item_id, index);222            output.kernels.appendAssumeCapacity(value);223        }224        self.legal = preparation.backend.BackendLegalizationAnalysis.init(allocator, source.profile);225        const legal = &self.legal.?;226        for (self.outlines.?.kernels.items) |outline| {227            const result = try preparation.backend.legalizeKernel(outline, &self.buffers.?, source.profile);228            try legal.kernels.append(allocator, result);229            if (result.isLegal()) {230                legal.legal_kernel_count += 1;231                legal.total_static_bytes = try std.math.add(u64, legal.total_static_bytes, result.static_bytes);232            } else legal.illegal_kernel_count += 1;233        }234    }235};

1/// A heap-allocated holder of one artifact plan, the compiled kernels and the2/// plan that describes them. A caller holds one of these between compiling a3/// prepared program to device code and copying that code into a runnable4/// program. `init` takes ownership of the plan and allocates the holder with5/// the given allocator, and `deinit` frees the plan and then the holder. The6/// holder lives only as long as the compile that made it and is never stored as7/// a stage record. The holder answers kernel counts and per-kernel summaries by8/// index or by work item, and it copies the plan or the summaries out for a9/// caller to keep.10pub const ArtifactJob = struct {11    allocator: std.mem.Allocator,12    artifact_plan: BackendArtifactPlan,1314    pub fn init(15        allocator: std.mem.Allocator,16        artifact_plan: BackendArtifactPlan,17    ) !*ArtifactJob {18        const artifact_job = try allocator.create(ArtifactJob);19        errdefer allocator.destroy(artifact_job);20        artifact_job.* = .{21            .allocator = allocator,22            .artifact_plan = artifact_plan,23        };24        return artifact_job;25    }2627    pub fn deinit(self: *ArtifactJob) void {28        self.artifact_plan.deinit();29        const allocator = self.allocator;30        allocator.destroy(self);31    }3233    /// A 64-bit hash of the plan's target profile, kind, format, slots, input34    /// and output ids, kernels and totals. A caller shows this number in35    /// reports or stamps it beside compiled output as a label, and no identity36    /// check or reuse decision compares it.37    pub fn fingerprint(self: *const ArtifactJob) u64 {38        return fingerprint_mod.artifactPlan(&self.artifact_plan);39    }4041    pub fn kernelCount(self: *const ArtifactJob) usize {42        return self.artifact_plan.kernelCount();43    }4445    pub fn kernelSummary(self: *const ArtifactJob, kernel_index: usize) gpu.BackendError!artifact.KernelSummary {46        if (kernel_index >= self.artifact_plan.kernels.items.len) return error.InvalidArtifact;47        return try artifact.summarizePlannedKernel(self.artifact_plan.kernels.items[kernel_index]);48    }4950    pub fn kernelSummaryForWork(self: *const ArtifactJob, work_item_id: usize) gpu.BackendError!artifact.KernelSummary {51        for (self.artifact_plan.kernels.items) |kernel| {52            if (kernel.work_item_id == work_item_id) return try artifact.summarizePlannedKernel(kernel);53        }54        return error.InvalidArtifact;55    }5657    pub fn artifactPlan(self: *const ArtifactJob) *const BackendArtifactPlan {58        return &self.artifact_plan;59    }6061    pub fn copyKernelSummaries(self: *const ArtifactJob, result_allocator: std.mem.Allocator) gpu.BackendError!artifact.KernelSummaries {62        const items = result_allocator.alloc(artifact.KernelSummary, self.artifact_plan.kernels.items.len) catch return error.OutOfMemory;63        var copied: usize = 0;64        errdefer {65            for (items[0..copied]) |summary| {66                result_allocator.free(summary.entry_name);67            }68            result_allocator.free(items);69        }7071        for (items, self.artifact_plan.kernels.items) |*item, kernel| {72            item.* = try artifact.copyKernelSummary(result_allocator, try artifact.summarizePlannedKernel(kernel));73            copied += 1;74        }7576        return .{77            .allocator = result_allocator,78            .items = items,79        };80    }8182    pub fn copyArtifactPlan(self: *const ArtifactJob, allocator: std.mem.Allocator) gpu.BackendError!BackendArtifactPlan {83        return try self.artifact_plan.copy(allocator);84    }85};

1pub fn createArtifactJobFromTargetJob(2    allocator: std.mem.Allocator,3    handle: gpu.BackendHandle,4    target_module: *target.TargetJob,5    options: ArtifactPlanOptions,6) !*ArtifactJob {7    var artifact_plan = try plan.createBackendArtifactPlanFromTargetJob(8        allocator,9        handle,10        target_module,11        options,12    );13    var plan_owned = true;14    errdefer if (plan_owned) artifact_plan.deinit();1516    const artifact_job = try ArtifactJob.init(17        allocator,18        artifact_plan,19    );20    plan_owned = false;21    return artifact_job;22}

1pub const fingerprint = @import("fingerprint.zig");2const model = @import("model/root.zig");3pub const pipeline = model.pipeline;4pub const plan = @import("plan.zig");5pub const summary = @import("summary.zig");6pub const wire = model.wire;7const job = @import("job.zig");89pub const product_name = "accy.artifact";1011pub const ArtifactPlanOptions = model.ArtifactPlanOptions;12pub const BackendArtifactPlan = plan.BackendArtifactPlan;13pub const ElementCountArgument = model.ElementCountArgument;14pub const KernelCallArtifact = model.KernelCallArtifact;15pub const KernelCallDerivedLaunch = model.KernelCallDerivedLaunch;16pub const KernelCallPipeline = model.KernelCallPipeline;17pub const OwnedKernelCallPipeline = model.OwnedKernelCallPipeline;18pub const PipelineIntermediate = model.PipelineIntermediate;19pub const PipelineRuntimeScalarBound = model.PipelineRuntimeScalarBound;20pub const PipelineScalarDerivation = model.PipelineScalarDerivation;21pub const PipelineStage = model.PipelineStage;22pub const PipelineValueRef = model.PipelineValueRef;23pub const findPipeline = model.findPipeline;24pub const KernelCallDerivedLaunchAxis = model.KernelCallDerivedLaunchAxis;25pub const KernelCallLaunch = model.KernelCallLaunch;26pub const KernelCallRegistry = model.KernelCallRegistry;27pub const KernelCallRegistryIndex = model.KernelCallRegistryIndex;28pub const KernelCallRegistryIndexSlot = model.KernelCallRegistryIndexSlot;29pub const KernelCallShapeProfile = model.KernelCallShapeProfile;30pub const KernelCallShapeProfileBounds = model.KernelCallShapeProfileBounds;31pub const KernelCallShapeProfileDimension = model.KernelCallShapeProfileDimension;32pub const LaunchResourceCandidate = plan.LaunchResourceCandidate;33pub const LaunchResourceClass = plan.LaunchResourceClass;34pub const LaunchResourcePlan = plan.LaunchResourcePlan;35pub const LaunchReductionKind = plan.LaunchReductionKind;36pub const LaunchTileKind = plan.LaunchTileKind;37pub const LaunchTilePlan = plan.LaunchTilePlan;38pub const PlannedKernel = plan.PlannedKernel;39pub const PlannedKernelCompileContract = plan.PlannedKernelCompileContract;40pub const PlannedKernelCompileLaunch = plan.PlannedKernelCompileLaunch;41pub const PlannedKernelCompilePayload = plan.PlannedKernelCompilePayload;42pub const PlannedKernelSource = plan.PlannedKernelSource;43pub const PlannedSlot = plan.PlannedSlot;44pub const KernelSource = summary.KernelSource;45pub const KernelSummary = summary.KernelSummary;46pub const KernelSummaries = summary.KernelSummaries;47pub const artifactPayloadByteCount = summary.artifactPayloadByteCount;48pub const copyKernelSummary = summary.copyKernelSummary;49pub const kernelSource = summary.kernelSource;50pub const kernelSummariesEqual = summary.kernelSummariesEqual;51pub const launchGeometriesEqual = summary.launchGeometriesEqual;52pub const launchResourceClassName = summary.launchResourceClassName;53pub const summarizePlannedKernel = summary.summarizePlannedKernel;54pub const BackendArtifactPlanSource = plan.BackendArtifactPlanSource;55pub const createBackendArtifactPlan = plan.createBackendArtifactPlan;56pub const createBackendArtifactPlanFromTargetJob = plan.createBackendArtifactPlanFromTargetJob;57pub const buildKernelCallRegistryIndex = model.buildKernelCallRegistryIndex;58pub const createBackendMemoryPlan = plan.createBackendMemoryPlan;59pub const defaultArtifactFormat = model.defaultArtifactFormat;60pub const deinitKernelCallShapeProfile = model.deinitKernelCallShapeProfile;61pub const deinitKernelCallRegistryIndex = model.deinitKernelCallRegistryIndex;62pub const duplicateKernelCallShapeProfile = model.duplicateKernelCallShapeProfile;63pub const artifactPlanFingerprint = fingerprint.artifactPlan;64pub const kernelCallShapeProfileEql = model.kernelCallShapeProfileEql;65pub const kernelCallRegistryFingerprint = fingerprint.kernelCallRegistry;66pub const launchResourcePlanFingerprint = fingerprint.launchResourcePlan;67pub const ArtifactJob = job.ArtifactJob;68pub const createArtifactJobFromTargetJob = job.createArtifactJobFromTargetJob;6970pub const InputJob = @import("input.zig").InputJob;71pub const createBackendArtifactPlanFromPreparedModule = plan.createBackendArtifactPlanFromPreparedModule;

1pub const artifact = @import("artifact/root.zig");