@simulatte/doppler 0.1.9 → 0.2.0

package/src/gpu/kernels/dequant_mxfp4_expert.wgsl

@@ -1,129 +0,0 @@
-// MXFP4 Dequantization Kernel (expert slice)
-//
-// Expert-aware version: dequantizes a single expert's slice from packed tensor.
-
-// Tunable workgroup size
-override WORKGROUP_SIZE_EXPERT: u32 = 256u;
-
-// Extract 4-bit nibble from packed bytes and decode as E2M1 FP4
-// MXFP4 E2M1 format: 1 sign bit, 2 exponent bits (bias=1), 1 mantissa bit
-// Layout: S | E1 | E0 | M
-fn get_nibble(byte_data: u32, nibble_idx: u32) -> f32 {
-    // Each U32 contains 4 bytes, each byte contains 2 nibbles
-    let byte_idx = nibble_idx / 2u;
-    let is_high = nibble_idx % 2u;
-    let byte_val = (byte_data >> (byte_idx * 8u)) & 0xFFu;
-
-    var nibble: u32;
-    if (is_high == 1u) {
-        nibble = (byte_val >> 4u) & 0xFu;
-    } else {
-        nibble = byte_val & 0xFu;
-    }
-
-    // Decode E2M1 FP4:
-    // nibble = SEEM (4 bits)
-    // S = sign bit (bit 3)
-    // E = exponent (bits 2-1), bias = 1
-    // M = mantissa (bit 0)
-    let sign_bit = (nibble >> 3u) & 1u;
-    let exp = (nibble >> 1u) & 3u;  // 2-bit exponent
-    let mantissa = nibble & 1u;     // 1-bit mantissa
-
-    var value: f32;
-    if (exp == 0u) {
-        // Subnormal: value = (-1)^S * 0.5 * M
-        value = f32(mantissa) * 0.5;
-    } else {
-        // Normal: value = (-1)^S * (1 + 0.5*M) * 2^(E-1)
-        let m = 1.0 + f32(mantissa) * 0.5;
-        value = m * pow(2.0, f32(exp) - 1.0);
-    }
-
-    // Apply sign
-    if (sign_bit == 1u) {
-        value = -value;
-    }
-    return value;
-}
-
-// Get scale value from packed scales array (E8M0 format)
-fn get_scale(scale_data: u32, idx: u32) -> f32 {
-    let byte_idx = idx % 4u;
-    let scale_byte = (scale_data >> (byte_idx * 8u)) & 0xFFu;
-    // E8M0 format: 8-bit exponent, no mantissa
-    // scale = 2^(exponent - 127) where 127 is the IEEE bias
-    // Special cases: 0 = zero, 255 = NaN (we treat as 0)
-    if (scale_byte == 0u || scale_byte == 255u) {
-        return 0.0;
-    }
-    let exponent = i32(scale_byte) - 127;
-    return pow(2.0, f32(exponent));
-}
-
-// Expert-aware version: dequantizes a single expert's slice from packed tensor
-// Input tensors have shape [num_experts, out_dim, num_groups, 16]
-// This kernel extracts and dequantizes a single expert's weights
-struct ExpertUniforms {
-    expert_idx: u32,        // Which expert to extract
-    num_experts: u32,       // Total experts (32 for GPT-OSS)
-    out_dim: u32,           // Output dimension
-    num_groups: u32,        // Groups per row (90 for GPT-OSS)
-    total_output: u32,      // Total output elements for this expert
-    _pad0: u32,
-    _pad1: u32,
-    _pad2: u32,
-}
-
-@group(0) @binding(0) var<uniform> eu: ExpertUniforms;
-@group(0) @binding(1) var<storage, read> expert_blocks: array<u32>;
-@group(0) @binding(2) var<storage, read> expert_scales: array<u32>;
-@group(0) @binding(3) var<storage, read_write> expert_output: array<f32>;
-
-@compute @workgroup_size(WORKGROUP_SIZE_EXPERT, 1, 1)
-fn main_expert(
-    @builtin(global_invocation_id) global_id: vec3<u32>
-) {
-    let out_elem = global_id.x;
-
-    if (out_elem >= eu.total_output) {
-        return;
-    }
-
-    // Output layout: [out_dim, group_size * num_groups]
-    // For out_dim=5760, num_groups=90, group_size=32: output is [5760, 2880]
-    let row_idx = out_elem / (eu.num_groups * 32u);
-    let col_idx = out_elem % (eu.num_groups * 32u);
-    let group_in_row = col_idx / 32u;
-    let elem_in_group = col_idx % 32u;
-
-    // Input blocks layout: [num_experts, out_dim, num_groups, 16] as U8
-    // = [num_experts, out_dim, num_groups, 4] as U32
-    let expert_offset = eu.expert_idx;
-    let blocks_per_expert = eu.out_dim * eu.num_groups * 4u;
-    let blocks_per_row = eu.num_groups * 4u;
-
-    let block_word_idx = expert_offset * blocks_per_expert
-                       + row_idx * blocks_per_row
-                       + group_in_row * 4u
-                       + (elem_in_group / 8u);
-
-    let block_word = expert_blocks[block_word_idx];
-    let nibble_in_word = elem_in_group % 8u;
-    let nibble_val = get_nibble(block_word, nibble_in_word);
-
-    // Input scales layout: [num_experts, out_dim, num_groups] as contiguous U8 bytes
-    // Calculate byte offset, then convert to U32 word index
-    let scales_bytes_per_expert = eu.out_dim * eu.num_groups;
-    let scales_bytes_per_row = eu.num_groups;
-
-    let scale_byte_offset = expert_offset * scales_bytes_per_expert
-                          + row_idx * scales_bytes_per_row
-                          + group_in_row;
-    let scale_word_idx = scale_byte_offset / 4u;
-    let scale_byte_in_word = scale_byte_offset % 4u;
-    let scale_word = expert_scales[scale_word_idx];
-    let scale = get_scale(scale_word, scale_byte_in_word);
-
-    expert_output[out_elem] = f32(nibble_val) * scale;
-}

