primal-barracuda 0.4.0

barraCuda — BARrier-free Rust Abstracted Cross-platform Unified Dimensional Algebra. Vendor-agnostic GPU compute via WGSL.
Documentation
// SPDX-License-Identifier: AGPL-3.0-or-later
// PRNG xoshiro128** - High-quality 32-bit pseudorandom number generator
// Adapted for WGSL from the algorithm by David Blackman and Sebastiano Vigna
// Each thread generates one random value from its seed; seeds passed as f32 (bitcast from u32)

@group(0) @binding(0) var<storage, read> seeds: array<f32>;
@group(0) @binding(1) var<storage, read_write> output: array<f32>;
@group(0) @binding(2) var<uniform> params: Params;

struct Params {
    size: u32,
    offset: u32,
}

fn rotl(x: u32, k: u32) -> u32 {
    return (x << k) | (x >> (32u - k));
}

// SplitMix32: derive 32-bit hash from seed (used for state initialization)
fn splitmix32(x: u32) -> u32 {
    var z = x;
    z = (z ^ (z >> 16u)) * 0x85ebca6bu;
    z = (z ^ (z >> 13u)) * 0xc2b2ae35u;
    return z ^ (z >> 16u);
}

// xoshiro128** next: advance state and return random u32
fn xoshiro_next(s: ptr<function, array<u32, 4>>) -> u32 {
    let result = rotl((*s)[1] * 5u, 7u) * 9u;
    let t = (*s)[1] << 9u;
    (*s)[2] = (*s)[2] ^ (*s)[0];
    (*s)[3] = (*s)[3] ^ (*s)[1];
    (*s)[1] = (*s)[1] ^ (*s)[2];
    (*s)[0] = (*s)[0] ^ (*s)[3];
    (*s)[2] = (*s)[2] ^ t;
    (*s)[3] = rotl((*s)[3], 11u);
    return result;
}

// Convert u32 to uniform f32 in [0, 1)
fn to_uniform_01(bits: u32) -> f32 {
    // Use top 23 bits for mantissa; 0x3f800000 = 1.0 in float
    return bitcast<f32>((bits >> 9u) | 0x3f800000u) - 1.0;
}

@compute @workgroup_size(256)
fn main(@builtin(global_invocation_id) global_id: vec3<u32>) {
    let idx = global_id.x;
    if (idx >= params.size) {
        return;
    }

    // Read seed as u32 (stored as f32 bitcast)
    let seed_bits = bitcast<u32>(seeds[idx]);

    // Initialize state via SplitMix32 (ensure non-zero)
    var state: array<u32, 4>;
    var z = seed_bits;
    state[0] = splitmix32(z);
    z = z + 0x9e3779b9u;
    state[1] = splitmix32(z);
    z = z + 0x9e3779b9u;
    state[2] = splitmix32(z);
    z = z + 0x9e3779b9u;
    state[3] = splitmix32(z);

    // Ensure state is not all zeros
    if (state[0] == 0u && state[1] == 0u && state[2] == 0u && state[3] == 0u) {
        state[0] = 1u;
    }

    // Advance by offset steps
    for (var i = 0u; i < params.offset; i = i + 1u) {
        let _unused = xoshiro_next(&state);
    }

    // Generate one random value
    let bits = xoshiro_next(&state);
    output[idx] = to_uniform_01(bits);
}