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
//
// ipa_scores_f64.wgsl — Invariant Point Attention scores (AlphaFold2)
//
// Computes: q*k^T/sqrt(d) + w_l * ||T_i(q_pts) - T_j(k_pts)||^2
// Scalar attention score for each (i,j) pair. The geometric term uses squared L2 distance
// between transformed point clouds. For simplicity we assume T_i, T_j are identity here;
// external code may apply transforms before passing q_pts, k_pts.
//
// Bindings: @0 q[N*D], @1 k[N*D], @2 q_pts[N*P*3], @3 k_pts[N*P*3], @4 out[N*N], @5 uniform{n, d, p, w_l}

struct IpaParams {
    n: u32,
    d: u32,
    p: u32,
    w_l: f64,
}

@group(0) @binding(0) var<storage, read>       q: array<f64>;       // [N*D]
@group(0) @binding(1) var<storage, read>       k: array<f64>;       // [N*D]
@group(0) @binding(2) var<storage, read>       q_pts: array<f64>;   // [N*P*3]
@group(0) @binding(3) var<storage, read>       k_pts: array<f64>;   // [N*P*3]
@group(0) @binding(4) var<storage, read_write> out: array<f64>;     // [N*N]
@group(0) @binding(5) var<uniform>             params: IpaParams;

@compute @workgroup_size(64)
fn main(@builtin(global_invocation_id) gid: vec3<u32>) {
    let N = params.n;
    let D = params.d;
    let P = params.p;
    let w_l = params.w_l;
    let idx = gid.x;
    if idx >= N * N { return; }

    let i = idx / N;
    let j = idx % N;

    var dot = f64(0.0);
    let q_base = i * D;
    let k_base = j * D;
    for (var d = 0u; d < D; d = d + 1u) {
        dot += q[q_base + d] * k[k_base + d];
    }
    let scale = sqrt_f64(f64(D));
    var score = dot / scale;

    var geom_sq = f64(0.0);
    let q_pts_base = i * P * 3u;
    let k_pts_base = j * P * 3u;
    for (var p = 0u; p < P; p = p + 1u) {
        let qx = q_pts[q_pts_base + p * 3u + 0u];
        let qy = q_pts[q_pts_base + p * 3u + 1u];
        let qz = q_pts[q_pts_base + p * 3u + 2u];
        let kx = k_pts[k_pts_base + p * 3u + 0u];
        let ky = k_pts[k_pts_base + p * 3u + 1u];
        let kz = k_pts[k_pts_base + p * 3u + 2u];
        let dx = qx - kx;
        let dy = qy - ky;
        let dz = qz - kz;
        geom_sq += dx * dx + dy * dy + dz * dz;
    }
    score += w_l * geom_sq;

    out[idx] = score;
}