tiny.accy.kernel.library.random.base.artifact_product

1pub const ArtifactPlanOptions = struct {2    format: ?gpu.ArtifactFormat = null,3    kernel_call_registry: ?*const KernelCallRegistry = null,4};

1pub const ElementCountArgument = enum {2    none,3    scalar_u32,4    device_buffer_u32,5};

1/// Records one prebuilt kernel in a registry, found by the triple of target2/// name, for example "accy.kernel.linalg.matmul5x7x3_4x2_f32", its `version`,3/// and its artifact format, so compiled programs can call it by name. The entry4/// also records its entry point name, argument count, required element types,5/// device features, code payload, launch rule, static arguments, and optional6/// named dimensions. The `version` field stands for what the kernel computes7/// and is separate from the byte-layout version of the registry file. A8/// maintainer raises `version` before an existing entry changes its math, the9/// meaning of its element types or memory layout, its argument list, its static10/// arguments, how its launch is derived, what its shape profile means, or its11/// schedule. A change that touches only the registry file's byte layout, or12/// that keeps behavior unchanged, leaves `version` as it is, because the13/// registry file carries its own layout version. A family target names one14/// reusable schedule, and sizes that leave that schedule unchanged arrive at15/// launch as bounded runtime scalar arguments.16pub const KernelCallArtifact = struct {17    target: []const u8,18    version: u32,19    format: gpu.ArtifactFormat,20    entry_name: []const u8,21    argument_count: u32,22    shape_family_fingerprint: ?u64 = null,23    shape_profile: ?KernelCallShapeProfile = null,24    required_dtypes: gpu.DTypeSet = .{},25    required_features: choir_abi.Features = .{},26    required_subgroup: choir_abi.SubgroupRequirements = .{},27    /// Layout the emitter gave the entry's push-constant block, if any.28    push_constants: choir_abi.PushConstants = .{},29    payload: gpu.CompilePayload,30    launch: KernelCallLaunch = .{ .derived = .{} },31    element_count_argument: ElementCountArgument = .none,32    runtime_scalar_argument_count: u32 = 0,33    static_arguments: []const choir_abi.ScalarArgument = &.{},3435    /// Scalar arguments the entry's kernel takes, runtime and static36    /// together. The rest of `argument_count` are buffers.37    pub fn scalarArgumentCount(self: KernelCallArtifact) gpu.BackendError!u32 {38        const static_count = std.math.cast(u32, self.static_arguments.len) orelse39            return error.InvalidArtifact;40        const count = std.math.add(u32, self.runtime_scalar_argument_count, static_count) catch41            return error.InvalidArtifact;42        if (count > self.argument_count) return error.InvalidArtifact;43        return count;44    }45};

1pub const KernelCallDerivedLaunch = struct {2    grid: [3]KernelCallDerivedLaunchAxis = .{3        .{ .fixed = 1 },4        .{ .fixed = 1 },5        .{ .fixed = 1 },6    },7    threadgroup: [3]u32 = .{ 1, 1, 1 },8    dynamic_shared_memory_bytes: u32 = 0,910    pub fn geometry(11        self: KernelCallDerivedLaunch,12        runtime_scalar_arguments: []const choir_abi.ScalarArgument,13    ) gpu.BackendError!choir_abi.LaunchGeometry {14        return .{15            .grid = .{16                try self.grid[0].extent(runtime_scalar_arguments),17                try self.grid[1].extent(runtime_scalar_arguments),18                try self.grid[2].extent(runtime_scalar_arguments),19            },20            .threadgroup = try validateThreadgroup(self.threadgroup),21            .dynamic_shared_memory_bytes = self.dynamic_shared_memory_bytes,22        };23    }24};

1pub const KernelCallDerivedLaunchAxis = union(enum) {2    fixed: u32,3    runtime_u32_ceil_div: RuntimeU32CeilDiv,45    pub const RuntimeU32CeilDiv = struct {6        argument_index: u32,7        divisor: u32 = 1,8    };910    pub fn extent(11        self: KernelCallDerivedLaunchAxis,12        runtime_scalar_arguments: []const choir_abi.ScalarArgument,13    ) gpu.BackendError!u32 {14        return switch (self) {15            .fixed => |value| if (value == 0) error.InvalidArtifact else value,16            .runtime_u32_ceil_div => |axis| runtimeU32CeilDiv(runtime_scalar_arguments, axis),17        };18    }19};

1pub const KernelCallLaunch = union(enum) {2    derived: KernelCallDerivedLaunch,3    fixed: choir_abi.LaunchGeometry,4};

