tiny.accy.executable.composition

1pub const BoundaryMetadata = struct {2    element_type: choir.composition.ElementType,3    dimensions: []const u64,4    byte_size: usize,56    fn deinit(self: *BoundaryMetadata, allocator: Allocator) void {7        if (self.dimensions.len != 0) allocator.free(@constCast(self.dimensions));8        self.* = undefined;9    }10};

1pub const CpuObjectMetadata = struct {2    allocator: Allocator,3    fingerprint: u64,4    artifact_fingerprint: u64,5    artifacts: []Artifact,6    input_boundaries: []BoundaryMetadata,7    output_boundaries: []BoundaryMetadata,89    pub fn init(10        allocator: Allocator,11        fragment: *const executable.CompiledFragment,12    ) !CpuObjectMetadata {13        const plan = fragment.artifactPlan();14        if (plan.kernels.items.len == 0) return error.InvalidArtifact;15        const artifacts = try allocator.alloc(Artifact, plan.kernels.items.len);16        var artifact_count: usize = 0;17        errdefer {18            var index = artifact_count;19            while (index != 0) {20                index -= 1;21                artifacts[index].deinit();22            }23            allocator.free(artifacts);24        }2526        for (plan.kernels.items, 0..) |kernel, index| {27            if (kernel.artifact.backend != .cpu or kernel.artifact.format != .cpu_object) return error.InvalidArtifact;28            const object = switch (kernel.artifact.payload) {29                .bytes => |bytes| bytes,30                else => return error.InvalidArtifact,31            };32            var artifact = try choir.backends.artifact.objectFileArtifact(33                allocator,34                .{35                    .architecture = .x86_64,36                    .triple = "x86_64-unknown-linux-gnu",37                    .cpu = "x86-64",38                },39                .{40                    .name = "sysv",41                    .calling_convention = "c",42                    .object_format = "elf",43                    .pointer_width_bits = 64,44                    .endianness = .little,45                },46                kernel.artifact.entry_name,47                object,48                &.{},49            );50            errdefer artifact.deinit();51            try artifact.options.add(.{ .key = "accy.kernel_id", .value = .{ .unsigned = kernel.kernel_id } });52            try artifact.options.add(.{ .key = "accy.work_item_id", .value = .{ .unsigned = kernel.work_item_id } });53            try artifact.options.add(.{ .key = "accy.argument_count", .value = .{ .unsigned = kernel.artifact.argument_count } });54            try artifact.options.add(.{ .key = "accy.scalar_argument_count", .value = .{ .unsigned = kernel.artifact.scalar_argument_count } });55            try artifact.verification.replace(artifact.allocator, .{ .state = .passed, .stage = "accy.cpu_object" });56            artifacts[index] = artifact;57            artifact_count += 1;58        }5960        const input_boundaries = try retainBoundaries(allocator, plan, plan.input_slot_ids);61        errdefer deinitBoundaries(allocator, input_boundaries);62        const output_boundaries = try retainBoundaries(allocator, plan, plan.output_slot_ids);63        errdefer deinitBoundaries(allocator, output_boundaries);6465        return .{66            .allocator = allocator,67            .fingerprint = fragment.fingerprint(),68            .artifact_fingerprint = fragment.artifactFingerprint(),69            .artifacts = artifacts,70            .input_boundaries = input_boundaries,71            .output_boundaries = output_boundaries,72        };73    }7475    pub fn entrySymbol(self: *const CpuObjectMetadata) ?[]const u8 {76        for (self.artifacts) |artifact| {77            if (artifact.linkage.provided_symbols.items.len != 0) return artifact.linkage.provided_symbols.items[0].name;78        }79        return null;80    }8182    pub fn deinit(self: *CpuObjectMetadata) void {83        var artifact_index = self.artifacts.len;84        while (artifact_index != 0) {85            artifact_index -= 1;86            self.artifacts[artifact_index].deinit();87        }88        deinitBoundaries(self.allocator, self.output_boundaries);89        deinitBoundaries(self.allocator, self.input_boundaries);90        self.allocator.free(self.artifacts);91        self.* = undefined;92    }93};

1pub const CpuObjectCompilation = struct {2    allocator: Allocator,3    fragment_id: ChoirComposition.FragmentId,4    launch_tuning_artifact: []const u8,5    input_product: choir.product.ProductKey,6    compiled_fragment: ?*executable.CompiledFragment,7    metadata: composition.CpuObjectMetadata,89    pub fn deinit(self: *CpuObjectCompilation) void {10        if (self.compiled_fragment) |fragment| fragment.deinit();11        self.metadata.deinit();12        self.input_product.record.release();13        if (self.launch_tuning_artifact.len != 0) self.allocator.free(@constCast(self.launch_tuning_artifact));14        self.* = undefined;15    }1617    pub fn materializer(self: *CpuObjectCompilation) ChoirComposition.FragmentMaterializer {18        return .{19            .id = self.fragment_id,20            .context = self,21            .materialize = materialize,22        };23    }24};

1pub const CpuObjectCompileOptions = struct {2    request: executable.FragmentCompilationRequest,3    compiler: executable.FragmentCompilerOptions = .{},4};

1pub const RuntimeEvidence = struct {2    invocation_count: u64,3    completed_invocation_count: u64,4    failed_invocation_count: u64,5    loaded_artifact_count: usize,6    live_buffer_count: usize,7};

1pub const RuntimeEvidenceError = error{ForeignLoadedFragment};

