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
//
// swarm_nn_forward_f64.wgsl — Population-parallel MLP forward pass (f64)
//
// Each thread evaluates one (controller, evaluation) pair through a
// 2-layer MLP: input → hidden (sigmoid) → output (argmax).
//
// Weight layout per controller (flat):
//   w1: [input_dim × hidden_dim], b1: [hidden_dim],
//   w2: [hidden_dim × output_dim], b2: [output_dim]
//
// Evolved from f32 → f64 for universal math library portability.

struct SwarmParams {
    n_controllers: u32,
    n_evals:       u32,
    input_dim:     u32,
    hidden_dim:    u32,
    output_dim:    u32,
    _pad0:         u32,
    _pad1:         u32,
    _pad2:         u32,
}

@group(0) @binding(0) var<storage, read>       weights: array<f64>;
@group(0) @binding(1) var<storage, read>       inputs:  array<f64>;
@group(0) @binding(2) var<storage, read_write> actions: array<u32>;
@group(0) @binding(3) var<uniform>             params:  SwarmParams;

fn sigmoid_f64(x: f64) -> f64 {
    let clamped = clamp(x, f64(-500.0), f64(500.0));
    return f64(1.0) / (f64(1.0) + exp(-clamped));
}

@compute @workgroup_size(256)
fn main(@builtin(global_invocation_id) global_id: vec3<u32>) {
    let idx = global_id.x;
    let total = params.n_controllers * params.n_evals;
    if (idx >= total) { return; }

    let ctrl = idx / params.n_evals;
    let eval = idx % params.n_evals;

    let id = params.input_dim;
    let hd = params.hidden_dim;
    let od = params.output_dim;

    let w_per = id * hd + hd + hd * od + od;
    let w_base = ctrl * w_per;
    let w1_off = w_base;
    let b1_off = w_base + id * hd;
    let w2_off = b1_off + hd;
    let b2_off = w2_off + hd * od;

    let in_off = (ctrl * params.n_evals + eval) * id;

    // Output layer + argmax (fused, recomputing hidden for register efficiency)
    var best_val: f64 = f64(-1e300);
    var best_idx = 0u;

    for (var o = 0u; o < od; o = o + 1u) {
        var out_val = weights[b2_off + o];
        for (var h = 0u; h < hd; h = h + 1u) {
            var hidden = weights[b1_off + h];
            for (var i = 0u; i < id; i = i + 1u) {
                hidden = hidden + weights[w1_off + i * hd + h] * inputs[in_off + i];
            }
            hidden = sigmoid_f64(hidden);
            out_val = out_val + weights[w2_off + h * od + o] * hidden;
        }
        if (out_val > best_val) {
            best_val = out_val;
            best_idx = o;
        }
    }

    actions[idx] = best_idx;
}