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
// LayerNorm Statistics Computation (Dispatch 1 of 2) - f64 canonical
//
// **2-DISPATCH FUSED LAYERNORM - PART 1: STATISTICS**
//
// This shader computes partial mean and variance per workgroup.

@group(0) @binding(0) var<storage, read> input: array<f64>;
@group(0) @binding(1) var<storage, read_write> partial_stats: array<f64>;  // [mean, m2, count] per workgroup
@group(0) @binding(2) var<storage, read_write> global_stats: array<f64>;   // [mean, variance]

struct Params {
    size: u32,
    epsilon: f64,
    num_workgroups: u32,
}
@group(0) @binding(3) var<uniform> params: Params;

var<workgroup> shared_mean: array<f64, 256>;
var<workgroup> shared_m2: array<f64, 256>;
var<workgroup> shared_count: array<u32, 256>;

@compute @workgroup_size(256)
fn main(
    @builtin(global_invocation_id) global_id: vec3<u32>,
    @builtin(local_invocation_id) local_id: vec3<u32>,
    @builtin(workgroup_id) workgroup_id: vec3<u32>,
    @builtin(num_workgroups) num_workgroups: vec3<u32>,
) {
    let tid = local_id.x;
    let wg_id = workgroup_id.x;
    let total_threads = 256u * num_workgroups.x;

    var local_mean: f64 = 0.0;
    var local_m2: f64 = 0.0;
    var local_count: u32 = 0u;

    for (var i = global_id.x; i < params.size; i = i + total_threads) {
        let value = input[i];
        local_count = local_count + 1u;

        let delta = value - local_mean;
        local_mean = local_mean + delta / f64(local_count);
        let delta2 = value - local_mean;
        local_m2 = local_m2 + delta * delta2;
    }

    shared_mean[tid] = local_mean;
    shared_m2[tid] = local_m2;
    shared_count[tid] = local_count;
    workgroupBarrier();

    for (var stride = 128u; stride > 0u; stride = stride / 2u) {
        if (tid < stride && (tid + stride) < 256u) {
            let count_a = shared_count[tid];
            let count_b = shared_count[tid + stride];
            let total_count = count_a + count_b;

            if (total_count > 0u) {
                let mean_a = shared_mean[tid];
                let mean_b = shared_mean[tid + stride];
                let m2_a = shared_m2[tid];
                let m2_b = shared_m2[tid + stride];

                let delta = mean_b - mean_a;
                let combined_mean = mean_a + delta * f64(count_b) / f64(total_count);

                let combined_m2 = m2_a + m2_b + delta * delta * f64(count_a) * f64(count_b) / f64(total_count);

                shared_mean[tid] = combined_mean;
                shared_m2[tid] = combined_m2;
                shared_count[tid] = total_count;
            }
        }
        workgroupBarrier();
    }

    if (tid == 0u) {
        let base = wg_id * 3u;
        partial_stats[base] = shared_mean[0];
        partial_stats[base + 1u] = shared_m2[0];
        partial_stats[base + 2u] = f64(shared_count[0]);
    }
}