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
//
// recycling_update_f64.wgsl — AlphaFold2 recycling iteration update
//
// out = prev + layer_norm(current - prev)
// Uses running difference with layer norm for iterative refinement.
//
// Bindings: @0 prev[N*C], @1 current[N*C], @2 out[N*C], @3 uniform{n, c, eps}

struct RecyclingParams {
    n: u32,
    c: u32,
    _pad: [u32; 2],
    eps: f64,
}

@group(0) @binding(0) var<storage, read>       prev: array<f64>;    // [N*C]
@group(0) @binding(1) var<storage, read>       current: array<f64>; // [N*C]
@group(0) @binding(2) var<storage, read_write> out: array<f64>;   // [N*C]
@group(0) @binding(3) var<uniform>             params: RecyclingParams;

@compute @workgroup_size(64)
fn main(@builtin(global_invocation_id) gid: vec3<u32>) {
    let N = params.n;
    let C = params.c;
    let eps = params.eps;

    let idx = gid.x;
    if idx >= N * C { return; }

    let row = idx / C;
    let col = idx % C;

    // Compute diff = current - prev for this row (need full row for layer norm)
    // Each thread handles one element; we need shared work for layer norm.
    // Simplified: each thread computes its own diff, then we need a second pass for layer norm.
    // For per-row layer norm, we need to compute mean and var over C elements for row.
    // Use a loop to compute mean and var for this row (each thread does full row - not ideal but works)
    let row_base = row * C;

    var mean_val = f64(0.0);
    for (var k = 0u; k < C; k = k + 1u) {
        mean_val += current[row_base + k] - prev[row_base + k];
    }
    mean_val /= f64(C);

    var var_val = f64(0.0);
    for (var k = 0u; k < C; k = k + 1u) {
        let d = (current[row_base + k] - prev[row_base + k]) - mean_val;
        var_val += d * d;
    }
    var_val = sqrt_f64(var_val / f64(C) + eps);

    let diff = (current[idx] - prev[idx]) - mean_val;
    let normalized = select(f64(0.0), diff / var_val, var_val > eps);

    out[idx] = prev[idx] + normalized;
}