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
// Attention Matrix Multiplication: Compute QK^T scores (f64 canonical)
// Pass 1 of multi-pass attention implementation
//
// Computes: scores[i,j] = Q[i] · K[j] / sqrt(d_k)
// Q: [batch, heads, q_seq_len, head_dim]
// K: [batch, heads, kv_seq_len, head_dim]
// scores: [batch, heads, q_seq_len, kv_seq_len]

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>;
@group(0) @binding(1) var<storage, read> key: array<f64>;
@group(0) @binding(2) var<storage, read_write> scores: array<f64>;
@group(0) @binding(3) var<uniform> params: AttentionParams;

@compute @workgroup_size(16, 16, 1)
fn main(@builtin(global_invocation_id) global_id: vec3<u32>) {
    let batch_head = global_id.z;
    let i = global_id.y; // query position
    let j = global_id.x; // key position
    
    if (i >= params.q_seq_len || j >= params.kv_seq_len) {
        return;
    }
    
    let batch = batch_head / params.num_heads;
    let head = batch_head % params.num_heads;
    
    if (batch >= params.batch_size) {
        return;
    }
    
    var score = f64(0.0);
    for (var d = 0u; d < params.head_dim; d = d + 1u) {
        let q_idx = batch * params.num_heads * params.q_seq_len * params.head_dim
                  + head * params.q_seq_len * params.head_dim
                  + i * params.head_dim
                  + d;
        
        let k_idx = batch * params.num_heads * params.kv_seq_len * params.head_dim
                  + head * params.kv_seq_len * params.head_dim
                  + j * params.head_dim
                  + d;
        
        score += query[q_idx] * key[k_idx];
    }
    
    let scale = sqrt_f64(f64(params.head_dim));
    score = score / scale;
    
    let score_idx = batch * params.num_heads * params.q_seq_len * params.kv_seq_len
                  + head * params.q_seq_len * params.kv_seq_len
                  + i * params.kv_seq_len
                  + j;
    
    scores[score_idx] = score;
}