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
// Scaled Dot-Product Attention in DF64 precision
// attn(Q, K, V) = softmax(Q @ K^T / sqrt(d_k)) @ V
//
// Single-head, batch_size=1, for validation / high-precision inference.
// Q: [seq_q, d_k], K: [seq_k, d_k], V: [seq_k, d_v]
// Output: [seq_q, d_v]
//
// Requires: df64_core.wgsl, df64_transcendentals.wgsl (via compile_shader_df64)

struct SdpaParams {
    seq_q: u32,
    seq_k: u32,
    d_k: u32,
    d_v: u32,
}

@group(0) @binding(0) var<storage, read> q_hi: array<f32>;
@group(0) @binding(1) var<storage, read> q_lo: array<f32>;
@group(0) @binding(2) var<storage, read> k_hi: array<f32>;
@group(0) @binding(3) var<storage, read> k_lo: array<f32>;
@group(0) @binding(4) var<storage, read> v_hi: array<f32>;
@group(0) @binding(5) var<storage, read> v_lo: array<f32>;
@group(0) @binding(6) var<storage, read_write> out_hi: array<f32>;
@group(0) @binding(7) var<storage, read_write> out_lo: array<f32>;
@group(0) @binding(8) var<uniform> params: SdpaParams;

@compute @workgroup_size(1)
fn main(@builtin(workgroup_id) wg_id: vec3<u32>) {
    let qi = wg_id.x;
    if (qi >= params.seq_q) { return; }

    let inv_sqrt_dk = df64_div(df64_from_f32(1.0), sqrt_df64(df64_from_f32(f32(params.d_k))));

    // Compute attention scores: score[j] = (Q[qi] . K[j]) / sqrt(d_k)
    // Then softmax over j, then weighted sum of V[j]

    // Pass 1: compute scores and find max
    var max_score = Df64(-3.4e38, 0.0);
    for (var j = 0u; j < params.seq_k; j = j + 1u) {
        var dot = df64_from_f32(0.0);
        for (var d = 0u; d < params.d_k; d = d + 1u) {
            let q_val = Df64(q_hi[qi * params.d_k + d], q_lo[qi * params.d_k + d]);
            let k_val = Df64(k_hi[j * params.d_k + d], k_lo[j * params.d_k + d]);
            dot = df64_add(dot, df64_mul(q_val, k_val));
        }
        let score = df64_mul(dot, inv_sqrt_dk);
        if (score.hi > max_score.hi) {
            max_score = score;
        }
    }

    // Pass 2: exp(score - max) and sum
    var sum_exp = df64_from_f32(0.0);
    for (var j = 0u; j < params.seq_k; j = j + 1u) {
        var dot = df64_from_f32(0.0);
        for (var d = 0u; d < params.d_k; d = d + 1u) {
            let q_val = Df64(q_hi[qi * params.d_k + d], q_lo[qi * params.d_k + d]);
            let k_val = Df64(k_hi[j * params.d_k + d], k_lo[j * params.d_k + d]);
            dot = df64_add(dot, df64_mul(q_val, k_val));
        }
        let score = df64_mul(dot, inv_sqrt_dk);
        let exp_val = exp_df64(df64_sub(score, max_score));
        sum_exp = df64_add(sum_exp, exp_val);
    }

    // Pass 3: output = sum_j( softmax(score_j) * V[j] )
    for (var dv = 0u; dv < params.d_v; dv = dv + 1u) {
        var acc = df64_from_f32(0.0);
        for (var j = 0u; j < params.seq_k; j = j + 1u) {
            var dot = df64_from_f32(0.0);
            for (var d = 0u; d < params.d_k; d = d + 1u) {
                let q_val = Df64(q_hi[qi * params.d_k + d], q_lo[qi * params.d_k + d]);
                let k_val = Df64(k_hi[j * params.d_k + d], k_lo[j * params.d_k + d]);
                dot = df64_add(dot, df64_mul(q_val, k_val));
            }
            let score = df64_mul(dot, inv_sqrt_dk);
            let weight = df64_div(exp_df64(df64_sub(score, max_score)), sum_exp);
            let v_val = Df64(v_hi[j * params.d_v + dv], v_lo[j * params.d_v + dv]);
            acc = df64_add(acc, df64_mul(weight, v_val));
        }
        out_hi[qi * params.d_v + dv] = acc.hi;
        out_lo[qi * params.d_v + dv] = acc.lo;
    }
}