@simulatte/doppler 0.1.8 → 0.2.0

package/src/gpu/kernels/fused_matmul_q4_multicol_f16.wgsl

@@ -1,216 +0,0 @@
-// Fused Q4_K Matmul Kernel - W4A16 (F16 output, multicol)
-//
-// Computes C_f16 = A * dequant(B_q4k) for large vocab GEMV.
-// Uses multi-column workgroups to reduce launch overhead.
-
-enable f16;
-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;
-const MAX_WORKGROUP_SIZE: u32 = 256u;
-
-struct Uniforms {
-    M: u32,                   // Always 1 for GEMV
-    N: u32,                   // Output dimension
-    K: u32,                   // Inner dimension (may be non-256-aligned)
-    alpha: f32,
-    num_blocks_per_row: u32,  // ceil(K / 256)
-    _pad0: u32,               // 16-byte alignment padding
-    _pad1: u32,
-    _pad2: u32,
-}
-
-// Q4_K block structure (144 bytes)
-// Layout: d(2) + dmin(2) + scales(12) + qs(128)
-struct Q4KBlock {
-    d_dmin: u32,          // d (f16) and dmin (f16) packed
-    scales: array<u32, 3>, // 12 bytes of packed 6-bit scales
-    qs: array<u32, 32>,   // 128 bytes of 4-bit quantized values
-}
-
-@group(0) @binding(0) var<uniform> u: Uniforms;
-@group(0) @binding(1) var<storage, read> A: array<f32>;
-@group(0) @binding(2) var<storage, read> B_q4k: array<Q4KBlock>;
-@group(0) @binding(4) var<storage, read_write> C_f16: array<f16>;
-
-// Extract f16 from packed u32
-fn unpack_f16_lo(packed: u32) -> f32 {
-    return unpack2x16float(packed).x;
-}
-
-fn unpack_f16_hi(packed: u32) -> f32 {
-    return unpack2x16float(packed).y;
-}
-
-// Get byte from scales array
-fn get_scale_byte(scales: array<u32, 3>, byte_idx: u32) -> u32 {
-    let word_idx = byte_idx / 4u;
-    let byte_in_word = byte_idx % 4u;
-    return (scales[word_idx] >> (byte_in_word * 8u)) & 0xFFu;
-}
-
-// llama.cpp Q4_K scale/min extraction
-fn get_scale_min_k4(scales: array<u32, 3>, j: u32) -> vec2<u32> {
-    var sc: u32;
-    var mn: u32;
-
-    if (j < 4u) {
-        sc = get_scale_byte(scales, j) & 63u;
-        mn = get_scale_byte(scales, j + 4u) & 63u;
-    } else {
-        let q_j = get_scale_byte(scales, j + 4u);
-        let q_lo = get_scale_byte(scales, j - 4u);
-        let q_hi = get_scale_byte(scales, j);
-        sc = (q_j & 0xFu) | ((q_lo >> 6u) << 4u);
-        mn = (q_j >> 4u) | ((q_hi >> 6u) << 4u);
-    }
-    return vec2<u32>(sc, mn);
-}
-
-// Extract 4-bit quantized value from qs array
-fn get_q4(qs: array<u32, 32>, idx: u32) -> u32 {
-    let chunk = idx / 64u;
-    let pos_in_chunk = idx % 64u;
-    let use_upper = pos_in_chunk >= 32u;
-    let byte_in_range = select(pos_in_chunk, pos_in_chunk - 32u, use_upper);
-    let byte_idx = chunk * 32u + byte_in_range;
-
-    let word_idx = byte_idx / 4u;
-    let byte_in_word = byte_idx % 4u;
-    let byte_val = (qs[word_idx] >> (byte_in_word * 8u)) & 0xFFu;
-
-    if (use_upper) {
-        return (byte_val >> 4u) & 0xFu;
-    } else {
-        return byte_val & 0xFu;
-    }
-}
-
-// Multi-column GEMV for large vocab (LM head)
-// Workgroup layout: 256 threads = 8 threads per column × 32 columns
-override COLS_PER_WG: u32 = 32u;
-override THREADS_PER_COL_GEMV: u32 = 8u;  // 256 / 32 = 8
-
-// Shared memory for reduction (one slot per thread)
-var<workgroup> multicol_sums: array<f32, MAX_WORKGROUP_SIZE>;
-
-@compute @workgroup_size(WORKGROUP_SIZE, 1, 1)
-fn main_multicol_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 local_id = lid.x;
-    let col_in_wg = local_id / THREADS_PER_COL_GEMV;
-    let tid_in_col = local_id % THREADS_PER_COL_GEMV;
-    let col = wg_id.x * COLS_PER_WG + col_in_wg;
-    let is_valid = col < u.N;
-
-    var partial_sum: f32 = 0.0;
-
-    if (is_valid) {
-        let num_blocks = u.num_blocks_per_row;
-        let tail_size = u.K & 255u;
-        let full_blocks = num_blocks - select(0u, 1u, tail_size > 0u);
-
-        for (var b: u32 = tid_in_col; b < full_blocks; b = b + THREADS_PER_COL_GEMV) {
-            let block = B_q4k[col * num_blocks + b];
-            let d = unpack_f16_lo(block.d_dmin);
-            let dmin = unpack_f16_hi(block.d_dmin);
-            let k_base = b * QK_K;
-
-            for (var sb: u32 = 0u; sb < 8u; sb = sb + 1u) {
-                let sm = get_scale_min_k4(block.scales, sb);
-                let scale = d * f32(sm.x);
-                let min_val = dmin * f32(sm.y);
-                let sb_base = sb * SUBBLOCK_SIZE;
-
-                for (var i: u32 = 0u; i < SUBBLOCK_SIZE; i = i + 4u) {
-                    let k0 = k_base + sb_base + i;
-                    let a0 = A[k0];
-                    let a1 = A[k0 + 1u];
-                    let a2 = A[k0 + 2u];
-                    let a3 = A[k0 + 3u];
-
-                    let q0 = get_q4(block.qs, sb_base + i);
-                    let q1 = get_q4(block.qs, sb_base + i + 1u);
-                    let q2 = get_q4(block.qs, sb_base + i + 2u);
-                    let q3 = get_q4(block.qs, sb_base + i + 3u);
-
-                    let w0 = scale * f32(q0) - min_val;
-                    let w1 = scale * f32(q1) - min_val;
-                    let w2 = scale * f32(q2) - min_val;
-                    let w3 = scale * f32(q3) - min_val;
-
-                    partial_sum = partial_sum + a0 * w0 + a1 * w1 + a2 * w2 + a3 * w3;
-                }
-            }
-        }
-
-        if (tail_size > 0u) {
-            let tail_block = full_blocks;
-            if (tail_block % THREADS_PER_COL_GEMV == tid_in_col) {
-                let block = B_q4k[col * num_blocks + tail_block];
-                let d = unpack_f16_lo(block.d_dmin);
-                let dmin = unpack_f16_hi(block.d_dmin);
-                let k_base = tail_block * QK_K;
-
-                for (var sb: u32 = 0u; sb < 8u; sb = sb + 1u) {
-                    let sb_base = sb * SUBBLOCK_SIZE;
-                    if (sb_base >= tail_size) {
-                        break;
-                    }
-                    let sm = get_scale_min_k4(block.scales, sb);
-                    let scale = d * f32(sm.x);
-                    let min_val = dmin * f32(sm.y);
-
-                    for (var i: u32 = 0u; i < SUBBLOCK_SIZE; i = i + 4u) {
-                        let k0 = k_base + sb_base + i;
-                        let k1 = k0 + 1u;
-                        let k2 = k0 + 2u;
-                        let k3 = k0 + 3u;
-
-                        var a0: f32 = 0.0;
-                        var a1: f32 = 0.0;
-                        var a2: f32 = 0.0;
-                        var a3: f32 = 0.0;
-                        if (k0 < u.K) { a0 = A[k0]; }
-                        if (k1 < u.K) { a1 = A[k1]; }
-                        if (k2 < u.K) { a2 = A[k2]; }
-                        if (k3 < u.K) { a3 = A[k3]; }
-
-                        let q0 = get_q4(block.qs, sb_base + i);
-                        let q1 = get_q4(block.qs, sb_base + i + 1u);
-                        let q2 = get_q4(block.qs, sb_base + i + 2u);
-                        let q3 = get_q4(block.qs, sb_base + i + 3u);
-
-                        let w0 = scale * f32(q0) - min_val;
-                        let w1 = scale * f32(q1) - min_val;
-                        let w2 = scale * f32(q2) - min_val;
-                        let w3 = scale * f32(q3) - min_val;
-
-                        partial_sum = partial_sum + a0 * w0 + a1 * w1 + a2 * w2 + a3 * w3;
-                    }
-                }
-            }
-        }
-    }
-
-    multicol_sums[local_id] = partial_sum;
-    workgroupBarrier();
-
-    if (tid_in_col == 0u && is_valid) {
-        var final_sum: f32 = 0.0;
-        let base = col_in_wg * THREADS_PER_COL_GEMV;
-        for (var i: u32 = 0u; i < THREADS_PER_COL_GEMV; i = i + 1u) {
-            final_sum = final_sum + multicol_sums[base + i];
-        }
-        C_f16[col] = f16(final_sum * u.alpha);
-    }
-}

