@simulatte/doppler 0.1.8 → 0.2.0

package/src/gpu/kernels/fused_ffn.wgsl

@@ -1,420 +0,0 @@
-// Fused FFN Kernel (Tier 2 P0)
-//
-// Fuses gate + up weight projections into a single kernel to reduce
-// memory bandwidth and kernel launch overhead.
-//
-// Standard FFN (SwiGLU/GeGLU):
-//   gate = x @ W_gate
-//   up = x @ W_up
-//   hidden = activation(gate) * up
-//   out = hidden @ W_down
-//
-// This kernel fuses steps 1-3 into a single kernel:
-//   1. Load x from global memory (1x)
-//   2. Compute gate and up projections simultaneously
-//   3. Apply activation and multiply
-//   4. Store result
-//
-// Memory savings: 2x reduction in x reads, eliminates intermediate buffers
-//
-// For Q4_K weights, this kernel:
-// - Dequantizes gate and up weights on-the-fly
-// - Uses subgroup operations for reduction
-// - Achieves 2-3x speedup over separate kernel approach
-
-enable subgroups;
-
-// Q4_K constants
-const QK_K: u32 = 256u;           // Elements per super-block
-const BLOCK_SIZE: u32 = 144u;     // Bytes per Q4_K block
-const SUBBLOCK_SIZE: u32 = 32u;   // Elements per sub-block
-
-override WORKGROUP_SIZE: u32 = 256u;
-override SHARED_INPUT_SIZE: u32 = 256u;
-const MAX_SUBGROUPS: u32 = 256u;  // Supports subgroup_size >= 1
-const MAX_SUBGROUPS_PER_OUTPUT: u32 = 64u;  // THREADS_PER_OUTPUT max
-
-struct Uniforms {
-    M: u32,                // Batch size (usually 1 for decode)
-    hidden_size: u32,      // Input dimension
-    intermediate_size: u32, // Output dimension (per gate/up)
-    alpha: f32,            // Scale factor
-    activation: u32,       // 0=silu, 1=gelu
-    clamp_max: f32,        // SwiGLU clamp (0 = disabled)
-    _pad0: u32,            // 16-byte alignment padding
-    _pad1: u32,
-}
-
-@group(0) @binding(0) var<uniform> u: Uniforms;
-@group(0) @binding(1) var<storage, read> input: array<f32>;
-@group(0) @binding(2) var<storage, read> W_gate: array<f32>;  // [intermediate_size, hidden_size]
-@group(0) @binding(3) var<storage, read> W_up: array<f32>;    // [intermediate_size, hidden_size]
-@group(0) @binding(4) var<storage, read_write> output: array<f32>;
-
-// Shared memory for input vector (reused for gate and up)
-var<workgroup> shared_input: array<f32, SHARED_INPUT_SIZE>;
-
-// For subgroup reduction
-var<workgroup> sg_sums: array<f32, MAX_SUBGROUPS * 2u>;
-
-// SiLU activation: x * sigmoid(x)
-fn silu(x: f32) -> f32 {
-    return x / (1.0 + exp(-x));
-}
-
-// GELU activation (approximate)
-fn gelu(x: f32) -> f32 {
-    let c = 0.7978845608; // sqrt(2/pi)
-    return 0.5 * x * (1.0 + tanh(c * (x + 0.044715 * x * x * x)));
-}
-
-fn clamp_swiglu(x: f32) -> f32 {
-    if (u.clamp_max <= 0.0 || u.activation != 0u) {
-        return x;
-    }
-    return clamp(x, -u.clamp_max, u.clamp_max);
-}
-
-// Fused FFN forward for F32 weights
-// One workgroup computes one output element
-@compute @workgroup_size(WORKGROUP_SIZE, 1, 1)
-fn main(
-    @builtin(local_invocation_id) lid: vec3<u32>,
-    @builtin(workgroup_id) wg_id: vec3<u32>,
-    @builtin(subgroup_invocation_id) sg_id: u32,
-    @builtin(subgroup_size) sg_size: u32,
-) {
-    let out_idx = wg_id.x;
-    let tid = lid.x;
-    let hidden_size = u.hidden_size;
-    let intermediate_size = u.intermediate_size;
-
-    if (out_idx >= intermediate_size) {
-        return;
-    }
-
-    let subgroup_id = tid / sg_size;
-    let num_subgroups = (WORKGROUP_SIZE + sg_size - 1u) / sg_size;
-
-    var gate_sum: f32 = 0.0;
-    var up_sum: f32 = 0.0;
-
-    // Weight offsets for this output element
-    let gate_base = out_idx * hidden_size;
-    let up_base = out_idx * hidden_size;
-
-    let num_tiles = (hidden_size + SHARED_INPUT_SIZE - 1u) / SHARED_INPUT_SIZE;
-    for (var tile = 0u; tile < num_tiles; tile = tile + 1u) {
-        let tile_start = tile * SHARED_INPUT_SIZE;
-        let tile_end = min(tile_start + SHARED_INPUT_SIZE, hidden_size);
-
-        // Load input tile into shared memory
-        for (var i = tid; i < SHARED_INPUT_SIZE; i = i + WORKGROUP_SIZE) {
-            let idx = tile_start + i;
-            if (idx < hidden_size) {
-                shared_input[i] = input[idx];
-            }
-        }
-        workgroupBarrier();
-
-        // Compute partial sums for this tile
-        for (var k = tile_start + tid; k < tile_end; k = k + WORKGROUP_SIZE) {
-            let x = shared_input[k - tile_start];
-            gate_sum += x * W_gate[gate_base + k];
-            up_sum += x * W_up[up_base + k];
-        }
-
-        workgroupBarrier();
-    }
-
-    // Phase 3: Reduce across threads using subgroups
-    let sg_gate = subgroupAdd(gate_sum);
-    let sg_up = subgroupAdd(up_sum);
-
-    if (sg_id == 0u && subgroup_id < num_subgroups) {
-        sg_sums[subgroup_id] = sg_gate;
-        sg_sums[subgroup_id + MAX_SUBGROUPS] = sg_up;
-    }
-    workgroupBarrier();
-
-    // Thread 0 does final reduction
-    if (tid == 0u) {
-        var final_gate: f32 = 0.0;
-        var final_up: f32 = 0.0;
-        for (var s = 0u; s < num_subgroups; s++) {
-            final_gate += sg_sums[s];
-            final_up += sg_sums[s + MAX_SUBGROUPS];
-        }
-
-        // Apply activation and multiply
-        var activated: f32;
-        if (u.activation == 0u) {
-            activated = silu(final_gate);
-        } else {
-            activated = gelu(final_gate);
-        }
-
-        output[out_idx] = clamp_swiglu(activated * final_up * u.alpha);
-    }
-}
-
-// Optimized variant: Multiple outputs per workgroup
-// For better GPU utilization when intermediate_size is small
-const OUTPUTS_PER_WG: u32 = 4u;
-const THREADS_PER_OUTPUT: u32 = 64u;
-
-var<workgroup> multi_sg_sums: array<f32, OUTPUTS_PER_WG * MAX_SUBGROUPS_PER_OUTPUT * 2u>;
-
-@compute @workgroup_size(WORKGROUP_SIZE, 1, 1)
-fn main_multi(
-    @builtin(local_invocation_id) lid: vec3<u32>,
-    @builtin(workgroup_id) wg_id: vec3<u32>,
-    @builtin(subgroup_invocation_id) sg_id: u32,
-    @builtin(subgroup_size) sg_size: u32,
-) {
-    let tid = lid.x;
-    let out_in_wg = tid / THREADS_PER_OUTPUT;
-    let tid_in_out = tid % THREADS_PER_OUTPUT;
-    let out_idx = wg_id.x * OUTPUTS_PER_WG + out_in_wg;
-
-    let hidden_size = u.hidden_size;
-    let intermediate_size = u.intermediate_size;
-    let is_active = out_idx < intermediate_size;
-
-    var gate_sum: f32 = 0.0;
-    var up_sum: f32 = 0.0;
-
-    let gate_base = out_idx * hidden_size;
-    let up_base = out_idx * hidden_size;
-
-    let num_tiles = (hidden_size + SHARED_INPUT_SIZE - 1u) / SHARED_INPUT_SIZE;
-    for (var tile = 0u; tile < num_tiles; tile = tile + 1u) {
-        let tile_start = tile * SHARED_INPUT_SIZE;
-        let tile_end = min(tile_start + SHARED_INPUT_SIZE, hidden_size);
-
-        // Load input tile
-        if (tid < SHARED_INPUT_SIZE) {
-            let idx = tile_start + tid;
-            if (idx < hidden_size) {
-                shared_input[tid] = input[idx];
-            }
-        }
-        workgroupBarrier();
-
-        // Strided access pattern per output
-        if (is_active) {
-            for (var k = tile_start + tid_in_out; k < tile_end; k = k + THREADS_PER_OUTPUT) {
-                let x = shared_input[k - tile_start];
-                gate_sum += x * W_gate[gate_base + k];
-                up_sum += x * W_up[up_base + k];
-            }
-        }
-        workgroupBarrier();
-    }
-
-    // Reduce within each output group
-    let local_sg_id = tid_in_out / sg_size;
-    let sg_gate = subgroupAdd(gate_sum);
-    let sg_up = subgroupAdd(up_sum);
-
-    if (is_active && sg_id == 0u && local_sg_id < MAX_SUBGROUPS_PER_OUTPUT) {
-        let base = out_in_wg * MAX_SUBGROUPS_PER_OUTPUT * 2u;
-        multi_sg_sums[base + local_sg_id] = sg_gate;
-        multi_sg_sums[base + MAX_SUBGROUPS_PER_OUTPUT + local_sg_id] = sg_up;
-    }
-    workgroupBarrier();
-
-    // First thread of each output finalizes
-    if (is_active && tid_in_out == 0u) {
-        let num_sgs = min(MAX_SUBGROUPS_PER_OUTPUT, (THREADS_PER_OUTPUT + sg_size - 1u) / sg_size);
-        var final_gate: f32 = 0.0;
-        var final_up: f32 = 0.0;
-
-        let base = out_in_wg * MAX_SUBGROUPS_PER_OUTPUT * 2u;
-        for (var s = 0u; s < num_sgs; s++) {
-            final_gate += multi_sg_sums[base + s];
-            final_up += multi_sg_sums[base + MAX_SUBGROUPS_PER_OUTPUT + s];
-        }
-
-        var activated: f32;
-        if (u.activation == 0u) {
-            activated = silu(final_gate);
-        } else {
-            activated = gelu(final_gate);
-        }
-
-        output[out_idx] = clamp_swiglu(activated * final_up * u.alpha);
-    }
-}
-
-// F16 weights variant - optimized for memory bandwidth
-@compute @workgroup_size(WORKGROUP_SIZE, 1, 1)
-fn main_f16(
-    @builtin(local_invocation_id) lid: vec3<u32>,
-    @builtin(workgroup_id) wg_id: vec3<u32>,
-    @builtin(subgroup_invocation_id) sg_id: u32,
-    @builtin(subgroup_size) sg_size: u32,
-) {
-    let out_idx = wg_id.x;
-    let tid = lid.x;
-    let hidden_size = u.hidden_size;
-    let intermediate_size = u.intermediate_size;
-
-    if (out_idx >= intermediate_size) {
-        return;
-    }
-
-    let subgroup_id = tid / sg_size;
-    let num_subgroups = (WORKGROUP_SIZE + sg_size - 1u) / sg_size;
-
-    var gate_sum: f32 = 0.0;
-    var up_sum: f32 = 0.0;
-
-    // Each thread handles stride of WORKGROUP_SIZE
-    let gate_base = out_idx * hidden_size;
-    let up_base = out_idx * hidden_size;
-
-    let num_tiles = (hidden_size + SHARED_INPUT_SIZE - 1u) / SHARED_INPUT_SIZE;
-    for (var tile = 0u; tile < num_tiles; tile = tile + 1u) {
-        let tile_start = tile * SHARED_INPUT_SIZE;
-        let tile_end = min(tile_start + SHARED_INPUT_SIZE, hidden_size);
-
-        // Load input tile
-        for (var i = tid; i < SHARED_INPUT_SIZE; i = i + WORKGROUP_SIZE) {
-            let idx = tile_start + i;
-            if (idx < hidden_size) {
-                shared_input[i] = input[idx];
-            }
-        }
-        workgroupBarrier();
-
-        for (var k = tile_start + tid; k < tile_end; k = k + WORKGROUP_SIZE) {
-            let x = shared_input[k - tile_start];
-
-            // Read F16 weights (packed as u32)
-            let gate_packed = W_gate[gate_base / 2u + k / 2u];
-            let up_packed = W_up[up_base / 2u + k / 2u];
-
-            let gate_vec = unpack2x16float(bitcast<u32>(gate_packed));
-            let up_vec = unpack2x16float(bitcast<u32>(up_packed));
-
-            let g = select(gate_vec.y, gate_vec.x, (k % 2u) == 0u);
-            let u = select(up_vec.y, up_vec.x, (k % 2u) == 0u);
-
-            gate_sum += x * g;
-            up_sum += x * u;
-        }
-
-        workgroupBarrier();
-    }
-
-    // Reduce
-    let sg_gate = subgroupAdd(gate_sum);
-    let sg_up = subgroupAdd(up_sum);
-
-    if (sg_id == 0u && subgroup_id < num_subgroups) {
-        sg_sums[subgroup_id] = sg_gate;
-        sg_sums[subgroup_id + MAX_SUBGROUPS] = sg_up;
-    }
-    workgroupBarrier();
-
-    if (tid == 0u) {
-        var final_gate: f32 = 0.0;
-        var final_up: f32 = 0.0;
-        for (var s = 0u; s < num_subgroups; s++) {
-            final_gate += sg_sums[s];
-            final_up += sg_sums[s + MAX_SUBGROUPS];
-        }
-
-        var activated: f32;
-        if (u.activation == 0u) {
-            activated = silu(final_gate);
-        } else {
-            activated = gelu(final_gate);
-        }
-
-        output[out_idx] = clamp_swiglu(activated * final_up * u.alpha);
-    }
-}
-
-// Batched variant for prefill (M > 1)
-// Each workgroup handles one output element across all batch items
-@compute @workgroup_size(WORKGROUP_SIZE, 1, 1)
-fn main_batched(
-    @builtin(local_invocation_id) lid: vec3<u32>,
-    @builtin(workgroup_id) wg_id: vec3<u32>,
-    @builtin(subgroup_invocation_id) sg_id: u32,
-    @builtin(subgroup_size) sg_size: u32,
-) {
-    let out_idx = wg_id.x;
-    let batch_idx = wg_id.y;
-    let tid = lid.x;
-    let hidden_size = u.hidden_size;
-    let intermediate_size = u.intermediate_size;
-    let M = u.M;
-
-    if (out_idx >= intermediate_size || batch_idx >= M) {
-        return;
-    }
-
-    let subgroup_id = tid / sg_size;
-    let num_subgroups = (WORKGROUP_SIZE + sg_size - 1u) / sg_size;
-
-    var gate_sum: f32 = 0.0;
-    var up_sum: f32 = 0.0;
-
-    let gate_base = out_idx * hidden_size;
-    let up_base = out_idx * hidden_size;
-    let input_base = batch_idx * hidden_size;
-
-    let num_tiles = (hidden_size + SHARED_INPUT_SIZE - 1u) / SHARED_INPUT_SIZE;
-    for (var tile = 0u; tile < num_tiles; tile = tile + 1u) {
-        let tile_start = tile * SHARED_INPUT_SIZE;
-        let tile_end = min(tile_start + SHARED_INPUT_SIZE, hidden_size);
-
-        // Load input tile for this batch item
-        for (var i = tid; i < SHARED_INPUT_SIZE; i = i + WORKGROUP_SIZE) {
-            let idx = tile_start + i;
-            if (idx < hidden_size) {
-                shared_input[i] = input[input_base + idx];
-            }
-        }
-        workgroupBarrier();
-
-        for (var k = tile_start + tid; k < tile_end; k = k + WORKGROUP_SIZE) {
-            let x = shared_input[k - tile_start];
-            gate_sum += x * W_gate[gate_base + k];
-            up_sum += x * W_up[up_base + k];
-        }
-
-        workgroupBarrier();
-    }
-
-    let sg_gate = subgroupAdd(gate_sum);
-    let sg_up = subgroupAdd(up_sum);
-
-    if (sg_id == 0u && subgroup_id < num_subgroups) {
-        sg_sums[subgroup_id] = sg_gate;
-        sg_sums[subgroup_id + MAX_SUBGROUPS] = sg_up;
-    }
-    workgroupBarrier();
-
-    if (tid == 0u) {
-        var final_gate: f32 = 0.0;
-        var final_up: f32 = 0.0;
-        for (var s = 0u; s < num_subgroups; s++) {
-            final_gate += sg_sums[s];
-            final_up += sg_sums[s + MAX_SUBGROUPS];
-        }
-
-        var activated: f32;
-        if (u.activation == 0u) {
-            activated = silu(final_gate);
-        } else {
-            activated = gelu(final_gate);
-        }
-
-        let out_offset = batch_idx * intermediate_size + out_idx;
-        output[out_offset] = clamp_swiglu(activated * final_up * u.alpha);
-    }
-}

