// SPDX-License-Identifier: Apache-2.0 // Copyright (c) 2026 UtopiaIA // Elffuss Runtime · GEMM del prefill con la estructura de ML Drift. // ───────────────────────────────────────────────────────────────────────────── // El GEMM teselado (kernels.gemm.wgsl.js) sube teselas f32 a memoria compartida, // pone dos barreras por paso y hace 2×4 salidas escalares por hilo. Este hace lo // contrario, que es lo que hace ML Drift (Apache-2.0) en su convolución 1×1: // · f16 en memoria y vec4·dot, acumulador en f32; // · SIN memoria compartida ni barreras; // · cada hilo calcula 16 filas × 2 tokens, y los 32 hilos del grupo en tokens // consecutivos leyendo el MISMO peso (difusión: una lectura sirve a todos). // Medido en un microbanco con pesos densos: ×4 sobre el GEMM teselado. // // Los pesos Q8_0 se DESCUANTIZAN a f16 antes, una vez por matriz y lote, en la // disposición que pide el bucle: [rows/16][K/4][16] vec4. Descuantizar dentro // del bucle repetiría la descodificación en los 32 hilos que comparten el peso, // y con solo 2 tokens de reúso por hilo eso se come la ventaja. // // Licencia: código propio, Apache-2.0 (ver SPDX arriba y LICENSE). Sin dependencias externas. import { HELPERS } from './kernels.wgsl.js'; import { bloquesWGSL } from './kernels.bloques.wgsl.js'; export const DRIFT_TPW = 32; // hilos por grupo, todos en tokens export const DRIFT_TPT = 2; // tokens por hilo export const DRIFT_FILAS = 16; // filas de salida por hilo // Pesos cuantizados [rows][K] → f16 [rows/16][K/4][16] vec4. Un hilo por vec4 // de salida: cuatro pesos CONSECUTIVOS en k de una fila. Cada tipo dice cómo // sacar esos cuatro de su bloque (todos son de 32 pesos y kk es múltiplo de 4, // así que nunca cruzan de bloque). // Q8_0R/Q4_0R son los mismos tipos REORDENADOS al cargar (`__ELFFUSS_REPACK`, // ver kernels.bloques.wgsl.js). export const DRIFT_TIPOS = new Set(['Q8_0', 'Q4_0', 'Q8_0R', 'Q4_0R']); const CUATRO = { // 34 bytes: escala f16 + 32 int8. Q8_0: { bytes: 34, wgsl: ` let d = load_scale(blk); let q = load_u32_at(blk + 2u + i0); let v = vec4(f32(get_byte_i32(q, 0u)), f32(get_byte_i32(q, 1u)), f32(get_byte_i32(q, 2u)), f32(get_byte_i32(q, 3u))) * d;` }, // 18 bytes: escala f16 + 16 bytes de nibbles; byte j = peso j (bajo) y j+16 (alto). Q4_0: { bytes: 18, wgsl: ` let d = load_scale(blk); let q = load_u32_at(blk + 2u + (i0 & 15u)); let sh = select(0u, 4u, i0 >= 16u); let v = (vec4(f32((q >> sh) & 0xFu), f32((q >> (8u + sh)) & 0xFu), f32((q >> (16u + sh)) & 0xFu), f32((q >> (24u + sh)) & 0xFu)) - 8.0) * d;` }, // Los reordenados: las MISMAS dos expresiones de arriba con las lecturas // cambiadas. `blk` sigue saliendo como si el formato fuera el del GGUF y se // divide por el tamaño del bloque para tener su índice; la escala y la palabra // de cuantos son los mismos bits, así que el f16 que se escribe también. Se // llama `bi` y no `i` porque aquí se está en el cuerpo de `main`, donde `i` // ya es el índice del hilo. Q8_0R: { bytes: 34, helpers: bloquesWGSL('Q8_0R'), wgsl: ` let bi = blk / 34u; let d = bq_escala(bi); let q = bq_palabra(bi, i0 / 4u); let v = vec4(f32(get_byte_i32(q, 0u)), f32(get_byte_i32(q, 1u)), f32(get_byte_i32(q, 2u)), f32(get_byte_i32(q, 3u))) * d;` }, Q4_0R: { bytes: 18, helpers: bloquesWGSL('Q4_0R'), wgsl: ` let bi = blk / 18u; let d = bq_escala(bi); let q = bq_palabra(bi, (i0 & 15u) / 4u); let sh = select(0u, 4u, i0 >= 16u); let v = (vec4(f32((q >> sh) & 0xFu), f32((q >> (8u + sh)) & 0xFu), f32((q >> (16u + sh)) & 0xFu), f32((q >> (24u + sh)) & 0xFu)) - 8.0) * d;` }, }; export function driftDequantShader(type, wg = 256) { const c = CUATRO[type]; if (!c) throw new Error(`drift: sin descuantización para ${type}`); return /* wgsl */` enable f16; struct P { rows : u32, k : u32, bpr : u32, total : u32 }; @group(0) @binding(0) var w : array; @group(0) @binding(1) var dst : array>; @group(0) @binding(2) var p : P; ${HELPERS}${c.helpers || ''} @compute @workgroup_size(${wg}) fn main(@builtin(global_invocation_id) gid : vec3) { let i = gid.x + gid.y * 65535u * ${wg}u; if (i >= p.total) { return; } let ks4 = p.k / 4u; let j = i % 16u; let ks = (i / 16u) % ks4; let og = i / (16u * ks4); let row = og * 16u + j; let kk = ks * 4u; let blk = (row * p.bpr + kk / 32u) * ${c.bytes}u; let i0 = kk % 32u;${c.wgsl} dst[i] = vec4(v); }`; } // Activaciones f32 [T][K] → vec4 [T][K/4]. export function f32aF16Shader(wg = 256) { return /* wgsl */` enable f16; struct P { n4 : u32, pad0 : u32, pad1 : u32, pad2 : u32 }; @group(0) @binding(0) var src : array>; @group(0) @binding(1) var dst : array>; @group(0) @binding(2) var p : P; @compute @workgroup_size(${wg}) fn main(@builtin(global_invocation_id) gid : vec3) { let i = gid.x + gid.y * 65535u * ${wg}u; if (i >= p.n4) { return; } dst[i] = vec4(src[i]); }`; } // Y[t][n] = Σ_k X[t][k]·W[n][k]. `tpw` hilos por grupo, todos en tokens; cada // hilo calcula `tpt` tokens × 16 filas. workgroup_id.y = og (bloque de 16 filas). El // último grupo de tokens puede pasarse del lote: lee la última fila válida y no // escribe. Más tokens por hilo = cada peso leído sirve a más cuentas, a cambio // de más registros vivos (16·tpt acumuladores). export function driftGemmShader(tpt = DRIFT_TPT, tpw = DRIFT_TPW) { const T = [...Array(tpt).keys()]; return /* wgsl */` enable f16; struct P { ks4 : u32, rows : u32, tokens : u32, pad : u32 }; @group(0) @binding(0) var W : array>; // [OG][KS][16] @group(0) @binding(1) var X : array>; // [T][KS] @group(0) @binding(2) var Y : array; // [T][rows] @group(0) @binding(3) var p : P; @compute @workgroup_size(${tpw}) fn main(@builtin(workgroup_id) wg : vec3, @builtin(local_invocation_id) l : vec3) { let og = wg.y + wg.z * 65535u; if (og * 16u >= p.rows) { return; } // sin barreras: salir es legal let t0 = (wg.x * ${tpw}u + l.x) * ${tpt}u; let ultimo = p.tokens - 1u; ${T.map(t => ` var a${t} : array; let x${t}i = min(t0 + ${t}u, ultimo) * p.ks4;`).join('\n')} for (var j = 0u; j < 16u; j++) { ${T.map(t => `a${t}[j] = 0.0;`).join(' ')} } var wi = og * p.ks4 * 16u; for (var ks = 0u; ks < p.ks4; ks++) { ${T.map(t => ` let x${t} = X[x${t}i + ks];`).join('\n')} for (var j = 0u; j < 16u; j++) { let w = W[wi + j]; ${T.map(t => ` a${t}[j] += f32(dot(x${t}, w));`).join('\n')} } wi += 16u; } let n0 = og * 16u; ${T.map(t => ` if (t0 + ${t}u < p.tokens) { for (var j = 0u; j < 16u; j++) { Y[(t0 + ${t}u) * p.rows + n0 + j] = a${t}[j]; } }`).join('\n')} }`; }