package/src/gpu/kernels/fused_matmul_q4_multicol_f16a.wgsl

@@ -1,204 +0,0 @@
-// Fused Q4_K Matmul Kernel - W4A16 (F16 activations, F16 output, multicol)
-//
-// Computes C_f16 = A * dequant(B_q4k) for large vocab GEMV with f16 activations.
-
-enable f16;
-enable subgroups;
-
-const QK_K: u32 = 256u;
-const BLOCK_SIZE: u32 = 144u;
-const SUBBLOCK_SIZE: u32 = 32u;
-
-override WORKGROUP_SIZE: u32 = 256u;
-const MAX_WORKGROUP_SIZE: u32 = 256u;
-
-struct Uniforms {
-    M: u32,
-    N: u32,
-    K: u32,
-    alpha: f32,
-    num_blocks_per_row: u32,
-    _pad0: u32,
-    _pad1: u32,
-    _pad2: u32,
-}
-
-struct Q4KBlock {
-    d_dmin: u32,
-    scales: array<u32, 3>,
-    qs: array<u32, 32>,
-}
-
-@group(0) @binding(0) var<uniform> u: Uniforms;
-@group(0) @binding(1) var<storage, read> A: array<f16>;
-@group(0) @binding(2) var<storage, read> B_q4k: array<Q4KBlock>;
-@group(0) @binding(4) var<storage, read_write> C_f16: array<f16>;
-
-fn unpack_f16_lo(packed: u32) -> f32 {
-    return unpack2x16float(packed).x;
-}
-
-fn unpack_f16_hi(packed: u32) -> f32 {
-    return unpack2x16float(packed).y;
-}
-
-fn get_scale_byte(scales: array<u32, 3>, byte_idx: u32) -> u32 {
-    let word_idx = byte_idx / 4u;
-    let byte_in_word = byte_idx % 4u;
-    return (scales[word_idx] >> (byte_in_word * 8u)) & 0xFFu;
-}
-
-fn get_scale_min_k4(scales: array<u32, 3>, j: u32) -> vec2<u32> {
-    var sc: u32;
-    var mn: u32;
-
-    if (j < 4u) {
-        sc = get_scale_byte(scales, j) & 63u;
-        mn = get_scale_byte(scales, j + 4u) & 63u;
-    } else {
-        let q_j = get_scale_byte(scales, j + 4u);
-        let q_lo = get_scale_byte(scales, j - 4u);
-        let q_hi = get_scale_byte(scales, j);
-        sc = (q_j & 0xFu) | ((q_lo >> 6u) << 4u);
-        mn = (q_j >> 4u) | ((q_hi >> 6u) << 4u);
-    }
-    return vec2<u32>(sc, mn);
-}
-
-fn get_q4(qs: array<u32, 32>, idx: u32) -> u32 {
-    let chunk = idx / 64u;
-    let pos_in_chunk = idx % 64u;
-    let use_upper = pos_in_chunk >= 32u;
-    let byte_in_range = select(pos_in_chunk, pos_in_chunk - 32u, use_upper);
-    let byte_idx = chunk * 32u + byte_in_range;
-
-    let word_idx = byte_idx / 4u;
-    let byte_in_word = byte_idx % 4u;
-    let byte_val = (qs[word_idx] >> (byte_in_word * 8u)) & 0xFFu;
-
-    if (use_upper) {
-        return (byte_val >> 4u) & 0xFu;
-    } else {
-        return byte_val & 0xFu;
-    }
-}
-
-override COLS_PER_WG: u32 = 32u;
-override THREADS_PER_COL_GEMV: u32 = 8u;
-
-var<workgroup> multicol_sums: array<f32, MAX_WORKGROUP_SIZE>;
-
-@compute @workgroup_size(WORKGROUP_SIZE, 1, 1)
-fn main_multicol_f16a(
-    @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 local_id = lid.x;
-    let col_in_wg = local_id / THREADS_PER_COL_GEMV;
-    let tid_in_col = local_id % THREADS_PER_COL_GEMV;
-    let col = wg_id.x * COLS_PER_WG + col_in_wg;
-    let is_valid = col < u.N;
-
-    var partial_sum: f32 = 0.0;
-
-    if (is_valid) {
-        let num_blocks = u.num_blocks_per_row;
-        let tail_size = u.K & 255u;
-        let full_blocks = num_blocks - select(0u, 1u, tail_size > 0u);
-        for (var b: u32 = tid_in_col; b < full_blocks; b = b + THREADS_PER_COL_GEMV) {
-            let block = B_q4k[col * num_blocks + b];
-            let d = unpack_f16_lo(block.d_dmin);
-            let dmin = unpack_f16_hi(block.d_dmin);
-            let k_base = b * QK_K;
-
-            for (var sb: u32 = 0u; sb < 8u; sb = sb + 1u) {
-                let sm = get_scale_min_k4(block.scales, sb);
-                let scale = d * f32(sm.x);
-                let min_val = dmin * f32(sm.y);
-                let sb_base = sb * SUBBLOCK_SIZE;
-
-                for (var i: u32 = 0u; i < SUBBLOCK_SIZE; i = i + 4u) {
-                    let k0 = k_base + sb_base + i;
-                    let a0 = f32(A[k0]);
-                    let a1 = f32(A[k0 + 1u]);
-                    let a2 = f32(A[k0 + 2u]);
-                    let a3 = f32(A[k0 + 3u]);
-
-                    let q0 = get_q4(block.qs, sb_base + i);
-                    let q1 = get_q4(block.qs, sb_base + i + 1u);
-                    let q2 = get_q4(block.qs, sb_base + i + 2u);
-                    let q3 = get_q4(block.qs, sb_base + i + 3u);
-
-                    let w0 = scale * f32(q0) - min_val;
-                    let w1 = scale * f32(q1) - min_val;
-                    let w2 = scale * f32(q2) - min_val;
-                    let w3 = scale * f32(q3) - min_val;
-
-                    partial_sum = partial_sum + a0 * w0 + a1 * w1 + a2 * w2 + a3 * w3;
-                }
-            }
-        }
-
-        if (tail_size > 0u) {
-            let tail_block = full_blocks;
-            if (tail_block % THREADS_PER_COL_GEMV == tid_in_col) {
-                let block = B_q4k[col * num_blocks + tail_block];
-                let d = unpack_f16_lo(block.d_dmin);
-                let dmin = unpack_f16_hi(block.d_dmin);
-                let k_base = tail_block * QK_K;
-
-                for (var sb: u32 = 0u; sb < 8u; sb = sb + 1u) {
-                    let sb_base = sb * SUBBLOCK_SIZE;
-                    if (sb_base >= tail_size) {
-                        break;
-                    }
-                    let sm = get_scale_min_k4(block.scales, sb);
-                    let scale = d * f32(sm.x);
-                    let min_val = dmin * f32(sm.y);
-
-                    for (var i: u32 = 0u; i < SUBBLOCK_SIZE; i = i + 4u) {
-                        let k0 = k_base + sb_base + i;
-                        let k1 = k0 + 1u;
-                        let k2 = k0 + 2u;
-                        let k3 = k0 + 3u;
-
-                        var a0: f32 = 0.0;
-                        var a1: f32 = 0.0;
-                        var a2: f32 = 0.0;
-                        var a3: f32 = 0.0;
-                        if (k0 < u.K) { a0 = f32(A[k0]); }
-                        if (k1 < u.K) { a1 = f32(A[k1]); }
-                        if (k2 < u.K) { a2 = f32(A[k2]); }
-                        if (k3 < u.K) { a3 = f32(A[k3]); }
-
-                        let q0 = get_q4(block.qs, sb_base + i);
-                        let q1 = get_q4(block.qs, sb_base + i + 1u);
-                        let q2 = get_q4(block.qs, sb_base + i + 2u);
-                        let q3 = get_q4(block.qs, sb_base + i + 3u);
-
-                        let w0 = scale * f32(q0) - min_val;
-                        let w1 = scale * f32(q1) - min_val;
-                        let w2 = scale * f32(q2) - min_val;
-                        let w3 = scale * f32(q3) - min_val;
-
-                        partial_sum = partial_sum + a0 * w0 + a1 * w1 + a2 * w2 + a3 * w3;
-                    }
-                }
-            }
-        }
-    }
-
-    multicol_sums[local_id] = partial_sum;
-    workgroupBarrier();
-
-    if (tid_in_col == 0u && is_valid) {
-        var final_sum: f32 = 0.0;
-        let base = col_in_wg * THREADS_PER_COL_GEMV;
-        for (var i: u32 = 0u; i < THREADS_PER_COL_GEMV; i = i + 1u) {
-            final_sum = final_sum + multicol_sums[base + i];
-        }
-        C_f16[col] = f16(final_sum * u.alpha);
-    }
-}

