tiny.accy.kernel.library.random

1pub const Feistel = struct {2    count: u64,3    rounds: u32 = feistel_default_rounds,4    seed: u64 = 0,5    dtype: DType = .i32,6    threads: u32 = 256,7    count_axis: []const u8 = "n",89    pub fn seedLo(self: Feistel) u32 {10        return @truncate(self.seed);11    }1213    pub fn seedHi(self: Feistel) u32 {14        return @truncate(self.seed >> 32);15    }1617    pub fn domainBits(self: Feistel) ?u6 {18        return feistelDomainBits(self.count);19    }2021    pub fn halfBits(self: Feistel) ?u6 {22        const bits = self.domainBits() orelse return null;23        return @intCast(bits / 2);24    }25};

1pub const PhiloxFold = struct {2    count: u64,3    samples: u32 = 1,4    rounds: u32 = philox_default_rounds,5    seed: u64 = 0,6    dtype: DType = .f32,7    threads: u32 = 256,8    count_axis: []const u8 = "n",910    pub fn seedLo(self: PhiloxFold) u32 {11        return @truncate(self.seed);12    }1314    pub fn seedHi(self: PhiloxFold) u32 {15        return @truncate(self.seed >> 32);16    }17};

1pub const SquaresFold = struct {2    count: u64,3    samples: u32 = 1,4    key: u64 = squares_default_key,5    dtype: DType = .f32,6    threads: u32 = 256,7    count_axis: []const u8 = "n",89    pub fn keyLo(self: SquaresFold) u32 {10        return @truncate(self.key);11    }1213    pub fn keyHi(self: SquaresFold) u32 {14        return @truncate(self.key >> 32);15    }16};

1pub const ThreefryFold = struct {2    count: u64,3    samples: u32 = 1,4    rounds: u32 = threefry_default_rounds,5    seed: u64 = 0,6    dtype: DType = .f32,7    threads: u32 = 256,8    count_axis: []const u8 = "n",910    pub fn seedLo(self: ThreefryFold) u32 {11        return @truncate(self.seed);12    }1314    pub fn seedHi(self: ThreefryFold) u32 {15        return @truncate(self.seed >> 32);16    }17};

1pub const PhiloxKeyCounterUniform = struct {2    count: u64,3    rounds: u32 = philox_default_rounds,4    dtype: DType = .f32,5    threads: u32 = 256,6    count_axis: []const u8 = "n",78    pub fn generators(self: PhiloxKeyCounterUniform) u64 {9        return self.count;10    }11};

1pub const PhiloxKeySplit = struct {2    count: u64,3    rounds: u32 = philox_default_rounds,4    threads: u32 = 256,5    count_axis: []const u8 = "n",67    pub fn generators(self: PhiloxKeySplit) u64 {8        return self.count;9    }10};

1pub const PhiloxKeyUniform = struct {2    count: u64,3    rounds: u32 = philox_default_rounds,4    dtype: DType = .f32,5    threads: u32 = 256,6    count_axis: []const u8 = "n",78    pub fn generators(self: PhiloxKeyUniform) u64 {9        return self.count;10    }11};

1pub const Philox = struct {2    count: u64,3    rounds: u32 = philox_default_rounds,4    seed: u64 = 0,5    dtype: DType = .f32,6    threads: u32 = 256,7    count_axis: []const u8 = "n",89    pub fn generators(self: Philox) u64 {10        return ceilDiv(self.count, philox_lanes);11    }1213    pub fn seedLo(self: Philox) u32 {14        return @truncate(self.seed);15    }1617    pub fn seedHi(self: Philox) u32 {18        return @truncate(self.seed >> 32);19    }20};

1pub const Squares = struct {2    count: u64,3    key: u64 = squares_default_key,4    dtype: DType = .f32,5    threads: u32 = 256,6    count_axis: []const u8 = "n",78    pub fn generators(self: Squares) u64 {9        return self.count;10    }1112    pub fn keyLo(self: Squares) u32 {13        return @truncate(self.key);14    }1516    pub fn keyHi(self: Squares) u32 {17        return @truncate(self.key >> 32);18    }19};

1pub const Threefry = struct {2    count: u64,3    rounds: u32 = threefry_default_rounds,4    seed: u64 = 0,5    dtype: DType = .f32,6    threads: u32 = 256,7    count_axis: []const u8 = "n",89    pub fn generators(self: Threefry) u64 {10        return ceilDiv(self.count, threefry_lanes);11    }1213    pub fn seedLo(self: Threefry) u32 {14        return @truncate(self.seed);15    }1617    pub fn seedHi(self: Threefry) u32 {18        return @truncate(self.seed >> 32);19    }20};

1pub fn createFeistelFamilyArtifact(2    allocator: std.mem.Allocator,3    handle: kernel.BackendHandle,4    instance: Feistel,5    options: entry.ArtifactOptions,6) !kernel.OwnedKernelCallArtifact {7    if (!feistelInstanceValid(instance)) return error.UnsupportedExtent;8    const target = try feistelFamilyTarget(allocator, instance);9    defer allocator.free(target);10    const entry_name = try feistelFamilyEntryName(allocator, instance);11    defer allocator.free(entry_name);12    const family_fingerprint = options.shape_family_fingerprint orelse try feistelFamilyFingerprint(allocator, instance);13    const shape_profile_dimensions = feistelShapeProfileDimensions(instance);14    const shape_profile = options.shape_profile orelse artifact_product.KernelCallShapeProfile{15        .name = "feistel",16        .fingerprint = family_fingerprint,17        .dimensions = shape_profile_dimensions[0..],18    };1920    var graph = switch (instance.dtype) {21        .i32 => try FeistelRuntimeFamilyI32.buildNamed(allocator, options.limits, entry_name, instance),22        else => return error.UnsupportedDType,23    };24    defer graph.deinit();25    return kernel.createKernelCallArtifact(allocator, handle, &graph, .{26        .target = target,27        .version = feistel_family_version,28        .format = options.format,29        .kernel_plan = options.kernel_plan,30        .element_count_argument = options.element_count_argument,31        .shape_family_fingerprint = family_fingerprint,32        .shape_profile = shape_profile,33        .launch = options.launch orelse try randomFoldDerivedLaunch(instance.threads),34        .runtime_scalar_argument_count = if (options.runtime_scalar_argument_count == 0) 3 else options.runtime_scalar_argument_count,35        .static_arguments = options.static_arguments,36    });37}

