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
// Tiled Matrix Multiplication - Memory-Optimized (f64 canonical)
//
// **OPTIMIZATION**: Shared memory tiling for 70-80% bandwidth utilization
//
// C = A * B where A is (M, K), B is (K, N), C is (M, N)

@group(0) @binding(0) var<storage, read> A: array<f64>;
@group(0) @binding(1) var<storage, read> B: array<f64>;
@group(0) @binding(2) var<storage, read_write> C: array<f64>;

struct MatmulParams {
    M: u32,
    K: u32,
    N: u32,
}

@group(0) @binding(3) var<uniform> params: MatmulParams;

// Shared memory tiles (16x16 = 256 floats per tile)
var<workgroup> tileA: array<f64, 256>;  // 16x16 tile of A
var<workgroup> tileB: array<f64, 256>;  // 16x16 tile of B

const TILE_SIZE: u32 = 16u;

@compute @workgroup_size(16, 16)
fn main(
    @builtin(global_invocation_id) global_id: vec3<u32>,
    @builtin(local_invocation_id) local_id: vec3<u32>,
    @builtin(workgroup_id) workgroup_id: vec3<u32>,
) {
    let row = global_id.y;
    let col = global_id.x;

    let local_row = local_id.y;
    let local_col = local_id.x;

    let in_bounds = row < params.M && col < params.N;

    var sum = 0.0;

    let num_tiles = (params.K + TILE_SIZE - 1u) / TILE_SIZE;

    for (var tile = 0u; tile < num_tiles; tile = tile + 1u) {
        let a_row = row;
        let a_col = tile * TILE_SIZE + local_col;

        if (a_row < params.M && a_col < params.K) {
            tileA[local_row * TILE_SIZE + local_col] = A[a_row * params.K + a_col];
        } else {
            tileA[local_row * TILE_SIZE + local_col] = 0.0;
        }

        let b_row = tile * TILE_SIZE + local_row;
        let b_col = col;

        if (b_row < params.K && b_col < params.N) {
            tileB[local_row * TILE_SIZE + local_col] = B[b_row * params.N + b_col];
        } else {
            tileB[local_row * TILE_SIZE + local_col] = 0.0;
        }

        workgroupBarrier();

        for (var k = 0u; k < TILE_SIZE; k = k + 1u) {
            let a_val = tileA[local_row * TILE_SIZE + k];
            let b_val = tileB[k * TILE_SIZE + local_col];
            sum = sum + a_val * b_val;
        }

        workgroupBarrier();
    }

    if (in_bounds) {
        C[row * params.N + col] = sum;
    }
}