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
// rk4_parallel.wgsl — Parallel Multi-System RK4 Integration (f64 canonical)
//
// Integrates N independent ODE systems simultaneously on GPU.
// Each thread handles one complete system, stepping from t=0 to t=T
// with fixed step size dt using classical RK4.
//
// The derivative function is encoded in the coeffs buffer as a
// coefficient matrix for Hill-function-based regulatory network ODEs.
//
// GPU dispatch: ceil(n_systems / 64) workgroups, 64 threads each.
//
// Provenance: neuralSpring metalForge (Feb 21, 2026) → ToadStool absorption
// Reference: Mhatre et al. (2020) PNAS, Srivastava et al. (2011) J Bact

@group(0) @binding(0) var<storage, read_write> state: array<f64>;
@group(0) @binding(1) var<storage, read> coeffs: array<f64>;
@group(0) @binding(2) var<storage, read_write> state_out: array<f64>;

struct OdeParams {
    n_systems: u32,
    dim: u32,
    n_steps: u32,
    dt: f64,
    n_coeffs: u32,
}
@group(0) @binding(3) var<uniform> params: OdeParams;

@group(0) @binding(4) var<storage, read_write> scratch: array<f64>;

fn hill(x: f64, k: f64, n: f64) -> f64 {
    let xn = pow_f64(x, n);
    return xn / (pow_f64(k, n) + xn);
}

fn read_state(sys: u32, d: u32) -> f64 {
    return state[sys * params.dim + d];
}

fn write_scratch(sys: u32, stage: u32, d: u32, val: f64) {
    scratch[sys * params.dim * 5u + stage * params.dim + d] = val;
}

fn read_scratch(sys: u32, stage: u32, d: u32) -> f64 {
    return scratch[sys * params.dim * 5u + stage * params.dim + d];
}

@compute @workgroup_size(64)
fn rk4_step(@builtin(global_invocation_id) gid: vec3<u32>) {
    let sys = gid.x;
    if sys >= params.n_systems {
        return;
    }

    let dim = params.dim;
    let dt = params.dt;

    for (var step: u32 = 0u; step < params.n_steps; step = step + 1u) {
        // k1 = f(y)
        for (var d: u32 = 0u; d < dim; d = d + 1u) {
            let y = read_state(sys, d);
            let c_base = sys * params.n_coeffs + d * 3u;
            let prod = coeffs[c_base];
            let deg = coeffs[c_base + 1u];
            let activator_idx = u32(coeffs[c_base + 2u]);
            let activator = read_state(sys, activator_idx);
            let deriv = prod * hill(activator, 0.5, 2.0) - deg * y;
            write_scratch(sys, 0u, d, deriv);
        }

        // k2 = f(y + dt/2 * k1)
        for (var d: u32 = 0u; d < dim; d = d + 1u) {
            let y_tmp = read_state(sys, d) + 0.5 * dt * read_scratch(sys, 0u, d);
            write_scratch(sys, 4u, d, y_tmp);
        }
        for (var d: u32 = 0u; d < dim; d = d + 1u) {
            let c_base = sys * params.n_coeffs + d * 3u;
            let prod = coeffs[c_base];
            let deg = coeffs[c_base + 1u];
            let activator_idx = u32(coeffs[c_base + 2u]);
            let activator = read_scratch(sys, 4u, activator_idx);
            let y_tmp = read_scratch(sys, 4u, d);
            let deriv = prod * hill(activator, 0.5, 2.0) - deg * y_tmp;
            write_scratch(sys, 1u, d, deriv);
        }

        // k3 = f(y + dt/2 * k2)
        for (var d: u32 = 0u; d < dim; d = d + 1u) {
            let y_tmp = read_state(sys, d) + 0.5 * dt * read_scratch(sys, 1u, d);
            write_scratch(sys, 4u, d, y_tmp);
        }
        for (var d: u32 = 0u; d < dim; d = d + 1u) {
            let c_base = sys * params.n_coeffs + d * 3u;
            let prod = coeffs[c_base];
            let deg = coeffs[c_base + 1u];
            let activator_idx = u32(coeffs[c_base + 2u]);
            let activator = read_scratch(sys, 4u, activator_idx);
            let y_tmp = read_scratch(sys, 4u, d);
            let deriv = prod * hill(activator, 0.5, 2.0) - deg * y_tmp;
            write_scratch(sys, 2u, d, deriv);
        }

        // k4 = f(y + dt * k3)
        for (var d: u32 = 0u; d < dim; d = d + 1u) {
            let y_tmp = read_state(sys, d) + dt * read_scratch(sys, 2u, d);
            write_scratch(sys, 4u, d, y_tmp);
        }
        for (var d: u32 = 0u; d < dim; d = d + 1u) {
            let c_base = sys * params.n_coeffs + d * 3u;
            let prod = coeffs[c_base];
            let deg = coeffs[c_base + 1u];
            let activator_idx = u32(coeffs[c_base + 2u]);
            let activator = read_scratch(sys, 4u, activator_idx);
            let y_tmp = read_scratch(sys, 4u, d);
            let deriv = prod * hill(activator, 0.5, 2.0) - deg * y_tmp;
            write_scratch(sys, 3u, d, deriv);
        }

        // y_new = y + (dt/6)(k1 + 2*k2 + 2*k3 + k4)
        for (var d: u32 = 0u; d < dim; d = d + 1u) {
            let k1 = read_scratch(sys, 0u, d);
            let k2 = read_scratch(sys, 1u, d);
            let k3 = read_scratch(sys, 2u, d);
            let k4 = read_scratch(sys, 3u, d);
            let y = read_state(sys, d);
            state[sys * dim + d] = y + (dt / 6.0) * (k1 + 2.0 * k2 + 2.0 * k3 + k4);
        }
    }

    for (var d: u32 = 0u; d < dim; d = d + 1u) {
        state_out[sys * dim + d] = state[sys * dim + d];
    }
}