1pub fn feistelThreadCandidatesForCount(count: u64) geometry_mod.Thread1DCandidates {2    return geometry_mod.threadCandidatesForExtent(count, random_thread_caps);3}

1pub fn feistelThreadsForCount(count: u64) u32 {2    return geometry_mod.threadsForExtent(count, random_thread_caps);3}

1pub fn feistelFamilyEntryName(allocator: std.mem.Allocator, instance: Feistel) ![]u8 {2    return std.fmt.allocPrint(3        allocator,4        "accy_kernel_random_feistel_family_{d}b_{d}r_{d}_{s}",5        .{ instance.domainBits().?, instance.rounds, instance.threads, instance.dtype.name() },6    );7}

1pub fn feistelFamilyTarget(allocator: std.mem.Allocator, instance: Feistel) ![]u8 {2    return std.fmt.allocPrint(3        allocator,4        "accy.kernel.random.feistel_family_{d}b_{d}r_{d}_{s}",5        .{ instance.domainBits().?, instance.rounds, instance.threads, instance.dtype.name() },6    );7}

1pub fn feistelFamilyFingerprint(backing_allocator: std.mem.Allocator, instance: Feistel) !u64 {2    var family = try feistelShapeFamily(backing_allocator, instance);3    defer family.deinit();4    return shape.fingerprint(family);5}

1pub fn feistelRuntimeArguments(instance: Feistel) ![3]choir_abi.ScalarArgument {2    return .{3        .{ .u32 = try runtimeExtentArgument(instance.count) },4        .{ .u32 = instance.seedLo() },5        .{ .u32 = instance.seedHi() },6    };7}

1pub fn feistelShapeFamily(backing_allocator: std.mem.Allocator, instance: Feistel) !shape.Family {2    return randomShapeFamily(backing_allocator, "feistel", instance.count_axis);3}

1pub fn feistelShapeProfileDimensions(instance: Feistel) [1]artifact_product.KernelCallShapeProfileDimension {2    return .{3        .{ .name = instance.count_axis, .runtime_scalar_argument_index = 0, .bounds = randomRuntimeExtentBounds() },4    };5}

1pub const FeistelRuntimeFamilyI32 = feistelRuntimeFamily(.i32);

1pub fn feistelPermuteReference(index: u32, rounds: u32, seed: u64, bits: u6) u32 {2    const half_bits: u5 = @intCast(bits / 2);3    const mask: u32 = (@as(u32, 1) << half_bits) - 1;4    var left: u32 = index >> half_bits;5    var right: u32 = index & mask;6    const seed_lo: u32 = @truncate(seed);7    const seed_hi: u32 = @truncate(seed >> 32);8    var round: u32 = 0;9    while (round < rounds) : (round += 1) {10        const mixed = philoxBlock(2, .{ right, round, 0, 0 }, .{ seed_lo, seed_hi })[0] & mask;11        const next_right = left ^ mixed;12        left = right;13        right = next_right;14    }15    return (left << half_bits) | right;16}

1pub fn feistelDomainBits(count: u64) ?u6 {2    if (count < 4) return null;3    if (!std.math.isPowerOfTwo(count)) return null;4    const bits: u6 = @intCast(std.math.log2_int(u64, count));5    if (bits > feistel_max_domain_bits) return null;6    if (bits % 2 != 0) return null;7    return bits;8}

1pub fn feistelInstanceValid(instance: Feistel) bool {2    if (instance.dtype != .i32) return false;3    if (instance.threads == 0) return false;4    if (instance.rounds == 0 or instance.rounds > feistel_max_rounds) return false;5    return instance.domainBits() != null;6}

1pub const feistel_default_rounds: u32 = 6;

1pub const feistel_family_version: u32 = 1;

1pub const feistel_max_rounds: u32 = 16;

1pub fn createPhiloxFoldFamilyArtifact(2    allocator: std.mem.Allocator,3    handle: kernel.BackendHandle,4    instance: PhiloxFold,5    options: entry.ArtifactOptions,6) !kernel.OwnedKernelCallArtifact {7    const target = try philoxFoldFamilyTarget(allocator, instance);8    defer allocator.free(target);9    const entry_name = try philoxFoldFamilyEntryName(allocator, instance);10    defer allocator.free(entry_name);11    const family_fingerprint = options.shape_family_fingerprint orelse try philoxFoldFamilyFingerprint(allocator, instance);12    const shape_profile_dimensions = philoxFoldShapeProfileDimensions(instance);13    const shape_profile = options.shape_profile orelse artifact_product.KernelCallShapeProfile{14        .name = "philox_fold",15        .fingerprint = family_fingerprint,16        .dimensions = shape_profile_dimensions[0..],17    };1819    var graph = switch (instance.dtype) {20        .f32 => try PhiloxFoldRuntimeFamilyF32.buildNamed(allocator, options.limits, entry_name, instance),21        .i32 => try PhiloxFoldRuntimeFamilyI32.buildNamed(allocator, options.limits, entry_name, instance),22        else => return error.UnsupportedDType,23    };24    defer graph.deinit();25    return kernel.createKernelCallArtifact(allocator, handle, &graph, .{26        .target = target,27        .version = philox_fold_family_version,28        .format = options.format,29        .kernel_plan = options.kernel_plan,30        .element_count_argument = options.element_count_argument,31        .shape_family_fingerprint = family_fingerprint,32        .shape_profile = shape_profile,33        .launch = options.launch orelse try randomFoldDerivedLaunch(instance.threads),34        .runtime_scalar_argument_count = if (options.runtime_scalar_argument_count == 0) 4 else options.runtime_scalar_argument_count,35        .static_arguments = options.static_arguments,36    });37}