1pub fn compileCpuObject(2    allocator: Allocator,3    fragment_id: ChoirComposition.FragmentId,4    module: *accy.SemanticModule,5    options: CpuObjectCompileOptions,6    report: *preparation.publication.PreparationReport,7    comptime configuration: choir.product.operation.Configuration,8) !CpuObjectCompilation {9    defer module.deinit();10    const launch_tuning_artifact: []const u8 = if (options.compiler.launch_tuning_artifact.len == 0)11        &.{}12    else13        try allocator.dupe(u8, options.compiler.launch_tuning_artifact);14    errdefer if (launch_tuning_artifact.len != 0) allocator.free(@constCast(launch_tuning_artifact));15    var compiler_options = options.compiler;16    compiler_options.artifact_format = .cpu_object;17    var backend_state = gpu.cpu.State.init(allocator);18    defer backend_state.deinit();19    var plan: executable.fragment.FragmentPreparationPlan = undefined;20    try plan.init(allocator, backend_state.handle(), compiler_options);21    defer plan.deinit();22    const prepared = try preparation.publication.prepare(allocator, .{ .draft = module }, .{23        .source = options.request.source,24        .variant = options.request.variant,25        .work = options.request.work,26        .record_bytes = options.request.record_bytes,27        .options = plan.run_options,28    }, report, configuration);29    defer prepared.deinit();30    try recordPreparation(compiler_options.instrumentation, report);31    const input_record = try prepared.stage(.semantic).metadata().retain();32    errdefer input_record.release();33    const compiled_fragment = try executable.compileFragmentFromPreparedModule(34        allocator,35        backend_state.handle(),36        prepared,37        compiler_options,38        options.request.artifact_workspace,39        configuration,40    );41    errdefer compiled_fragment.deinit();42    const metadata = try composition.CpuObjectMetadata.init(allocator, compiled_fragment);43    return .{44        .allocator = allocator,45        .fragment_id = fragment_id,46        .launch_tuning_artifact = launch_tuning_artifact,47        .input_product = choir.product.productKey(input_record),48        .compiled_fragment = compiled_fragment,49        .metadata = metadata,50    };51}

1pub fn materializeCpuObject(2    compilation: *cpu.CpuObjectCompilation,3    allocator: Allocator,4    module: *const ChoirComposition.CompositionModule,5    fragment: *const ChoirComposition.Fragment,6) !ChoirComposition.MaterializedFragment {7    try verifyDurableFragment(compilation, module, fragment);8    const compiled_fragment = compilation.compiled_fragment orelse return error.AlreadyMaterialized;9    const state = try allocator.create(cpu.runtime.State);10    state.* = cpu.runtime.State.init(allocator, fragment.id);11    var state_owned = true;12    errdefer if (state_owned) {13        state.deinitUnloaded();14        allocator.destroy(state);15    };1617    const runtime_input_sizes = try retainByteSizes(allocator, compilation.metadata.input_boundaries);18    var input_sizes_owned = true;19    errdefer if (input_sizes_owned) allocator.free(runtime_input_sizes);20    const runtime_output_sizes = try retainByteSizes(allocator, compilation.metadata.output_boundaries);21    var output_sizes_owned = true;22    errdefer if (output_sizes_owned) allocator.free(runtime_output_sizes);2324    compilation.compiled_fragment = null;25    const load_options = executable.FragmentCompilerOptions{26        .artifact_format = .cpu_object,27        .launch_tuning_artifact = compilation.launch_tuning_artifact,28    };29    const loaded_fragment = try executable.loadFragment(30        allocator,31        state.handle(),32        compiled_fragment,33        load_options,34    );35    var loaded_owned = true;36    errdefer if (loaded_owned) loaded_fragment.deinit();3738    state.install(loaded_fragment, runtime_input_sizes, runtime_output_sizes);39    state_owned = false;40    loaded_owned = false;41    input_sizes_owned = false;42    output_sizes_owned = false;4344    return .{45        .state = state,46        .vtable = &cpu.runtime.vtable,47    };48}

1pub fn runtimeEvidence(fragment: ChoirComposition.LoadedFragment) RuntimeEvidenceError!RuntimeEvidence {2    if (fragment.vtable != &vtable) return error.ForeignLoadedFragment;3    const state: *State = @ptrCast(@alignCast(fragment.state));4    state.mutex.lock();5    defer state.mutex.unlock();6    return .{7        .invocation_count = state.invocation_count,8        .completed_invocation_count = state.completed_invocation_count,9        .failed_invocation_count = state.failed_invocation_count,10        .loaded_artifact_count = state.cpu.loaded.count(),11        .live_buffer_count = state.cpu.buffers.count(),12    };13}

1const artifact = @import("artifact.zig");2const cpu = @import("cpu/root.zig");3pub const element = @import("element.zig");45pub const CpuObjectCompileOptions = cpu.CpuObjectCompileOptions;6pub const CpuObjectCompilation = cpu.CpuObjectCompilation;7pub const CpuObjectMetadata = artifact.CpuObjectMetadata;8pub const BoundaryMetadata = artifact.BoundaryMetadata;9pub const RuntimeEvidence = cpu.RuntimeEvidence;10pub const RuntimeEvidenceError = cpu.RuntimeEvidenceError;11pub const compileCpuObject = cpu.compileCpuObject;12pub const materializeCpuObject = cpu.materializeCpuObject;13pub const runtimeEvidence = cpu.runtimeEvidence;14pub const elementType = element.elementType;15pub const dtype = element.dtype;

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