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
// Q4_0 Dequantization Shader (f64 canonical)
//
// Dequantizes 4-bit quantized weights to f64 for inference.
// Each block contains 32 elements packed in 18 bytes:
//   - 2 bytes: scale factor (f16)
//   - 16 bytes: 32 x 4-bit quantized values
//
// Deep Debt Compliance:
// - Pure WGSL (no vendor extensions)
// - Workgroup size 256 (universal)
// - Coalesced memory access patterns

struct DequantParams {
    num_blocks: u32,
    _pad0: u32,
    _pad1: u32,
    _pad2: u32,
}

@group(0) @binding(0) var<storage, read> input: array<u32>;
@group(0) @binding(1) var<storage, read_write> output: array<f64>;
@group(0) @binding(2) var<uniform> params: DequantParams;

const BLOCK_SIZE: u32 = 32u;
const WORKGROUP_SIZE: u32 = 256u;

@compute @workgroup_size(256)
fn main(@builtin(global_invocation_id) global_id: vec3<u32>) {
    let block_idx = global_id.x;

    if (block_idx >= params.num_blocks) {
        return;
    }

    let byte_offset = block_idx * 18u;
    let u32_offset = byte_offset / 4u;

    let raw0 = input[u32_offset];
    let raw1 = input[u32_offset + 1u];
    let raw2 = input[u32_offset + 2u];
    let raw3 = input[u32_offset + 3u];
    let raw4 = input[u32_offset + 4u];

    let byte_mod = byte_offset % 4u;
    var scale_bits: u32;
    if (byte_mod == 0u) {
        scale_bits = raw0 & 0xFFFFu;
    } else if (byte_mod == 2u) {
        scale_bits = raw0 >> 16u;
    } else {
        scale_bits = ((raw0 >> (byte_mod * 8u)) | (raw1 << (32u - byte_mod * 8u))) & 0xFFFFu;
    }

    let scale = f64(unpack2x16float(scale_bits).x);

    let out_base = block_idx * BLOCK_SIZE;

    let data_byte_offset = byte_offset + 2u;
    let data_u32_offset = data_byte_offset / 4u;
    let data_byte_mod = data_byte_offset % 4u;

    let d0 = input[data_u32_offset];
    let d1 = input[data_u32_offset + 1u];
    let d2 = input[data_u32_offset + 2u];
    let d3 = input[data_u32_offset + 3u];
    let d4 = input[data_u32_offset + 4u];

    for (var i = 0u; i < 16u; i = i + 1u) {
        let byte_idx = i;
        let word_idx = byte_idx / 4u;
        let local_byte = byte_idx % 4u;

        var byte_val: u32;
        if (word_idx == 0u) {
            byte_val = (d0 >> (local_byte * 8u + data_byte_mod * 8u)) & 0xFFu;
        } else if (word_idx == 1u) {
            byte_val = (d1 >> (local_byte * 8u)) & 0xFFu;
        } else if (word_idx == 2u) {
            byte_val = (d2 >> (local_byte * 8u)) & 0xFFu;
        } else {
            byte_val = (d3 >> (local_byte * 8u)) & 0xFFu;
        }

        let q0 = i32(byte_val & 0xFu) - 8;
        let q1 = i32((byte_val >> 4u) & 0xFu) - 8;

        let idx0 = out_base + i * 2u;
        let idx1 = out_base + i * 2u + 1u;

        output[idx0] = scale * f64(q0);
        output[idx1] = scale * f64(q1);
    }
}