1pub fn philoxFoldBitsReference(rounds: u32, output_index: u32, samples: u32, key: [2]u32) u32 {2    var accumulator: u32 = 0;3    for (0..samples) |sample| {4        const words = philoxBlock(rounds, .{ output_index, @intCast(sample), 0, 0 }, key);5        for (words) |word| accumulator ^= word;6    }7    return accumulator;8}

1pub fn philoxFoldFamilyEntryName(allocator: std.mem.Allocator, instance: PhiloxFold) ![]u8 {2    return std.fmt.allocPrint(3        allocator,4        "accy_kernel_random_philox_fold_family_{d}r_{d}_{s}",5        .{ instance.rounds, instance.threads, instance.dtype.name() },6    );7}

1pub fn philoxFoldFamilyFingerprint(backing_allocator: std.mem.Allocator, instance: PhiloxFold) !u64 {2    var family = try randomShapeFamily(backing_allocator, "philox_fold", instance.count_axis);3    defer family.deinit();4    return shape.fingerprint(family);5}

1pub fn philoxFoldFamilyTarget(allocator: std.mem.Allocator, instance: PhiloxFold) ![]u8 {2    return std.fmt.allocPrint(3        allocator,4        "accy.kernel.random.philox_fold_family_{d}r_{d}_{s}",5        .{ instance.rounds, instance.threads, instance.dtype.name() },6    );7}

1pub fn philoxFoldFamilyTuningKey(2    backing_allocator: std.mem.Allocator,3    device_fingerprint: u64,4    instance: PhiloxFold,5) !tuning.FamilyTuningKey {6    const family_fingerprint = try philoxFoldFamilyFingerprint(backing_allocator, instance);7    const extents = philoxFoldTuningExtents(instance);8    return tuning.FamilyTuningKey.init(9        device_fingerprint,10        family_fingerprint,11        entry.operationFingerprint(philoxFoldTuningOperation(instance)),12        instance.dtype,13        philox_fold_family_version,14        extents[0..],15    ) orelse unreachable;16}

1pub fn philoxFoldRuntimeArguments(instance: PhiloxFold) ![4]choir_abi.ScalarArgument {2    if (instance.samples == 0) return error.ExtentOverflowsIndexRange;3    return .{4        .{ .u32 = try runtimeExtentArgument(instance.count) },5        .{ .u32 = instance.samples },6        .{ .u32 = instance.seedLo() },7        .{ .u32 = instance.seedHi() },8    };9}

1pub fn philoxFoldShapeProfileDimensions(instance: PhiloxFold) [2]artifact_product.KernelCallShapeProfileDimension {2    return .{3        .{ .name = instance.count_axis, .runtime_scalar_argument_index = 0, .bounds = randomRuntimeExtentBounds() },4        .{ .name = "k", .runtime_scalar_argument_index = 1, .bounds = randomRuntimeExtentBounds() },5    };6}

1pub fn philoxFoldTuningExtents(instance: PhiloxFold) [2]u64 {2    return .{ instance.count, instance.samples };3}

1pub fn philoxFoldTuningOperation(instance: PhiloxFold) entry.Operation {2    return .{ .random = .{ .philox_fold = instance.rounds } };3}

1pub fn philoxFoldUniformReference(rounds: u32, output_index: u32, samples: u32, key: [2]u32) f32 {2    var accumulator: f32 = 0.0;3    for (0..samples) |sample| {4        const words = philoxBlock(rounds, .{ output_index, @intCast(sample), 0, 0 }, key);5        for (words) |word| accumulator += uniformFromBits(word);6    }7    return accumulator;8}

1pub const PhiloxFoldRuntimeFamilyF32 = philoxFoldRuntimeFamily(.f32);

1pub const PhiloxFoldRuntimeFamilyI32 = philoxFoldRuntimeFamily(.i32);

1pub const philox_fold_family_version: u32 = 1;

1pub fn createSquaresFoldFamilyArtifact(2    allocator: std.mem.Allocator,3    handle: kernel.BackendHandle,4    instance: SquaresFold,5    options: entry.ArtifactOptions,6) !kernel.OwnedKernelCallArtifact {7    const target = try squaresFoldFamilyTarget(allocator, instance);8    defer allocator.free(target);9    const entry_name = try squaresFoldFamilyEntryName(allocator, instance);10    defer allocator.free(entry_name);11    const family_fingerprint = options.shape_family_fingerprint orelse try squaresFoldFamilyFingerprint(allocator, instance);12    const shape_profile_dimensions = squaresFoldShapeProfileDimensions(instance);13    const shape_profile = options.shape_profile orelse artifact_product.KernelCallShapeProfile{14        .name = "squares_fold",15        .fingerprint = family_fingerprint,16        .dimensions = shape_profile_dimensions[0..],17    };1819    var graph = switch (instance.dtype) {20        .f32 => try SquaresFoldRuntimeFamilyF32.buildNamed(allocator, options.limits, entry_name, instance),21        .i32 => try SquaresFoldRuntimeFamilyI32.buildNamed(allocator, options.limits, entry_name, instance),22        else => return error.UnsupportedDType,23    };24    defer graph.deinit();25    return kernel.createKernelCallArtifact(allocator, handle, &graph, .{26        .target = target,27        .version = squares_fold_family_version,28        .format = options.format,29        .kernel_plan = options.kernel_plan,30        .element_count_argument = options.element_count_argument,31        .shape_family_fingerprint = family_fingerprint,32        .shape_profile = shape_profile,33        .launch = options.launch orelse try randomFoldDerivedLaunch(instance.threads),34        .runtime_scalar_argument_count = if (options.runtime_scalar_argument_count == 0) 4 else options.runtime_scalar_argument_count,35        .static_arguments = options.static_arguments,36    });37}

1pub fn squaresFoldBitsReference(output_index: u32, samples: u32, key: u64) u32 {2    var accumulator: u32 = 0;3    for (0..samples) |sample| {4        const counter = @as(u64, output_index) | (@as(u64, @intCast(sample)) << 32);5        accumulator ^= squaresBlock(counter, key);6    }7    return accumulator;8}