package/src/gpu/kernels/dequant_mxfp4_expert_f16.wgsl

@@ -1,105 +0,0 @@
-// AUTO-GENERATED from src/gpu/kernels/dequant_mxfp4_expert.wgsl.
-// Edit the source kernel and tools/configs/wgsl-variants.js, then run `npm run kernels:generate`.
-// MXFP4 Dequantization Kernel (expert slice, f16 output)
-
-enable f16;
-
-override WORKGROUP_SIZE_EXPERT: u32 = 256u;
-
-fn get_nibble(byte_data: u32, nibble_idx: u32) -> f32 {
-    let byte_idx = nibble_idx / 2u;
-    let is_high = nibble_idx % 2u;
-    let byte_val = (byte_data >> (byte_idx * 8u)) & 0xFFu;
-
-    var nibble: u32;
-    if (is_high == 1u) {
-        nibble = (byte_val >> 4u) & 0xFu;
-    } else {
-        nibble = byte_val & 0xFu;
-    }
-
-    let sign_bit = (nibble >> 3u) & 1u;
-    let exp = (nibble >> 1u) & 3u;
-    let mantissa = nibble & 1u;
-
-    var value: f32;
-    if (exp == 0u) {
-        value = f32(mantissa) * 0.5;
-    } else {
-        let m = 1.0 + f32(mantissa) * 0.5;
-        value = m * pow(2.0, f32(exp) - 1.0);
-    }
-
-    if (sign_bit == 1u) {
-        value = -value;
-    }
-    return value;
-}
-
-fn get_scale(scale_data: u32, idx: u32) -> f32 {
-    let byte_idx = idx % 4u;
-    let scale_byte = (scale_data >> (byte_idx * 8u)) & 0xFFu;
-    if (scale_byte == 0u || scale_byte == 255u) {
-        return 0.0;
-    }
-    let exponent = i32(scale_byte) - 127;
-    return pow(2.0, f32(exponent));
-}
-
-struct ExpertUniforms {
-    expert_idx: u32,
-    num_experts: u32,
-    out_dim: u32,
-    num_groups: u32,
-    total_output: u32,
-    _pad0: u32,
-    _pad1: u32,
-    _pad2: u32,
-}
-
-@group(0) @binding(0) var<uniform> eu: ExpertUniforms;
-@group(0) @binding(1) var<storage, read> expert_blocks: array<u32>;
-@group(0) @binding(2) var<storage, read> expert_scales: array<u32>;
-@group(0) @binding(3) var<storage, read_write> expert_output: array<f16>;
-
-@compute @workgroup_size(WORKGROUP_SIZE_EXPERT, 1, 1)
-fn main_expert(
-    @builtin(global_invocation_id) global_id: vec3<u32>
-) {
-    let out_elem = global_id.x;
-
-    if (out_elem >= eu.total_output) {
-        return;
-    }
-
-    let row_idx = out_elem / (eu.num_groups * 32u);
-    let col_idx = out_elem % (eu.num_groups * 32u);
-    let group_in_row = col_idx / 32u;
-    let elem_in_group = col_idx % 32u;
-
-    let expert_offset = eu.expert_idx;
-    let blocks_per_expert = eu.out_dim * eu.num_groups * 4u;
-    let blocks_per_row = eu.num_groups * 4u;
-
-    let block_word_idx = expert_offset * blocks_per_expert
-                       + row_idx * blocks_per_row
-                       + group_in_row * 4u
-                       + (elem_in_group / 8u);
-
-    let block_word = expert_blocks[block_word_idx];
-    let nibble_in_word = elem_in_group % 8u;
-    let nibble_val = get_nibble(block_word, nibble_in_word);
-
-    let scales_bytes_per_expert = eu.out_dim * eu.num_groups;
-    let scales_bytes_per_row = eu.num_groups;
-
-    let scale_byte_offset = expert_offset * scales_bytes_per_expert
-                          + row_idx * scales_bytes_per_row
-                          + group_in_row;
-    let scale_word_idx = scale_byte_offset / 4u;
-    let scale_byte_in_word = scale_byte_offset % 4u;
-    let scale_word = expert_scales[scale_word_idx];
-    let scale = get_scale(scale_word, scale_byte_in_word);
-
-    expert_output[out_elem] = f16(nibble_val * scale);
-}