1pub const KernelCallRegistry = struct {2    entries: []const KernelCallArtifact = &.{},3    index: ?KernelCallRegistryIndex = null,45    pub fn find(6        self: KernelCallRegistry,7        target: []const u8,8        version: u32,9        format: gpu.ArtifactFormat,10    ) ?KernelCallArtifact {11        if (self.index) |index| {12            const entry_index = index.findEntryIndex(target, version, format) orelse return null;13            if (entry_index >= self.entries.len) return null;14            return self.entries[entry_index];15        }16        for (self.entries) |entry| {17            if (entry.version != version) continue;18            if (entry.format != format) continue;19            if (!std.mem.eql(u8, entry.target, target)) continue;20            return entry;21        }22        return null;23    }24};

1pub const KernelCallRegistryIndex = struct {2    slots: []const KernelCallRegistryIndexSlot = &.{},34    pub fn findEntryIndex(5        self: KernelCallRegistryIndex,6        target: []const u8,7        version: u32,8        format: gpu.ArtifactFormat,9    ) ?usize {10        if (self.slots.len == 0) return null;11        var slot_index = kernelCallRegistrySlotIndex(self.slots.len, target, version, format);12        var probe_count: usize = 0;13        while (probe_count < self.slots.len) : (probe_count += 1) {14            const slot = self.slots[slot_index];15            if (!slot.occupied) return null;16            if (kernelCallRegistryKeyMatches(slot, target, version, format)) return slot.entry_index;17            slot_index = (slot_index + 1) & (self.slots.len - 1);18        }19        return null;20    }21};

1pub const KernelCallRegistryIndexSlot = struct {2    occupied: bool = false,3    target: []const u8 = &.{},4    version: u32 = 0,5    format: gpu.ArtifactFormat = .cuda_ptx,6    entry_index: usize = 0,7};

1pub const KernelCallShapeProfile = struct {2    name: []const u8,3    fingerprint: u64,4    dimensions: []const KernelCallShapeProfileDimension = &.{},56    pub fn validate(self: KernelCallShapeProfile, runtime_scalar_argument_count: u32) gpu.BackendError!void {7        if (self.name.len == 0) return error.InvalidArtifact;8        if (self.dimensions.len == 0) return error.InvalidArtifact;9        for (self.dimensions, 0..) |item, index| {10            if (item.name.len == 0) return error.InvalidArtifact;11            if (item.runtime_scalar_argument_index >= runtime_scalar_argument_count) return error.InvalidArtifact;12            if (!item.bounds.valid()) return error.InvalidArtifact;13            for (self.dimensions[0..index]) |previous| {14                if (previous.runtime_scalar_argument_index == item.runtime_scalar_argument_index) return error.InvalidArtifact;15                if (std.mem.eql(u8, previous.name, item.name)) return error.InvalidArtifact;16            }17        }18    }1920    pub fn dimension(self: KernelCallShapeProfile, name: []const u8) ?KernelCallShapeProfileDimension {21        for (self.dimensions) |item| {22            if (std.mem.eql(u8, item.name, name)) return item;23        }24        return null;25    }2627    pub fn runtimeScalarDimension(self: KernelCallShapeProfile, index: u32) ?KernelCallShapeProfileDimension {28        for (self.dimensions) |item| {29            if (item.runtime_scalar_argument_index == index) return item;30        }31        return null;32    }33};

1pub const KernelCallShapeProfileDimension = struct {2    name: []const u8,3    runtime_scalar_argument_index: u32,4    bounds: KernelCallShapeProfileBounds,5};

1pub const StandaloneKernelOptions = struct {2    runtime_scalar_argument_count: u32 = 0,3    static_arguments: []const choir_abi.ScalarArgument = &.{},4};

1pub const KernelCallRegistryIndexError = error{2    DuplicateKernelCallArtifact,3} || std.mem.Allocator.Error;

1pub fn buildKernelCallRegistryIndex(2    allocator: std.mem.Allocator,3    entries: []const KernelCallArtifact,4) KernelCallRegistryIndexError!KernelCallRegistryIndex {5    if (entries.len == 0) return .{};6    const slots = try allocator.alloc(KernelCallRegistryIndexSlot, try kernelCallRegistryIndexCapacity(entries.len));7    @memset(slots, .{});8    const index = KernelCallRegistryIndex{ .slots = slots };9    errdefer deinitKernelCallRegistryIndex(allocator, index);10    for (entries, 0..) |entry, entry_index| try insertKernelCallRegistryIndexEntry(slots, entry, entry_index);11    return index;12}

1pub fn defaultArtifactFormat(kind: gpu.BackendKind) ?gpu.ArtifactFormat {2    return switch (kind) {3        .cuda => .cuda_ptx,4        .vulkan => .vulkan_spirv,5        .metal => .metal_msl,6        .webgpu => .webgpu_wgsl,7        .cpu => .cpu_object,8        .wasm => .webassembly_module,9        else => null,10    };11}