package/src/gpu/kernels/fused_matmul_residual.d.ts

@@ -1,46 +0,0 @@
-/**
- * Fused GEMV + Residual Kernel
- *
- * For decode (M=1), combines output projection matmul with residual add in a single kernel.
- */
-
-import type { Tensor, TensorDtype } from '../tensor.js';
-import type { WeightBuffer } from '../weight-buffer.js';
-import type { CommandRecorder } from '../command-recorder.js';
-import type { OutputBufferOptions } from './types.js';
-
-/** Fused MatmulResidual kernel options */
-export interface MatmulResidualFusedOptions extends OutputBufferOptions {
-  /** Output dimension N (hiddenSize) */
-  N: number;
-  /** Input dimension K (numHeads * headDim) */
-  K: number;
-  /** Scaling factor (default: 1.0) */
-  alpha?: number;
-}
-
-/**
- * Check if fused GEMV+residual should be used.
- */
-export declare function shouldUseFusedMatmulResidual(M: number): boolean;
-
-/**
- * Run fused GEMV + Residual
- */
-export declare function runMatmulResidualFused(
-  input: Tensor,
-  weight: GPUBuffer | WeightBuffer,
-  residual: Tensor,
-  options: MatmulResidualFusedOptions
-): Promise<Tensor>;
-
-/**
- * Record fused GEMV + Residual (batched, no submit)
- */
-export declare function recordMatmulResidualFused(
-  recorder: CommandRecorder,
-  input: Tensor,
-  weight: GPUBuffer | WeightBuffer,
-  residual: Tensor,
-  options: MatmulResidualFusedOptions
-): Promise<Tensor>;