1pub fn squaresFoldFamilyEntryName(allocator: std.mem.Allocator, instance: SquaresFold) ![]u8 {2    return std.fmt.allocPrint(3        allocator,4        "accy_kernel_random_squares_fold_family_{d}_{s}",5        .{ instance.threads, instance.dtype.name() },6    );7}

1pub fn squaresFoldFamilyFingerprint(backing_allocator: std.mem.Allocator, instance: SquaresFold) !u64 {2    var family = try randomShapeFamily(backing_allocator, "squares_fold", instance.count_axis);3    defer family.deinit();4    return shape.fingerprint(family);5}

1pub fn squaresFoldFamilyTarget(allocator: std.mem.Allocator, instance: SquaresFold) ![]u8 {2    return std.fmt.allocPrint(3        allocator,4        "accy.kernel.random.squares_fold_family_{d}_{s}",5        .{ instance.threads, instance.dtype.name() },6    );7}

1pub fn squaresFoldFamilyTuningKey(2    backing_allocator: std.mem.Allocator,3    device_fingerprint: u64,4    instance: SquaresFold,5) !tuning.FamilyTuningKey {6    const family_fingerprint = try squaresFoldFamilyFingerprint(backing_allocator, instance);7    const extents = squaresFoldTuningExtents(instance);8    return tuning.FamilyTuningKey.init(9        device_fingerprint,10        family_fingerprint,11        entry.operationFingerprint(squaresFoldTuningOperation(instance)),12        instance.dtype,13        squares_fold_family_version,14        extents[0..],15    ) orelse unreachable;16}

1pub fn squaresFoldRuntimeArguments(instance: SquaresFold) ![4]choir_abi.ScalarArgument {2    if (instance.samples == 0) return error.ExtentOverflowsIndexRange;3    return .{4        .{ .u32 = try runtimeExtentArgument(instance.count) },5        .{ .u32 = instance.samples },6        .{ .u32 = instance.keyLo() },7        .{ .u32 = instance.keyHi() },8    };9}

1pub fn squaresFoldShapeProfileDimensions(instance: SquaresFold) [2]artifact_product.KernelCallShapeProfileDimension {2    return .{3        .{ .name = instance.count_axis, .runtime_scalar_argument_index = 0, .bounds = randomRuntimeExtentBounds() },4        .{ .name = "k", .runtime_scalar_argument_index = 1, .bounds = randomRuntimeExtentBounds() },5    };6}

1pub fn squaresFoldTuningExtents(instance: SquaresFold) [2]u64 {2    return .{ instance.count, instance.samples };3}

1pub fn squaresFoldTuningOperation(instance: SquaresFold) entry.Operation {2    _ = instance;3    return .{ .random = .squares_fold };4}

1pub fn squaresFoldUniformReference(output_index: u32, samples: u32, key: u64) f32 {2    var accumulator: f32 = 0.0;3    for (0..samples) |sample| {4        const counter = @as(u64, output_index) | (@as(u64, @intCast(sample)) << 32);5        accumulator += uniformFromBits(squaresBlock(counter, key));6    }7    return accumulator;8}

1pub const SquaresFoldRuntimeFamilyF32 = squaresFoldRuntimeFamily(.f32);

1pub const SquaresFoldRuntimeFamilyI32 = squaresFoldRuntimeFamily(.i32);

1pub const squares_fold_family_version: u32 = 1;

1pub fn createThreefryFoldFamilyArtifact(2    allocator: std.mem.Allocator,3    handle: kernel.BackendHandle,4    instance: ThreefryFold,5    options: entry.ArtifactOptions,6) !kernel.OwnedKernelCallArtifact {7    const target = try threefryFoldFamilyTarget(allocator, instance);8    defer allocator.free(target);9    const entry_name = try threefryFoldFamilyEntryName(allocator, instance);10    defer allocator.free(entry_name);11    const family_fingerprint = options.shape_family_fingerprint orelse try threefryFoldFamilyFingerprint(allocator, instance);12    const shape_profile_dimensions = threefryFoldShapeProfileDimensions(instance);13    const shape_profile = options.shape_profile orelse artifact_product.KernelCallShapeProfile{14        .name = "threefry_fold",15        .fingerprint = family_fingerprint,16        .dimensions = shape_profile_dimensions[0..],17    };1819    var graph = switch (instance.dtype) {20        .f32 => try ThreefryFoldRuntimeFamilyF32.buildNamed(allocator, options.limits, entry_name, instance),21        .i32 => try ThreefryFoldRuntimeFamilyI32.buildNamed(allocator, options.limits, entry_name, instance),22        else => return error.UnsupportedDType,23    };24    defer graph.deinit();25    return kernel.createKernelCallArtifact(allocator, handle, &graph, .{26        .target = target,27        .version = threefry_fold_family_version,28        .format = options.format,29        .kernel_plan = options.kernel_plan,30        .element_count_argument = options.element_count_argument,31        .shape_family_fingerprint = family_fingerprint,32        .shape_profile = shape_profile,33        .launch = options.launch orelse try randomFoldDerivedLaunch(instance.threads),34        .runtime_scalar_argument_count = if (options.runtime_scalar_argument_count == 0) 4 else options.runtime_scalar_argument_count,35        .static_arguments = options.static_arguments,36    });37}

1pub fn threefryFoldBitsReference(rounds: u32, output_index: u32, samples: u32, key: [2]u32) u32 {2    var accumulator: u32 = 0;3    for (0..samples) |sample| {4        const words = threefryBlock(rounds, .{ output_index, @intCast(sample) }, key);5        for (words) |word| accumulator ^= word;6    }7    return accumulator;8}

1pub fn threefryFoldFamilyEntryName(allocator: std.mem.Allocator, instance: ThreefryFold) ![]u8 {2    return std.fmt.allocPrint(3        allocator,4        "accy_kernel_random_threefry_fold_family_{d}r_{d}_{s}",5        .{ instance.rounds, instance.threads, instance.dtype.name() },6    );7}

1pub fn threefryFoldFamilyFingerprint(backing_allocator: std.mem.Allocator, instance: ThreefryFold) !u64 {2    var family = try randomShapeFamily(backing_allocator, "threefry_fold", instance.count_axis);3    defer family.deinit();4    return shape.fingerprint(family);5}