package/src/gpu/kernels/fused_ffn_f16.wgsl

@@ -1,213 +0,0 @@
-// AUTO-GENERATED from src/gpu/kernels/fused_ffn.wgsl.
-// Edit the source kernel and tools/configs/wgsl-variants.js, then run `npm run kernels:generate`.
-// Fused FFN Kernel - Native F16 I/O
-//
-// Full f16 pipeline variant: f16 input, f16 weights, f16 output.
-// f32 accumulators and shared memory for numerical stability.
-// Requires 'shader-f16' feature.
-//
-// Standard FFN (SwiGLU/GeGLU):
-//   gate = x @ W_gate
-//   up = x @ W_up
-//   hidden = activation(gate) * up
-//   out = hidden @ W_down
-//
-// This kernel fuses steps 1-3 into a single dispatch.
-// Input is widened f16→f32 on shared memory load; output is narrowed f32→f16 on write.
-
-enable f16;
-enable subgroups;
-
-override WORKGROUP_SIZE: u32 = 256u;
-override SHARED_INPUT_SIZE: u32 = 256u;
-const MAX_SUBGROUPS: u32 = 256u;
-
-struct Uniforms {
-    M: u32,
-    hidden_size: u32,
-    intermediate_size: u32,
-    alpha: f32,
-    activation: u32,
-    clamp_max: f32,
-    _pad0: u32,
-    _pad1: u32,
-}
-
-@group(0) @binding(0) var<uniform> u: Uniforms;
-@group(0) @binding(1) var<storage, read> input: array<f16>;
-@group(0) @binding(2) var<storage, read> W_gate: array<f16>;
-@group(0) @binding(3) var<storage, read> W_up: array<f16>;
-@group(0) @binding(4) var<storage, read_write> output: array<f16>;
-
-var<workgroup> shared_input: array<f32, SHARED_INPUT_SIZE>;
-var<workgroup> sg_sums: array<f32, MAX_SUBGROUPS * 2u>;
-
-fn silu(x: f32) -> f32 {
-    return x / (1.0 + exp(-x));
-}
-
-fn gelu(x: f32) -> f32 {
-    let c = 0.7978845608;
-    return 0.5 * x * (1.0 + tanh(c * (x + 0.044715 * x * x * x)));
-}
-
-fn clamp_swiglu(x: f32) -> f32 {
-    if (u.clamp_max <= 0.0 || u.activation != 0u) {
-        return x;
-    }
-    return clamp(x, -u.clamp_max, u.clamp_max);
-}
-
-// Single-output-per-workgroup variant for decode (M=1)
-@compute @workgroup_size(WORKGROUP_SIZE, 1, 1)
-fn main(
-    @builtin(local_invocation_id) lid: vec3<u32>,
-    @builtin(workgroup_id) wg_id: vec3<u32>,
-    @builtin(subgroup_invocation_id) sg_id: u32,
-    @builtin(subgroup_size) sg_size: u32,
-) {
-    let out_idx = wg_id.x;
-    let tid = lid.x;
-    let hidden_size = u.hidden_size;
-
-    if (out_idx >= u.intermediate_size) {
-        return;
-    }
-
-    let subgroup_id = tid / sg_size;
-    let num_subgroups = (WORKGROUP_SIZE + sg_size - 1u) / sg_size;
-
-    var gate_sum: f32 = 0.0;
-    var up_sum: f32 = 0.0;
-
-    let weight_base = out_idx * hidden_size;
-
-    let num_tiles = (hidden_size + SHARED_INPUT_SIZE - 1u) / SHARED_INPUT_SIZE;
-    for (var tile = 0u; tile < num_tiles; tile = tile + 1u) {
-        let tile_start = tile * SHARED_INPUT_SIZE;
-        let tile_end = min(tile_start + SHARED_INPUT_SIZE, hidden_size);
-
-        // Load f16 input, widen to f32 in shared memory for accumulation precision
-        for (var i = tid; i < SHARED_INPUT_SIZE; i = i + WORKGROUP_SIZE) {
-            let idx = tile_start + i;
-            if (idx < hidden_size) {
-                shared_input[i] = f32(input[idx]);
-            }
-        }
-        workgroupBarrier();
-
-        for (var k = tile_start + tid; k < tile_end; k = k + WORKGROUP_SIZE) {
-            let x = shared_input[k - tile_start];
-            gate_sum += x * f32(W_gate[weight_base + k]);
-            up_sum += x * f32(W_up[weight_base + k]);
-        }
-
-        workgroupBarrier();
-    }
-
-    let sg_gate = subgroupAdd(gate_sum);
-    let sg_up = subgroupAdd(up_sum);
-
-    if (sg_id == 0u && subgroup_id < num_subgroups) {
-        sg_sums[subgroup_id] = sg_gate;
-        sg_sums[subgroup_id + MAX_SUBGROUPS] = sg_up;
-    }
-    workgroupBarrier();
-
-    if (tid == 0u) {
-        var final_gate: f32 = 0.0;
-        var final_up: f32 = 0.0;
-        for (var s = 0u; s < num_subgroups; s++) {
-            final_gate += sg_sums[s];
-            final_up += sg_sums[s + MAX_SUBGROUPS];
-        }
-
-        var activated: f32;
-        if (u.activation == 0u) {
-            activated = silu(final_gate);
-        } else {
-            activated = gelu(final_gate);
-        }
-
-        output[out_idx] = f16(clamp_swiglu(activated * final_up * u.alpha));
-    }
-}
-
-// Batched variant for prefill (M > 1)
-@compute @workgroup_size(WORKGROUP_SIZE, 1, 1)
-fn main_batched(
-    @builtin(local_invocation_id) lid: vec3<u32>,
-    @builtin(workgroup_id) wg_id: vec3<u32>,
-    @builtin(subgroup_invocation_id) sg_id: u32,
-    @builtin(subgroup_size) sg_size: u32,
-) {
-    let out_idx = wg_id.x;
-    let batch_idx = wg_id.y;
-    let tid = lid.x;
-    let hidden_size = u.hidden_size;
-    let intermediate_size = u.intermediate_size;
-
-    if (out_idx >= intermediate_size || batch_idx >= u.M) {
-        return;
-    }
-
-    let subgroup_id = tid / sg_size;
-    let num_subgroups = (WORKGROUP_SIZE + sg_size - 1u) / sg_size;
-
-    var gate_sum: f32 = 0.0;
-    var up_sum: f32 = 0.0;
-
-    let weight_base = out_idx * hidden_size;
-    let input_base = batch_idx * hidden_size;
-
-    let num_tiles = (hidden_size + SHARED_INPUT_SIZE - 1u) / SHARED_INPUT_SIZE;
-    for (var tile = 0u; tile < num_tiles; tile = tile + 1u) {
-        let tile_start = tile * SHARED_INPUT_SIZE;
-        let tile_end = min(tile_start + SHARED_INPUT_SIZE, hidden_size);
-
-        // Load f16 input, widen to f32 in shared memory for accumulation precision
-        for (var i = tid; i < SHARED_INPUT_SIZE; i = i + WORKGROUP_SIZE) {
-            let idx = tile_start + i;
-            if (idx < hidden_size) {
-                shared_input[i] = f32(input[input_base + idx]);
-            }
-        }
-        workgroupBarrier();
-
-        for (var k = tile_start + tid; k < tile_end; k = k + WORKGROUP_SIZE) {
-            let x = shared_input[k - tile_start];
-            gate_sum += x * f32(W_gate[weight_base + k]);
-            up_sum += x * f32(W_up[weight_base + k]);
-        }
-
-        workgroupBarrier();
-    }
-
-    let sg_gate = subgroupAdd(gate_sum);
-    let sg_up = subgroupAdd(up_sum);
-
-    if (sg_id == 0u && subgroup_id < num_subgroups) {
-        sg_sums[subgroup_id] = sg_gate;
-        sg_sums[subgroup_id + MAX_SUBGROUPS] = sg_up;
-    }
-    workgroupBarrier();
-
-    if (tid == 0u) {
-        var final_gate: f32 = 0.0;
-        var final_up: f32 = 0.0;
-        for (var s = 0u; s < num_subgroups; s++) {
-            final_gate += sg_sums[s];
-            final_up += sg_sums[s + MAX_SUBGROUPS];
-        }
-
-        var activated: f32;
-        if (u.activation == 0u) {
-            activated = silu(final_gate);
-        } else {
-            activated = gelu(final_gate);
-        }
-
-        let out_offset = batch_idx * intermediate_size + out_idx;
-        output[out_offset] = f16(clamp_swiglu(activated * final_up * u.alpha));
-    }
-}