1pub fn deinitKernelCallRegistryIndex(2    allocator: std.mem.Allocator,3    index: KernelCallRegistryIndex,4) void {5    if (index.slots.len != 0) allocator.free(@constCast(index.slots));6}

1pub fn deinitKernelCallShapeProfile(2    allocator: std.mem.Allocator,3    profile: KernelCallShapeProfile,4) void {5    allocator.free(profile.name);6    for (profile.dimensions) |dimension| allocator.free(dimension.name);7    allocator.free(profile.dimensions);8}

1pub fn duplicateKernelCallShapeProfile(2    allocator: std.mem.Allocator,3    profile: KernelCallShapeProfile,4) !KernelCallShapeProfile {5    const name = try allocator.dupe(u8, profile.name);6    errdefer allocator.free(name);7    const dimensions = try allocator.alloc(KernelCallShapeProfileDimension, profile.dimensions.len);8    var copied_count: usize = 0;9    errdefer {10        for (dimensions[0..copied_count]) |dimension| allocator.free(dimension.name);11        allocator.free(dimensions);12    }13    for (profile.dimensions, dimensions) |source, *destination| {14        destination.* = source;15        destination.name = try allocator.dupe(u8, source.name);16        copied_count += 1;17    }18    return .{19        .name = name,20        .fingerprint = profile.fingerprint,21        .dimensions = dimensions,22    };23}

1pub fn kernelCallShapeProfileEql(lhs: ?KernelCallShapeProfile, rhs: ?KernelCallShapeProfile) bool {2    if (lhs == null and rhs == null) return true;3    if (lhs == null or rhs == null) return false;4    return kernelCallShapeProfileValueEql(lhs.?, rhs.?);5}

1pub fn validateThreadgroup(threadgroup: [3]u32) gpu.BackendError![3]u32 {2    for (threadgroup) |extent| {3        if (extent == 0) return error.InvalidArtifact;4    }5    return threadgroup;6}

1pub const KernelCallShapeProfileBounds = accy_choir.shape.Bounds;

1const registry = @import("registry.zig");2pub const pipeline = @import("pipeline.zig");3pub const wire = @import("wire.zig");45pub const ArtifactPlanOptions = registry.ArtifactPlanOptions;6pub const ElementCountArgument = registry.ElementCountArgument;7pub const KernelCallLaunch = registry.KernelCallLaunch;8pub const KernelCallDerivedLaunchAxis = registry.KernelCallDerivedLaunchAxis;9pub const KernelCallDerivedLaunch = registry.KernelCallDerivedLaunch;10pub const KernelCallShapeProfileBounds = registry.KernelCallShapeProfileBounds;11pub const KernelCallShapeProfileDimension = registry.KernelCallShapeProfileDimension;12pub const KernelCallShapeProfile = registry.KernelCallShapeProfile;13pub const KernelCallArtifact = registry.KernelCallArtifact;14pub const StandaloneKernelOptions = registry.StandaloneKernelOptions;15pub const KernelCallRegistryIndexSlot = registry.KernelCallRegistryIndexSlot;16pub const KernelCallRegistryIndex = registry.KernelCallRegistryIndex;17pub const KernelCallRegistry = registry.KernelCallRegistry;18pub const KernelCallRegistryIndexError = registry.KernelCallRegistryIndexError;19pub const buildKernelCallRegistryIndex = registry.buildKernelCallRegistryIndex;20pub const deinitKernelCallRegistryIndex = registry.deinitKernelCallRegistryIndex;21pub const duplicateKernelCallShapeProfile = registry.duplicateKernelCallShapeProfile;22pub const deinitKernelCallShapeProfile = registry.deinitKernelCallShapeProfile;23pub const kernelCallShapeProfileEql = registry.kernelCallShapeProfileEql;24pub const defaultArtifactFormat = registry.defaultArtifactFormat;25pub const validateThreadgroup = registry.validateThreadgroup;2627pub const PipelineValueRef = pipeline.PipelineValueRef;28pub const PipelineScalarDerivation = pipeline.PipelineScalarDerivation;29pub const PipelineIntermediate = pipeline.PipelineIntermediate;30pub const PipelineRuntimeScalarBound = pipeline.PipelineRuntimeScalarBound;31pub const PipelineStage = pipeline.PipelineStage;32pub const KernelCallPipeline = pipeline.KernelCallPipeline;33pub const findPipeline = pipeline.findPipeline;34pub const OwnedKernelCallPipeline = pipeline.OwnedKernelCallPipeline;

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