1pub fn threefryFoldFamilyTarget(allocator: std.mem.Allocator, instance: ThreefryFold) ![]u8 {2    return std.fmt.allocPrint(3        allocator,4        "accy.kernel.random.threefry_fold_family_{d}r_{d}_{s}",5        .{ instance.rounds, instance.threads, instance.dtype.name() },6    );7}

1pub fn threefryFoldFamilyTuningKey(2    backing_allocator: std.mem.Allocator,3    device_fingerprint: u64,4    instance: ThreefryFold,5) !tuning.FamilyTuningKey {6    const family_fingerprint = try threefryFoldFamilyFingerprint(backing_allocator, instance);7    const extents = threefryFoldTuningExtents(instance);8    return tuning.FamilyTuningKey.init(9        device_fingerprint,10        family_fingerprint,11        entry.operationFingerprint(threefryFoldTuningOperation(instance)),12        instance.dtype,13        threefry_fold_family_version,14        extents[0..],15    ) orelse unreachable;16}

1pub fn threefryFoldRuntimeArguments(instance: ThreefryFold) ![4]choir_abi.ScalarArgument {2    if (instance.samples == 0) return error.ExtentOverflowsIndexRange;3    return .{4        .{ .u32 = try runtimeExtentArgument(instance.count) },5        .{ .u32 = instance.samples },6        .{ .u32 = instance.seedLo() },7        .{ .u32 = instance.seedHi() },8    };9}

1pub fn threefryFoldShapeProfileDimensions(instance: ThreefryFold) [2]artifact_product.KernelCallShapeProfileDimension {2    return .{3        .{ .name = instance.count_axis, .runtime_scalar_argument_index = 0, .bounds = randomRuntimeExtentBounds() },4        .{ .name = "k", .runtime_scalar_argument_index = 1, .bounds = randomRuntimeExtentBounds() },5    };6}

1pub fn threefryFoldTuningExtents(instance: ThreefryFold) [2]u64 {2    return .{ instance.count, instance.samples };3}

1pub fn threefryFoldTuningOperation(instance: ThreefryFold) entry.Operation {2    return .{ .random = .{ .threefry_fold = instance.rounds } };3}

1pub fn threefryFoldUniformReference(rounds: u32, output_index: u32, samples: u32, key: [2]u32) f32 {2    var accumulator: f32 = 0.0;3    for (0..samples) |sample| {4        const words = threefryBlock(rounds, .{ output_index, @intCast(sample) }, key);5        for (words) |word| accumulator += uniformFromBits(word);6    }7    return accumulator;8}

1pub const ThreefryFoldRuntimeFamilyF32 = threefryFoldRuntimeFamily(.f32);

1pub const ThreefryFoldRuntimeFamilyI32 = threefryFoldRuntimeFamily(.i32);

1pub const threefry_fold_family_version: u32 = 1;

1pub fn createPhiloxKeyCounterUniformFamilyArtifact(2    allocator: std.mem.Allocator,3    handle: kernel.BackendHandle,4    instance: PhiloxKeyCounterUniform,5    options: entry.ArtifactOptions,6) !kernel.OwnedKernelCallArtifact {7    const target = try philoxKeyCounterUniformFamilyTarget(allocator, instance);8    defer allocator.free(target);9    const entry_name = try philoxKeyCounterUniformFamilyEntryName(allocator, instance);10    defer allocator.free(entry_name);11    const family_fingerprint = options.shape_family_fingerprint orelse try profile.philoxKeyCounterUniformFamilyFingerprint(allocator, instance);12    const shape_profile_dimensions = profile.philoxKeyCounterUniformShapeProfileDimensions(instance);13    const shape_profile = options.shape_profile orelse artifact_product.KernelCallShapeProfile{14        .name = "philox_key_counter_uniform",15        .fingerprint = family_fingerprint,16        .dimensions = shape_profile_dimensions[0..],17    };1819    var graph = switch (instance.dtype) {20        .f32 => try PhiloxKeyCounterUniformRuntimeFamilyF32.buildNamed(allocator, options.limits, entry_name, instance),21        .i32 => try PhiloxKeyCounterUniformRuntimeFamilyI32.buildNamed(allocator, options.limits, entry_name, instance),22        else => return error.UnsupportedDType,23    };24    defer graph.deinit();25    return kernel.createKernelCallArtifact(allocator, handle, &graph, .{26        .target = target,27        .version = philox_key_counter_uniform_family_version,28        .format = options.format,29        .kernel_plan = options.kernel_plan,30        .element_count_argument = options.element_count_argument,31        .shape_family_fingerprint = family_fingerprint,32        .shape_profile = shape_profile,33        .launch = options.launch orelse try randomFoldDerivedLaunch(instance.threads),34        .runtime_scalar_argument_count = if (options.runtime_scalar_argument_count == 0) 1 else options.runtime_scalar_argument_count,35        .static_arguments = options.static_arguments,36    });37}

1pub fn createPhiloxKeySplitFamilyArtifact(2    allocator: std.mem.Allocator,3    handle: kernel.BackendHandle,4    instance: PhiloxKeySplit,5    options: entry.ArtifactOptions,6) !kernel.OwnedKernelCallArtifact {7    const target = try philoxKeySplitFamilyTarget(allocator, instance);8    defer allocator.free(target);9    const entry_name = try philoxKeySplitFamilyEntryName(allocator, instance);10    defer allocator.free(entry_name);11    const family_fingerprint = options.shape_family_fingerprint orelse try profile.philoxKeySplitFamilyFingerprint(allocator, instance);12    const shape_profile_dimensions = profile.philoxKeySplitShapeProfileDimensions(instance);13    const shape_profile = options.shape_profile orelse artifact_product.KernelCallShapeProfile{14        .name = "philox_key_split",15        .fingerprint = family_fingerprint,16        .dimensions = shape_profile_dimensions[0..],17    };1819    var graph = try PhiloxKeySplitRuntimeFamily.buildNamed(allocator, options.limits, entry_name, instance);20    defer graph.deinit();21    return kernel.createKernelCallArtifact(allocator, handle, &graph, .{22        .target = target,23        .version = philox_key_split_family_version,24        .format = options.format,25        .kernel_plan = options.kernel_plan,26        .element_count_argument = options.element_count_argument,27        .shape_family_fingerprint = family_fingerprint,28        .shape_profile = shape_profile,29        .launch = options.launch orelse try randomFoldDerivedLaunch(instance.threads),30        .runtime_scalar_argument_count = if (options.runtime_scalar_argument_count == 0) 1 else options.runtime_scalar_argument_count,31        .static_arguments = options.static_arguments,32    });33}