package/src/gpu/kernels/dequant_mxfp4_vec4.wgsl

@@ -1,116 +0,0 @@
-// MXFP4 Dequantization Kernel (vec4)
-//
-// Vectorized variant for MXFP4 dequantization.
-
-// Tunable workgroup size
-override WORKGROUP_SIZE_VEC4: u32 = 64u;
-
-struct Uniforms {
-    total_elements: u32,    // Total output elements
-    num_groups: u32,        // Groups per row (e.g., 90)
-    group_size: u32,        // Elements per group (32 = 16 bytes * 2 nibbles)
-    row_stride: u32,        // Stride between rows in output
-}
-
-@group(0) @binding(0) var<uniform> u: Uniforms;
-@group(0) @binding(1) var<storage, read> blocks: array<u32>;  // Packed U8 as U32
-@group(0) @binding(2) var<storage, read> scales: array<u32>;  // Packed U8 as U32
-@group(0) @binding(3) var<storage, read_write> output: array<f32>;
-
-// Extract 4-bit nibble from packed bytes and decode as E2M1 FP4
-// MXFP4 E2M1 format: 1 sign bit, 2 exponent bits (bias=1), 1 mantissa bit
-// Layout: S | E1 | E0 | M
-fn get_nibble(byte_data: u32, nibble_idx: u32) -> f32 {
-    // Each U32 contains 4 bytes, each byte contains 2 nibbles
-    let byte_idx = nibble_idx / 2u;
-    let is_high = nibble_idx % 2u;
-    let byte_val = (byte_data >> (byte_idx * 8u)) & 0xFFu;
-
-    var nibble: u32;
-    if (is_high == 1u) {
-        nibble = (byte_val >> 4u) & 0xFu;
-    } else {
-        nibble = byte_val & 0xFu;
-    }
-
-    // Decode E2M1 FP4:
-    // nibble = SEEM (4 bits)
-    // S = sign bit (bit 3)
-    // E = exponent (bits 2-1), bias = 1
-    // M = mantissa (bit 0)
-    let sign_bit = (nibble >> 3u) & 1u;
-    let exp = (nibble >> 1u) & 3u;  // 2-bit exponent
-    let mantissa = nibble & 1u;     // 1-bit mantissa
-
-    var value: f32;
-    if (exp == 0u) {
-        // Subnormal: value = (-1)^S * 0.5 * M
-        value = f32(mantissa) * 0.5;
-    } else {
-        // Normal: value = (-1)^S * (1 + 0.5*M) * 2^(E-1)
-        let m = 1.0 + f32(mantissa) * 0.5;
-        value = m * pow(2.0, f32(exp) - 1.0);
-    }
-
-    // Apply sign
-    if (sign_bit == 1u) {
-        value = -value;
-    }
-    return value;
-}
-
-// Get scale value from packed scales array (E8M0 format)
-fn get_scale(scale_data: u32, idx: u32) -> f32 {
-    let byte_idx = idx % 4u;
-    let scale_byte = (scale_data >> (byte_idx * 8u)) & 0xFFu;
-    // E8M0 format: 8-bit exponent, no mantissa
-    // scale = 2^(exponent - 127) where 127 is the IEEE bias
-    // Special cases: 0 = zero, 255 = NaN (we treat as 0)
-    if (scale_byte == 0u || scale_byte == 255u) {
-        return 0.0;
-    }
-    let exponent = i32(scale_byte) - 127;
-    return pow(2.0, f32(exponent));
-}
-
-// Vectorized version - each thread handles 4 elements
-@compute @workgroup_size(WORKGROUP_SIZE_VEC4, 1, 1)
-fn main_vec4(
-    @builtin(global_invocation_id) global_id: vec3<u32>
-) {
-    let base_elem = global_id.x * 4u;
-
-    if (base_elem >= u.total_elements) {
-        return;
-    }
-
-    // Compute group for base element
-    let group_idx = base_elem / u.group_size;
-    let intra_group_base = base_elem % u.group_size;
-
-    // Get scale for this group (all 4 elements should be in same group typically)
-    let scale_word_idx = group_idx / 4u;
-    let scale_byte_idx = group_idx % 4u;
-    let scale_word = scales[scale_word_idx];
-    let scale = get_scale(scale_word, scale_byte_idx);
-
-    // Get block data
-    let block_base = group_idx * 4u;
-
-    // Process 4 consecutive nibbles
-    for (var i = 0u; i < 4u; i = i + 1u) {
-        let elem_idx = base_elem + i;
-        if (elem_idx >= u.total_elements) {
-            break;
-        }
-
-        let intra_group_idx = intra_group_base + i;
-        let word_in_block = intra_group_idx / 8u;
-        let nibble_in_word = intra_group_idx % 8u;
-
-        let block_word = blocks[block_base + word_in_block];
-        let nibble_val = get_nibble(block_word, nibble_in_word);
-
-        output[elem_idx] = f32(nibble_val) * scale;
-    }
-}

