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
// GroupNorm: Group normalization (modern alternative to BatchNorm) (f64 canonical)
// CUDA equivalent: Custom kernels or PyTorch's GroupNorm
// Formula: output = (input - group_mean) / sqrt(group_var + epsilon) * gamma + beta
// Use cases: Small batch training, style transfer, generative models

@group(0) @binding(0) var<storage, read> input: array<f64>;
@group(0) @binding(1) var<storage, read> gamma: array<f64>;  // Scale parameter (per channel)
@group(0) @binding(2) var<storage, read> beta: array<f64>;   // Shift parameter (per channel)
@group(0) @binding(3) var<storage, read_write> output: array<f64>;
@group(0) @binding(4) var<storage, read_write> stats: array<f64>;  // Group statistics (mean, var)

struct Params {
    batch_size: u32,
    channels: u32,
    spatial_size: u32,  // H * W
    num_groups: u32,
    channels_per_group: u32,
    epsilon: f64,
}
@group(0) @binding(5) var<uniform> params: Params;

// Shared memory for workgroup reductions
var<workgroup> shared_sum: array<f64, 256>;
var<workgroup> shared_sum_sq: array<f64, 256>;

// Pass 1: Compute group statistics (mean and variance)
@compute @workgroup_size(256)
fn compute_stats(@builtin(global_invocation_id) global_id: vec3<u32>,
                 @builtin(local_invocation_id) local_id: vec3<u32>,
                 @builtin(workgroup_id) workgroup_id: vec3<u32>) {
    let gid = global_id.x;
    let local_idx = local_id.x;
    let batch_idx = workgroup_id.z / params.num_groups;
    let group_idx = workgroup_id.z % params.num_groups;
    
    let group_size = params.channels_per_group * params.spatial_size;
    let group_start = batch_idx * params.channels * params.spatial_size + 
                      group_idx * params.channels_per_group * params.spatial_size;
    
    // Each thread accumulates a portion of the group
    var local_sum = 0.0;
    var local_sum_sq = 0.0;
    var count = 0u;
    
    for (var i = gid; i < group_size; i += 256u) {
        let idx = group_start + i;
        if (idx < arrayLength(&input)) {
            let val = input[idx];
            local_sum += val;
            local_sum_sq += val * val;
            count += 1u;
        }
    }
    
    shared_sum[local_idx] = local_sum;
    shared_sum_sq[local_idx] = local_sum_sq;
    workgroupBarrier();
    
    // Tree reduction within workgroup
    for (var stride = 128u; stride > 0u; stride = stride / 2u) {
        if (local_idx < stride) {
            shared_sum[local_idx] += shared_sum[local_idx + stride];
            shared_sum_sq[local_idx] += shared_sum_sq[local_idx + stride];
        }
        workgroupBarrier();
    }
    
    // First thread computes mean and variance for this group
    if (local_idx == 0u) {
        let total = shared_sum[0];
        let total_sq = shared_sum_sq[0];
        let n = f64(group_size);
        
        let mean = total / n;
        let variance = (total_sq / n) - (mean * mean);
        
        // Store statistics: [mean, variance] for each group
        let stats_idx = workgroup_id.z * 2u;
        stats[stats_idx] = mean;
        stats[stats_idx + 1u] = variance;
    }
}

// Pass 2: Normalize using group statistics
@compute @workgroup_size(256)
fn normalize(@builtin(global_invocation_id) global_id: vec3<u32>) {
    let gid = global_id.x;
    
    if (gid >= params.batch_size * params.channels * params.spatial_size) {
        return;
    }
    
    // Determine which batch, channel, and position
    let spatial_idx = gid % params.spatial_size;
    let channel_idx = (gid / params.spatial_size) % params.channels;
    let batch_idx = gid / (params.channels * params.spatial_size);
    
    // Determine which group this channel belongs to
    let group_idx = channel_idx / params.channels_per_group;
    
    // Get group statistics
    let stats_base = (batch_idx * params.num_groups + group_idx) * 2u;
    let mean = stats[stats_base];
    let variance = stats[stats_base + 1u];
    
    // Normalize: (x - mean) / sqrt(variance + epsilon)
    let normalized = (input[gid] - mean) / sqrt_f64(variance + params.epsilon);
    
    // Apply affine transformation: gamma * normalized + beta
    output[gid] = gamma[channel_idx] * normalized + beta[channel_idx];
}