1pub fn createPhiloxKeyUniformFamilyArtifact(2    allocator: std.mem.Allocator,3    handle: kernel.BackendHandle,4    instance: PhiloxKeyUniform,5    options: entry.ArtifactOptions,6) !kernel.OwnedKernelCallArtifact {7    const target = try philoxKeyUniformFamilyTarget(allocator, instance);8    defer allocator.free(target);9    const entry_name = try philoxKeyUniformFamilyEntryName(allocator, instance);10    defer allocator.free(entry_name);11    const family_fingerprint = options.shape_family_fingerprint orelse try profile.philoxKeyUniformFamilyFingerprint(allocator, instance);12    const shape_profile_dimensions = profile.philoxKeyUniformShapeProfileDimensions(instance);13    const shape_profile = options.shape_profile orelse artifact_product.KernelCallShapeProfile{14        .name = "philox_key_uniform",15        .fingerprint = family_fingerprint,16        .dimensions = shape_profile_dimensions[0..],17    };1819    var graph = switch (instance.dtype) {20        .f32 => try PhiloxKeyUniformRuntimeFamilyF32.buildNamed(allocator, options.limits, entry_name, instance),21        .i32 => try PhiloxKeyUniformRuntimeFamilyI32.buildNamed(allocator, options.limits, entry_name, instance),22        else => return error.UnsupportedDType,23    };24    defer graph.deinit();25    return kernel.createKernelCallArtifact(allocator, handle, &graph, .{26        .target = target,27        .version = philox_key_uniform_family_version,28        .format = options.format,29        .kernel_plan = options.kernel_plan,30        .element_count_argument = options.element_count_argument,31        .shape_family_fingerprint = family_fingerprint,32        .shape_profile = shape_profile,33        .launch = options.launch orelse try randomFoldDerivedLaunch(instance.threads),34        .runtime_scalar_argument_count = if (options.runtime_scalar_argument_count == 0) 1 else options.runtime_scalar_argument_count,35        .static_arguments = options.static_arguments,36    });37}

1pub fn philoxKeyCounterUniformFamilyEntryName(allocator: std.mem.Allocator, instance: PhiloxKeyCounterUniform) ![]u8 {2    return std.fmt.allocPrint(3        allocator,4        "accy_kernel_random_philox_key_counter_uniform_family_{d}r_{d}_{s}",5        .{ instance.rounds, instance.threads, instance.dtype.name() },6    );7}

1pub fn philoxKeyCounterUniformFamilyTarget(allocator: std.mem.Allocator, instance: PhiloxKeyCounterUniform) ![]u8 {2    return std.fmt.allocPrint(3        allocator,4        "accy.kernel.random.philox_key_counter_uniform_family_{d}r_{d}_{s}",5        .{ instance.rounds, instance.threads, instance.dtype.name() },6    );7}

1pub fn philoxKeySplitFamilyEntryName(allocator: std.mem.Allocator, instance: PhiloxKeySplit) ![]u8 {2    return std.fmt.allocPrint(3        allocator,4        "accy_kernel_random_philox_key_split_family_{d}r_{d}_key",5        .{ instance.rounds, instance.threads },6    );7}

1pub fn philoxKeySplitFamilyTarget(allocator: std.mem.Allocator, instance: PhiloxKeySplit) ![]u8 {2    return std.fmt.allocPrint(3        allocator,4        "accy.kernel.random.philox_key_split_family_{d}r_{d}_key",5        .{ instance.rounds, instance.threads },6    );7}

1pub fn philoxKeyUniformFamilyEntryName(allocator: std.mem.Allocator, instance: PhiloxKeyUniform) ![]u8 {2    return std.fmt.allocPrint(3        allocator,4        "accy_kernel_random_philox_key_uniform_family_{d}r_{d}_{s}",5        .{ instance.rounds, instance.threads, instance.dtype.name() },6    );7}

1pub fn philoxKeyUniformFamilyTarget(allocator: std.mem.Allocator, instance: PhiloxKeyUniform) ![]u8 {2    return std.fmt.allocPrint(3        allocator,4        "accy.kernel.random.philox_key_uniform_family_{d}r_{d}_{s}",5        .{ instance.rounds, instance.threads, instance.dtype.name() },6    );7}

1pub fn philoxKeyCounterUniformFamilyFingerprint(backing_allocator: std.mem.Allocator, instance: PhiloxKeyCounterUniform) !u64 {2    var family = try philoxKeyCounterUniformShapeFamily(backing_allocator, instance);3    defer family.deinit();4    return shape.fingerprint(family);5}

1pub fn philoxKeyCounterUniformFamilySpecialization(backing_allocator: std.mem.Allocator, instance: PhiloxKeyCounterUniform) !entry.OwnedSpecialization {2    var owned = entry.OwnedSpecialization.init(backing_allocator);3    errdefer owned.deinit();4    const lifetime_allocator = owned.allocator();56    const inputs = try lifetime_allocator.alloc(entry.Shape, 2);7    inputs[0] = entry.runtimeShapeScalar();8    inputs[1] = entry.runtimeShapeScalar();9    const outputs = try lifetime_allocator.alloc(entry.Shape, 1);10    outputs[0] = try entry.runtimeShape1D(lifetime_allocator, instance.count_axis, instance.count);1112    owned.value = .{13        .dtype = instance.dtype,14        .operation = .{ .random = .{ .philox_key_counter_uniform = instance.rounds } },15        .inputs = inputs,16        .outputs = outputs,17        .schedule = try entry.runtimeThreadBlocks1D(lifetime_allocator, "e", instance.generators(), instance.threads),18    };19    owned.value.launch = owned.value.schedule.?.launch();20    var family = try philoxKeyCounterUniformShapeFamily(backing_allocator, instance);21    errdefer family.deinit();22    try owned.takeShapeFamily(&family);23    return owned;24}