package/src/gpu/kernels/dequant_q6k.wgsl

@@ -1,140 +0,0 @@
-// Q6_K Dequantization Kernel - f16 Output
-//
-// Dequantizes Q6_K blocks (6-bit quantization from llama.cpp/GGUF).
-//
-// Q6_K block layout (210 bytes per 256 elements):
-//   - ql: 128 bytes at offset 0 (low 4 bits of quants)
-//   - qh: 64 bytes at offset 128 (high 2 bits of quants)
-//   - scales: 16 bytes at offset 192 (8-bit signed block scales)
-//   - d: 2 bytes at offset 208 (f16 super-block scale)
-//
-// Algorithm from ggml-quants.c dequantize_row_q6_K
-
-enable f16;
-
-// Q6_K constants
-const QK_K: u32 = 256u;
-const Q6K_BLOCK_BYTES: u32 = 210u;
-
-// Byte offsets in Q6_K block
-const QL_OFFSET: u32 = 0u;      // 128 bytes
-const QH_OFFSET: u32 = 128u;    // 64 bytes
-const SCALES_OFFSET: u32 = 192u; // 16 bytes
-const D_OFFSET: u32 = 208u;     // 2 bytes
-
-// Tunable workgroup size
-override WORKGROUP_SIZE: u32 = 256u;
-
-struct Uniforms {
-    num_blocks: u32,
-    output_offset: u32,
-    workgroups_x: u32,  // For 2D dispatch: blocks per row
-    _pad1: u32,
-}
-
-@group(0) @binding(0) var<uniform> u: Uniforms;
-@group(0) @binding(1) var<storage, read> quantized: array<u32>;
-@group(0) @binding(2) var<storage, read_write> output: array<f16>;
-
-var<workgroup> shared_d: f32;
-var<workgroup> shared_scales: array<f32, 16>;
-
-// Read a byte from the quantized buffer at a given block and byte offset
-fn read_byte(block_idx: u32, byte_offset: u32) -> u32 {
-    let global_byte = block_idx * Q6K_BLOCK_BYTES + byte_offset;
-    let word_idx = global_byte / 4u;
-    let byte_in_word = global_byte % 4u;
-    return (quantized[word_idx] >> (byte_in_word * 8u)) & 0xFFu;
-}
-
-// Read a u16 (little-endian) from the quantized buffer
-fn read_u16(block_idx: u32, byte_offset: u32) -> u32 {
-    let lo = read_byte(block_idx, byte_offset);
-    let hi = read_byte(block_idx, byte_offset + 1u);
-    return lo | (hi << 8u);
-}
-
-// Read signed i8 as f32
-fn read_i8_as_f32(block_idx: u32, byte_offset: u32) -> f32 {
-    let byte_val = read_byte(block_idx, byte_offset);
-    // Convert u8 to i8 via two's complement
-    if (byte_val >= 128u) {
-        return f32(i32(byte_val) - 256);
-    }
-    return f32(byte_val);
-}
-
-// Unpack f16 from u32 (low 16 bits)
-fn unpack_f16(packed: u32) -> f32 {
-    return unpack2x16float(packed).x;
-}
-
-@compute @workgroup_size(WORKGROUP_SIZE, 1, 1)
-fn main(
-    @builtin(local_invocation_id) local_id: vec3<u32>,
-    @builtin(workgroup_id) workgroup_id: vec3<u32>
-) {
-    // Handle 2D dispatch for large block counts (> 65535)
-    let block_idx = workgroup_id.x + workgroup_id.y * u.workgroups_x;
-    let elem_idx = local_id.x;
-
-    if (block_idx >= u.num_blocks) {
-        return;
-    }
-
-    // Thread 0 loads d (f16 at offset 208)
-    if (elem_idx == 0u) {
-        let d_packed = read_u16(block_idx, D_OFFSET);
-        shared_d = unpack_f16(d_packed);
-    }
-
-    // Threads 0-15 load scales (16 x i8 at offset 192)
-    // Scales are signed i8 values used directly (no division)
-    if (elem_idx < 16u) {
-        shared_scales[elem_idx] = read_i8_as_f32(block_idx, SCALES_OFFSET + elem_idx);
-    }
-
-    workgroupBarrier();
-
-    let d = shared_d;
-
-    // Decompose element index into position within the block
-    // Q6_K processes 256 elements in two 128-element halves
-    // Each half has 4 quadrants of 32 elements
-    let half = elem_idx / 128u;           // 0 or 1
-    let within_half = elem_idx % 128u;    // 0..127
-    let quadrant = within_half / 32u;     // 0, 1, 2, or 3
-    let l = within_half % 32u;            // 0..31
-
-    // ql index: l + 32*(quadrant&1) + 64*half
-    // quadrant 0,2 use ql[l], quadrant 1,3 use ql[l+32]
-    let ql_idx = l + 32u * (quadrant & 1u) + 64u * half;
-    let ql_byte = read_byte(block_idx, QL_OFFSET + ql_idx);
-
-    // ql shift: 0 for quadrant 0,1 (lower nibble); 4 for quadrant 2,3 (upper nibble)
-    let ql_shift = 4u * (quadrant >> 1u);
-    let ql_val = (ql_byte >> ql_shift) & 0xFu;
-
-    // qh index: l + 32*half
-    let qh_idx = l + 32u * half;
-    let qh_byte = read_byte(block_idx, QH_OFFSET + qh_idx);
-
-    // qh shift: 0 for q0, 2 for q1, 4 for q2, 6 for q3
-    let qh_shift = quadrant * 2u;
-    let qh_val = (qh_byte >> qh_shift) & 0x3u;
-
-    // Combine to get 6-bit quantized value, then subtract 32
-    let q6 = ql_val | (qh_val << 4u);
-    let q = i32(q6) - 32;
-
-    // Scale index from ggml.c: is + 2*quadrant + 8*half, where is = l/16
-    let is_val = l / 16u;  // 0 or 1
-    let scale_idx = is_val + 2u * quadrant + 8u * half;
-    let scale = shared_scales[scale_idx];
-
-    // Dequantize: output = d * scale * q
-    let dequant = d * scale * f32(q);
-
-    let out_idx = u.output_offset + block_idx * QK_K + elem_idx;
-    output[out_idx] = f16(dequant);
-}

