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
// GPU-Resident Conjugate Gradient kernels - f64 Precision
// These kernels keep scalar values on GPU to eliminate per-iteration CPU sync.
// All bindings use read_write for consistency within this module.

struct CGParams {
    n: u32,
}

// ============================================================================
// CG update step 1: x = x + alpha * p, r = r - alpha * Ap
// ============================================================================
@group(0) @binding(0) var<storage, read_write> cg_x: array<f64>;
@group(0) @binding(1) var<storage, read_write> cg_r: array<f64>;
@group(0) @binding(2) var<storage, read_write> cg_p: array<f64>;
@group(0) @binding(3) var<storage, read_write> cg_Ap: array<f64>;
@group(0) @binding(4) var<storage, read_write> cg_alpha: array<f64>;
@group(0) @binding(5) var<uniform> cg_params1: CGParams;

@compute @workgroup_size(256)
fn cg_update_xr(@builtin(global_invocation_id) global_id: vec3<u32>) {
    let idx = global_id.x;
    if (idx >= cg_params1.n) {
        return;
    }

    let alpha = cg_alpha[0];
    cg_x[idx] = cg_x[idx] + alpha * cg_p[idx];
    cg_r[idx] = cg_r[idx] - alpha * cg_Ap[idx];
}

// ============================================================================
// CG update step 2: p = r + beta * p
// ============================================================================
@group(0) @binding(0) var<storage, read_write> cg_r2: array<f64>;
@group(0) @binding(1) var<storage, read_write> cg_p2: array<f64>;
@group(0) @binding(2) var<storage, read_write> cg_beta: array<f64>;
@group(0) @binding(3) var<uniform> cg_params2: CGParams;

@compute @workgroup_size(256)
fn cg_update_p(@builtin(global_invocation_id) global_id: vec3<u32>) {
    let idx = global_id.x;
    if (idx >= cg_params2.n) {
        return;
    }

    let beta = cg_beta[0];
    cg_p2[idx] = cg_r2[idx] + beta * cg_p2[idx];
}

// ============================================================================
// Compute alpha = rz / pAp from two scalar buffers
// ============================================================================
@group(0) @binding(0) var<storage, read_write> rz_in: array<f64>;
@group(0) @binding(1) var<storage, read_write> pap_in: array<f64>;
@group(0) @binding(2) var<storage, read_write> alpha_out: array<f64>;

@compute @workgroup_size(1)
fn compute_alpha(@builtin(global_invocation_id) global_id: vec3<u32>) {
    let rz = rz_in[0];
    let pap = pap_in[0];

    if (abs(pap) > f64(1e-30)) {
        alpha_out[0] = rz / pap;
    } else {
        alpha_out[0] = f64(0.0);
    }
}

// ============================================================================
// Compute beta = rz_new / rz_old, also copies rz_new to rz_old
// ============================================================================
@group(0) @binding(0) var<storage, read_write> rz_new_in: array<f64>;
@group(0) @binding(1) var<storage, read_write> rz_old_inout: array<f64>;
@group(0) @binding(2) var<storage, read_write> beta_out: array<f64>;

@compute @workgroup_size(1)
fn compute_beta(@builtin(global_invocation_id) global_id: vec3<u32>) {
    let rz_new = rz_new_in[0];
    let rz_old = rz_old_inout[0];

    if (abs(rz_old) > f64(1e-30)) {
        beta_out[0] = rz_new / rz_old;
    } else {
        beta_out[0] = f64(0.0);
    }

    // Update rz_old for next iteration
    rz_old_inout[0] = rz_new;
}