1pub fn philoxKeyCounterUniformInstanceFromSpecialization(specialization: entry.Specialization) ?PhiloxKeyCounterUniform {2    if (!specialization.scheduleMatchesLaunch()) return null;3    const operation = specialization.operation orelse return null;4    const rounds = switch (operation) {5        .random => |random_operation| switch (random_operation) {6            .philox_key_counter_uniform => |rounds| rounds,7            else => return null,8        },9        else => return null,10    };11    const dtype = specialization.dtype orelse return null;12    if (!randomDTypeSupported(dtype)) return null;13    if (specialization.inputs.len != 2 or specialization.outputs.len != 1) return null;14    if (specialization.reductions.len != 0) return null;15    if (specialization.inputs[0].axes.len != 0 or specialization.inputs[1].axes.len != 0) return null;16    const output = specialization.outputs[0];17    if (output.axes.len != 1) return null;18    const launch = specialization.launch orelse return null;19    if (launch.threadgroup[0] == 0) return null;20    return .{21        .count = output.axes[0].extent,22        .rounds = rounds,23        .dtype = dtype,24        .threads = launch.threadgroup[0],25        .count_axis = output.axes[0].name,26    };27}

1pub fn philoxKeyCounterUniformRuntimeArguments(instance: PhiloxKeyCounterUniform) ![1]choir_abi.ScalarArgument {2    return .{.{ .u32 = try runtimeExtentArgument(instance.count) }};3}

1pub fn philoxKeyCounterUniformShapeFamily(backing_allocator: std.mem.Allocator, instance: PhiloxKeyCounterUniform) !shape.Family {2    return randomShapeFamily(backing_allocator, "philox_key_counter_uniform", instance.count_axis);3}

1pub fn philoxKeyCounterUniformShapeProfileDimensions(instance: PhiloxKeyCounterUniform) [1]artifact_product.KernelCallShapeProfileDimension {2    return .{.{ .name = instance.count_axis, .runtime_scalar_argument_index = 0, .bounds = randomRuntimeExtentBounds() }};3}

1pub fn philoxKeySplitFamilyFingerprint(backing_allocator: std.mem.Allocator, instance: PhiloxKeySplit) !u64 {2    var family = try philoxKeySplitShapeFamily(backing_allocator, instance);3    defer family.deinit();4    return shape.fingerprint(family);5}

1pub fn philoxKeySplitFamilySpecialization(backing_allocator: std.mem.Allocator, instance: PhiloxKeySplit) !entry.OwnedSpecialization {2    var owned = entry.OwnedSpecialization.init(backing_allocator);3    errdefer owned.deinit();4    const lifetime_allocator = owned.allocator();56    const inputs = try lifetime_allocator.alloc(entry.Shape, 1);7    inputs[0] = entry.runtimeShapeScalar();8    const outputs = try lifetime_allocator.alloc(entry.Shape, 1);9    outputs[0] = try entry.runtimeShape1D(lifetime_allocator, instance.count_axis, instance.count);1011    owned.value = .{12        .dtype = .key,13        .operation = .{ .random = .{ .philox_key_split = instance.rounds } },14        .inputs = inputs,15        .outputs = outputs,16        .schedule = try entry.runtimeThreadBlocks1D(lifetime_allocator, "e", instance.generators(), instance.threads),17    };18    owned.value.launch = owned.value.schedule.?.launch();19    var family = try philoxKeySplitShapeFamily(backing_allocator, instance);20    errdefer family.deinit();21    try owned.takeShapeFamily(&family);22    return owned;23}

1pub fn philoxKeySplitInstanceFromSpecialization(specialization: entry.Specialization) ?PhiloxKeySplit {2    if (!specialization.scheduleMatchesLaunch()) return null;3    const operation = specialization.operation orelse return null;4    const rounds = switch (operation) {5        .random => |random_operation| switch (random_operation) {6            .philox_key_split => |rounds| rounds,7            else => return null,8        },9        else => return null,10    };11    const dtype = specialization.dtype orelse return null;12    if (dtype != .key) return null;13    if (specialization.inputs.len != 1 or specialization.outputs.len != 1) return null;14    if (specialization.inputs[0].axes.len != 0) return null;15    if (specialization.reductions.len != 0) return null;16    const output = specialization.outputs[0];17    if (output.axes.len != 1) return null;18    const launch = specialization.launch orelse return null;19    if (launch.threadgroup[0] == 0) return null;20    return .{21        .count = output.axes[0].extent,22        .rounds = rounds,23        .threads = launch.threadgroup[0],24        .count_axis = output.axes[0].name,25    };26}

1pub fn philoxKeySplitRuntimeArguments(instance: PhiloxKeySplit) ![1]choir_abi.ScalarArgument {2    return .{.{ .u32 = try runtimeExtentArgument(instance.count) }};3}

1pub fn philoxKeySplitShapeFamily(backing_allocator: std.mem.Allocator, instance: PhiloxKeySplit) !shape.Family {2    return randomShapeFamily(backing_allocator, "philox_key_split", instance.count_axis);3}

1pub fn philoxKeySplitShapeProfileDimensions(instance: PhiloxKeySplit) [1]artifact_product.KernelCallShapeProfileDimension {2    return .{.{ .name = instance.count_axis, .runtime_scalar_argument_index = 0, .bounds = randomRuntimeExtentBounds() }};3}

1pub fn philoxKeyUniformFamilyFingerprint(backing_allocator: std.mem.Allocator, instance: PhiloxKeyUniform) !u64 {2    var family = try philoxKeyUniformShapeFamily(backing_allocator, instance);3    defer family.deinit();4    return shape.fingerprint(family);5}