package/src/gpu/kernels/dequant_q8_0.wgsl

@@ -1,98 +0,0 @@
-// Q8_0 Dequantization Kernel - f16 Output
-//
-// Dequantizes Q8_0 blocks (8-bit quantization from llama.cpp/GGUF).
-//
-// Q8_0 block layout (34 bytes per 32 elements):
-//   - d: 2 bytes at offset 0 (f16 scale)
-//   - qs: 32 bytes at offset 2 (int8 quantized values)
-//
-// Algorithm from ggml-quants.c dequantize_row_q8_0
-
-enable f16;
-
-// Q8_0 constants
-const QK8_0: u32 = 32u;
-const Q8_0_BLOCK_BYTES: u32 = 34u;
-
-// Byte offsets in Q8_0 block
-const D_OFFSET: u32 = 0u;   // 2 bytes (f16 scale)
-const QS_OFFSET: u32 = 2u;  // 32 bytes (int8 values)
-
-// Tunable workgroup size
-override WORKGROUP_SIZE: u32 = 32u;
-
-struct Uniforms {
-    num_blocks: u32,
-    output_offset: u32,
-    workgroups_x: u32,  // For 2D dispatch: blocks per row
-    _pad1: u32,
-}
-
-@group(0) @binding(0) var<uniform> u: Uniforms;
-@group(0) @binding(1) var<storage, read> quantized: array<u32>;
-@group(0) @binding(2) var<storage, read_write> output: array<f16>;
-
-var<workgroup> shared_d: f32;
-
-// Read a byte from the quantized buffer at a given block and byte offset
-fn read_byte(block_idx: u32, byte_offset: u32) -> u32 {
-    let global_byte = block_idx * Q8_0_BLOCK_BYTES + byte_offset;
-    let word_idx = global_byte / 4u;
-    let byte_in_word = global_byte % 4u;
-    return (quantized[word_idx] >> (byte_in_word * 8u)) & 0xFFu;
-}
-
-// Read a u16 (little-endian) from the quantized buffer
-fn read_u16(block_idx: u32, byte_offset: u32) -> u32 {
-    let lo = read_byte(block_idx, byte_offset);
-    let hi = read_byte(block_idx, byte_offset + 1u);
-    return lo | (hi << 8u);
-}
-
-// Read signed i8 as f32
-fn read_i8_as_f32(block_idx: u32, byte_offset: u32) -> f32 {
-    let byte_val = read_byte(block_idx, byte_offset);
-    // Convert u8 to i8 via two's complement
-    if (byte_val >= 128u) {
-        return f32(i32(byte_val) - 256);
-    }
-    return f32(byte_val);
-}
-
-// Unpack f16 from u32 (low 16 bits)
-fn unpack_f16(packed: u32) -> f32 {
-    return unpack2x16float(packed).x;
-}
-
-@compute @workgroup_size(WORKGROUP_SIZE, 1, 1)
-fn main(
-    @builtin(local_invocation_id) local_id: vec3<u32>,
-    @builtin(workgroup_id) workgroup_id: vec3<u32>
-) {
-    // Handle 2D dispatch for large block counts (> 65535)
-    let block_idx = workgroup_id.x + workgroup_id.y * u.workgroups_x;
-    let elem_idx = local_id.x;
-
-    if (block_idx >= u.num_blocks) {
-        return;
-    }
-
-    // Thread 0 loads d (f16 at offset 0)
-    if (elem_idx == 0u) {
-        let d_packed = read_u16(block_idx, D_OFFSET);
-        shared_d = unpack_f16(d_packed);
-    }
-
-    workgroupBarrier();
-
-    let d = shared_d;
-
-    // Read quantized value as signed int8
-    let q = read_i8_as_f32(block_idx, QS_OFFSET + elem_idx);
-
-    // Dequantize: output = d * q
-    let dequant = d * q;
-
-    let out_idx = u.output_offset + block_idx * QK8_0 + elem_idx;
-    output[out_idx] = f16(dequant);
-}