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
// sdpa_scores_f64.wgsl — QK^T / sqrt(d_k) — Pass 1 of 3-pass SDPA (f64 canonical)
//
// Computes scaled dot-product scores for each (batch, head, query_pos) triple.
// Output layout: scores[batch, head, q_pos, k_pos] (row-major)
// Supports cross-attention: Q seq_len may differ from K/V seq_len.
//
// Used by TensorSession::attention() as the first of 3 sequential passes:
//   1. sdpa_scores  → scores[B, H, Sq, Skv]
//   2. attention_softmax → weights[B, H, Sq, Skv]
//   3. attention_apply   → output[B, H, Sq, D]

struct AttentionParams {
    batch_size: u32,
    num_heads:  u32,
    q_seq_len:  u32,
    kv_seq_len: u32,
    head_dim:   u32,
    _pad0:      u32,
    _pad1:      u32,
    _pad2:      u32,
}

@group(0) @binding(0) var<storage, read>       query:  array<f64>;  // [B, H, Sq, D]
@group(0) @binding(1) var<storage, read>       key:    array<f64>;  // [B, H, Skv, D]
@group(0) @binding(2) var<storage, read_write> scores: array<f64>;  // [B, H, Sq, Skv]
@group(0) @binding(3) var<uniform>             params: AttentionParams;

@compute @workgroup_size(256)
fn main(@builtin(global_invocation_id) gid: vec3<u32>) {
    let total = params.batch_size * params.num_heads * params.q_seq_len * params.kv_seq_len;
    let idx   = gid.x;
    if idx >= total { return; }

    let bh     = idx / (params.q_seq_len * params.kv_seq_len);
    let rem    = idx % (params.q_seq_len * params.kv_seq_len);
    let q_pos  = rem / params.kv_seq_len;
    let k_pos  = rem % params.kv_seq_len;

    let b    = bh / params.num_heads;
    let h    = bh % params.num_heads;

    if b >= params.batch_size { return; }

    let D     = params.head_dim;
    let Sq    = params.q_seq_len;
    let Skv   = params.kv_seq_len;
    let H     = params.num_heads;

    let q_base = b * H * Sq * D + h * Sq * D + q_pos * D;
    let k_base = b * H * Skv * D + h * Skv * D + k_pos * D;

    var dot = f64(0.0);
    for (var d = 0u; d < D; d++) {
        dot += query[q_base + d] * key[k_base + d];
    }

    let scale  = sqrt_f64(f64(D));
    let out_idx = b * H * Sq * Skv + h * Sq * Skv + q_pos * Skv + k_pos;
    scores[out_idx] = dot / scale;
}