package/src/gpu/kernels/fused_matmul_residual.js

@@ -1,175 +0,0 @@
-
-
-import { getDevice } from '../device.js';
-import { acquireBuffer, releaseBuffer } from '../../memory/buffer-pool.js';
-import { createTensor, dtypeBytes } from '../tensor.js';
-import { getBuffer } from '../weight-buffer.js';
-import { dispatch, recordDispatch } from './dispatch.js';
-import { getPipelineFast, createUniformBufferWithView } from './utils.js';
-import { trace } from '../../debug/index.js';
-import { selectRuleValue } from './rule-registry.js';
-
-
-export function shouldUseFusedMatmulResidual(M) {
-  return M === 1;
-}
-
-function resolveFusedResidualVariant(input, residual) {
-  if (input.dtype !== residual.dtype) {
-    throw new Error(
-      `[MatmulResidualFused] dtype mismatch: input=${input.dtype} residual=${residual.dtype}`
-    );
-  }
-  return selectRuleValue('fusedMatmulResidual', 'variant', { dtype: input.dtype });
-}
-
-
-export async function runMatmulResidualFused(
-  input,
-  weight,
-  residual,
-  options
-) {
-  const device = getDevice();
-  const {
-    N,
-    K,
-    alpha = 1.0,
-    outputBuffer = null,
-  } = options;
-
-  const weightBuffer = getBuffer(weight);
-  
-  const outputDtype = input.dtype;
-
-  trace.kernels(`MatmulResidualFused: N=${N}, K=${K}, alpha=${alpha}, dtype=${outputDtype}`);
-
-  const pipelineVariant = resolveFusedResidualVariant(input, residual);
-  const pipeline = await getPipelineFast('fused_matmul_residual', pipelineVariant);
-
-  const ownedOutput = outputBuffer ? null : acquireBuffer(
-    N * dtypeBytes(outputDtype),
-    undefined,
-    'matmul_residual_output'
-  );
-  const output = outputBuffer || ownedOutput;
-
-  // Create uniform buffer (same layout as matmul_gemv)
-  const uniformBuffer = createUniformBufferWithView(
-    'matmul_residual_uniforms',
-    32,  // 8 u32s
-    (view) => {
-      view.setUint32(0, 1, true);         // M = 1 (decode)
-      view.setUint32(4, N, true);         // N (output dimension)
-      view.setUint32(8, K, true);         // K (input dimension)
-      view.setFloat32(12, alpha, true);   // alpha
-      view.setUint32(16, 1, true);        // transpose_b = 1
-      view.setUint32(20, 0, true);        // _pad0
-      view.setUint32(24, 0, true);        // _pad1
-      view.setUint32(28, 0, true);        // _pad2
-    },
-    null,
-    device
-  );
-
-  // Create bind group
-  try {
-    const bindGroup = device.createBindGroup({
-      label: 'matmul_residual_bind_group',
-      layout: pipeline.getBindGroupLayout(0),
-      entries: [
-        { binding: 0, resource: { buffer: uniformBuffer } },
-        { binding: 1, resource: { buffer: input.buffer } },
-        { binding: 2, resource: { buffer: weightBuffer } },
-        { binding: 3, resource: { buffer: output } },
-        { binding: 4, resource: { buffer: residual.buffer } },
-      ],
-    });
-
-    const workgroups = N;
-    dispatch(device, pipeline, bindGroup, workgroups, 'matmul_residual_fused');
-  } catch (error) {
-    uniformBuffer.destroy();
-    if (ownedOutput) {
-      releaseBuffer(ownedOutput);
-    }
-    throw error;
-  }
-
-  uniformBuffer.destroy();
-
-  return createTensor(output, outputDtype, [1, N], 'matmul_residual_output');
-}
-
-
-export async function recordMatmulResidualFused(
-  recorder,
-  input,
-  weight,
-  residual,
-  options
-) {
-  const device = recorder.device;
-  const {
-    N,
-    K,
-    alpha = 1.0,
-    outputBuffer = null,
-  } = options;
-
-  const weightBuffer = getBuffer(weight);
-  
-  const outputDtype = input.dtype;
-
-  const pipelineVariant = resolveFusedResidualVariant(input, residual);
-  const pipeline = await getPipelineFast('fused_matmul_residual', pipelineVariant);
-
-  const ownedOutput = outputBuffer ? null : acquireBuffer(
-    N * dtypeBytes(outputDtype),
-    undefined,
-    'matmul_residual_output'
-  );
-  const output = outputBuffer || ownedOutput;
-
-  // Create uniform buffer
-  const uniformBuffer = createUniformBufferWithView(
-    'matmul_residual_uniforms',
-    32,
-    (view) => {
-      view.setUint32(0, 1, true);         // M = 1
-      view.setUint32(4, N, true);         // N
-      view.setUint32(8, K, true);         // K
-      view.setFloat32(12, alpha, true);   // alpha
-      view.setUint32(16, 1, true);        // transpose_b = 1
-      view.setUint32(20, 0, true);        // _pad0
-      view.setUint32(24, 0, true);        // _pad1
-      view.setUint32(28, 0, true);        // _pad2
-    },
-    recorder
-  );
-
-  // Create bind group
-  try {
-    const bindGroup = device.createBindGroup({
-      label: 'matmul_residual_bind_group',
-      layout: pipeline.getBindGroupLayout(0),
-      entries: [
-        { binding: 0, resource: { buffer: uniformBuffer } },
-        { binding: 1, resource: { buffer: input.buffer } },
-        { binding: 2, resource: { buffer: weightBuffer } },
-        { binding: 3, resource: { buffer: output } },
-        { binding: 4, resource: { buffer: residual.buffer } },
-      ],
-    });
-
-    const workgroups = N;
-    recordDispatch(recorder, pipeline, bindGroup, workgroups, 'matmul_residual_fused');
-  } catch (error) {
-    if (ownedOutput) {
-      releaseBuffer(ownedOutput);
-    }
-    throw error;
-  }
-
-  return createTensor(output, outputDtype, [1, N], 'matmul_residual_output');
-}