1pub fn philoxKeyUniformFamilySpecialization(backing_allocator: std.mem.Allocator, instance: PhiloxKeyUniform) !entry.OwnedSpecialization {2    var owned = entry.OwnedSpecialization.init(backing_allocator);3    errdefer owned.deinit();4    const lifetime_allocator = owned.allocator();56    const inputs = try lifetime_allocator.alloc(entry.Shape, 1);7    inputs[0] = try entry.runtimeShape1D(lifetime_allocator, instance.count_axis, instance.count);8    const outputs = try lifetime_allocator.alloc(entry.Shape, 1);9    outputs[0] = try entry.runtimeShape1D(lifetime_allocator, instance.count_axis, instance.count);1011    owned.value = .{12        .dtype = instance.dtype,13        .operation = .{ .random = .{ .philox_key_uniform = instance.rounds } },14        .inputs = inputs,15        .outputs = outputs,16        .schedule = try entry.runtimeThreadBlocks1D(lifetime_allocator, "e", instance.generators(), instance.threads),17    };18    owned.value.launch = owned.value.schedule.?.launch();19    var family = try philoxKeyUniformShapeFamily(backing_allocator, instance);20    errdefer family.deinit();21    try owned.takeShapeFamily(&family);22    return owned;23}

1pub fn philoxKeyUniformInstanceFromSpecialization(specialization: entry.Specialization) ?PhiloxKeyUniform {2    if (!specialization.scheduleMatchesLaunch()) return null;3    const operation = specialization.operation orelse return null;4    const rounds = switch (operation) {5        .random => |random_operation| switch (random_operation) {6            .philox_key_uniform => |rounds| rounds,7            else => return null,8        },9        else => return null,10    };11    const dtype = specialization.dtype orelse return null;12    if (!randomDTypeSupported(dtype)) return null;13    if (specialization.inputs.len != 1 or specialization.outputs.len != 1) return null;14    if (specialization.reductions.len != 0) return null;15    const input = specialization.inputs[0];16    const output = specialization.outputs[0];17    if (input.axes.len != 1 or output.axes.len != 1) return null;18    if (input.axes[0].extent != output.axes[0].extent) return null;19    const launch = specialization.launch orelse return null;20    if (launch.threadgroup[0] == 0) return null;21    return .{22        .count = output.axes[0].extent,23        .rounds = rounds,24        .dtype = dtype,25        .threads = launch.threadgroup[0],26        .count_axis = output.axes[0].name,27    };28}

1pub fn philoxKeyUniformRuntimeArguments(instance: PhiloxKeyUniform) ![1]choir_abi.ScalarArgument {2    return .{.{ .u32 = try runtimeExtentArgument(instance.count) }};3}

1pub fn philoxKeyUniformShapeFamily(backing_allocator: std.mem.Allocator, instance: PhiloxKeyUniform) !shape.Family {2    return randomShapeFamily(backing_allocator, "philox_key_uniform", instance.count_axis);3}

1pub fn philoxKeyUniformShapeProfileDimensions(instance: PhiloxKeyUniform) [1]artifact_product.KernelCallShapeProfileDimension {2    return .{.{ .name = instance.count_axis, .runtime_scalar_argument_index = 0, .bounds = randomRuntimeExtentBounds() }};3}

1pub const PhiloxKeyCounterUniformRuntimeFamilyF32 = philoxKeyCounterUniformRuntimeFamily(.f32);

1pub const PhiloxKeyCounterUniformRuntimeFamilyI32 = philoxKeyCounterUniformRuntimeFamily(.i32);

1pub const PhiloxKeySplitRuntimeFamily = kernel.logical.Family(.{2    .name = "accy_kernel_random_philox_key_split_runtime_key",3    .parameters = .{4        .dst = kernel.dynamicBuffer(.key),5        .key = kernel.dynamicBuffer(.key),6        .count = kernel.scalar(.i32),7    },8    .Instance = PhiloxKeySplit,9    .schedule = philoxKeySplitSchedule,10    .body = philox_key_split_runtime_family_body,11});

1pub const PhiloxKeyUniformRuntimeFamilyF32 = philoxKeyUniformRuntimeFamily(.f32);

1pub const PhiloxKeyUniformRuntimeFamilyI32 = philoxKeyUniformRuntimeFamily(.i32);

1pub const philox_key_counter_uniform_family_version: u32 = 1;

1pub const philox_key_split_family_version: u32 = 1;

1pub const philox_key_uniform_family_version: u32 = 1;

1pub fn createPhiloxFamilyArtifact(2    allocator: std.mem.Allocator,3    handle: kernel.BackendHandle,4    instance: Philox,5    options: entry.ArtifactOptions,6) !kernel.OwnedKernelCallArtifact {7    const target = try philoxFamilyTarget(allocator, instance);8    defer allocator.free(target);9    const entry_name = try philoxFamilyEntryName(allocator, instance);10    defer allocator.free(entry_name);11    const family_fingerprint = options.shape_family_fingerprint orelse try philoxFamilyFingerprint(allocator, instance);12    const shape_profile_dimensions = philoxShapeProfileDimensions(instance);13    const shape_profile = options.shape_profile orelse artifact_product.KernelCallShapeProfile{14        .name = "philox",15        .fingerprint = family_fingerprint,16        .dimensions = shape_profile_dimensions[0..],17    };1819    var graph = switch (instance.dtype) {20        .f32 => try PhiloxRuntimeFamilyF32.buildNamed(allocator, options.limits, entry_name, instance),21        .i32 => try PhiloxRuntimeFamilyI32.buildNamed(allocator, options.limits, entry_name, instance),22        else => return error.UnsupportedDType,23    };24    defer graph.deinit();25    return kernel.createKernelCallArtifact(allocator, handle, &graph, .{26        .target = target,27        .version = philox_family_version,28        .format = options.format,29        .kernel_plan = options.kernel_plan,30        .element_count_argument = options.element_count_argument,31        .shape_family_fingerprint = family_fingerprint,32        .shape_profile = shape_profile,33        .launch = options.launch orelse try randomDerivedLaunch(instance.threads, philox_lanes),34        .runtime_scalar_argument_count = if (options.runtime_scalar_argument_count == 0) 3 else options.runtime_scalar_argument_count,35        .static_arguments = options.static_arguments,36    });37}