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
// Multi-Head Attention: Output Projection with Head Concatenation (f64 canonical)
// Concatenates heads and projects through output weight matrix
//
// Input: [batch, num_heads, seq_len, head_dim]
// Weight: [d_model, d_model]
// Output: [batch, seq_len, d_model]
//
// Algorithm:
// 1. Reshape [B,H,S,D/H] → [B,S,D] (concatenate heads)
// 2. Project: output[b,s,i] = sum_j(concat[b,s,j] * weight[j,i])

struct Params {
    batch_size: u32,
    seq_len: u32,
    d_model: u32,
    num_heads: u32,
    head_dim: u32,
}

@group(0) @binding(0) var<storage, read> input: array<f64>;   // [B, H, S, D/H]
@group(0) @binding(1) var<storage, read> weight: array<f64>;  // [D, D]
@group(0) @binding(2) var<storage, read_write> output: array<f64>; // [B, S, D]
@group(0) @binding(3) var<uniform> params: Params;

@compute @workgroup_size(16, 16, 1)
fn main(@builtin(global_invocation_id) global_id: vec3<u32>) {
    let b = global_id.x; // batch
    let s = global_id.y; // seq position
    let out_dim = global_id.z; // output dimension

    if (b >= params.batch_size || s >= params.seq_len || out_dim >= params.d_model) {
        return;
    }

    var sum = 0.0;

    // Concatenate heads and project through output matrix
    for (var h = 0u; h < params.num_heads; h++) {
        for (var d = 0u; d < params.head_dim; d++) {
            // Read from input: [b, h, s, d]
            let input_idx = b * params.num_heads * params.seq_len * params.head_dim +
                           h * params.seq_len * params.head_dim +
                           s * params.head_dim +
                           d;

            // Concatenated index in flat array [b, s, h*head_dim + d]
            let concat_dim = h * params.head_dim + d;

            // Weight index: [concat_dim, out_dim]
            let weight_idx = concat_dim * params.d_model + out_dim;

            sum += input[input_idx] * weight[weight_idx];
        }
    }

    // Write output: [b, s, out_dim]
    let out_idx = b * params.seq_len * params.d_model + s * params.d_model + out_dim;
    output[out_idx] = sum;
}