package/src/gpu/kernels/fused_matmul_rmsnorm.d.ts

@@ -1,64 +0,0 @@
-/**
- * Fused GEMV + RMSNorm Kernel
- *
- * For decode (M=1), combines the down projection matmul with RMSNorm in a single kernel.
- */
-
-import type { Tensor } from '../tensor.js';
-import type { WeightBuffer } from '../weight-buffer.js';
-import type { CommandRecorder } from '../command-recorder.js';
-import type { OutputBufferOptions } from './types.js';
-
-/** Fused MatmulRMSNorm kernel options */
-export interface MatmulRMSNormFusedOptions extends OutputBufferOptions {
-  /** Output dimension N (hiddenSize) */
-  N: number;
-  /** Input dimension K (intermediateSize) */
-  K: number;
-  /** RMSNorm epsilon (default: 1e-5) */
-  eps?: number;
-  /** Optional residual buffer to add to output */
-  residual?: GPUBuffer | null;
-  /** Whether RMSNorm uses (1 + weight) scaling */
-  rmsNormWeightOffset?: boolean;
-  /** Optional label for profiling (appended to kernel label) */
-  label?: string | null;
-  /**
-   * Whether weight matrix is stored transposed.
-   * - true: weight is [N,K] (row-major/SafeTensors), needs transpose access
-   * - false: weight is [K,N] (column-major/pre-transposed), direct access
-   * Default: true (matches GGUF convention)
-   */
-  transposeB?: boolean;
-}
-
-/**
- * Select fused kernel variant based on output size
- */
-export declare function selectMatmulRMSNormFusedVariant(N: number): string;
-
-/**
- * Run fused GEMV + RMSNorm
- */
-export declare function runMatmulRMSNormFused(
-  input: Tensor,
-  weight: GPUBuffer | WeightBuffer,
-  normWeight: GPUBuffer,
-  options: MatmulRMSNormFusedOptions
-): Promise<Tensor>;
-
-/**
- * Record fused GEMV + RMSNorm (batched, no submit)
- */
-export declare function recordMatmulRMSNormFused(
-  recorder: CommandRecorder,
-  input: Tensor,
-  weight: GPUBuffer | WeightBuffer,
-  normWeight: GPUBuffer,
-  options: MatmulRMSNormFusedOptions
-): Promise<Tensor>;
-
-/**
- * Check if fused kernel should be used for given dimensions
- */
-export declare function shouldUseFusedMatmulRMSNorm(M: number, N: number, K?: number): boolean;