// SPDX-License-Identifier: Apache-2.0 // Copyright (c) 2026 UtopiaIA // Elffuss Runtime · GEMM del prompt con la descuantización DENTRO (interruptor GEMM2). // ───────────────────────────────────────────────────────────────────────────── // El camino DRIFT (kernels.drift.wgsl.js) hace tres despachos por matmul: // descuantiza la matriz ENTERA a un búfer f16, pasa las activaciones a f16 y // luego corre el GEMM sin memoria compartida. El primer despacho escribe casi el // doble de bytes de los que lee, y el GEMM vuelve a leer todo eso: por cada // pasada del prompt se mueven varias veces los pesos del modelo solo para // cambiarles el formato. Aquí ese búfer intermedio desaparece. Dos kernels: // // · EXACTO. La MISMA tesela que DRIFT (un grupo de `tpw` hilos en tokens // consecutivos, cada hilo `tpt` tokens × `filas` filas, el mismo bucle sobre // k de cuatro en cuatro y el mismo `a[j] += f32(dot(x, w))`) pero los pesos // llegan cuantizados: los hilos del grupo descuantizan juntos un trozo de // `nb` bloques por fila a memoria compartida y el bucle lee de ahí. Cada // peso sale con la MISMA expresión que el descuantizador de DRIFT (un valor // exacto en f32, porque cuanto × escala cabe en el significando) y se // redondea a f16 igual; cada salida acumula los mismos sumandos en el mismo // orden. Por eso tiene que dar los mismos bits que DRIFT. Descuantizar en el // bucle de cada hilo, sin compartir, repetiría la descodificación en los // hilos que comparten el peso: es lo que la cabecera de DRIFT descartó, y // con la memoria compartida el trabajo se reparte en vez de repetirse. // // · TESELA (sub-interruptor GEMM2_TESELA). Bloqueo en registros con memoria // compartida: una tesela de BM filas de pesos × BN tokens, paso de k de 32 // (un bloque de cuantización por fila), cada hilo TM filas × TN tokens. // Las dos teselas viven en memoria compartida en f16 con k como dimensión // lenta, así que un hilo lee de un golpe cuatro filas (o cuatro tokens) del // mismo k y cada lectura alimenta TM·TN/4 multiplicaciones. Doble búfer: la // tesela siguiente se trae a registros antes de calcular la actual y se // guarda después, con una sola barrera por paso. Acumulación en f32 // producto a producto (más precisa que el `dot` en f16 de DRIFT), así que // NO es bit a bit: se valida con tolerancia contra DRIFT y contra una // referencia en f64. La acumulación en f16 dentro de cada tesela de k es // otro sub-interruptor (GEMM2_ACC16), con su propia tolerancia. // // Formatos de pesos: Q8_0 y Q4_0 tal cual vienen del GGUF, y Q8_0R/Q4_0R, los // mismos bytes reordenados al cargar: primero los cuantos de todos los bloques, // cada bloque alineado a 16 bytes, y detrás las escalas f16, una por media // palabra. Los kernels leen SIEMPRE a través de las funciones de bloque de // `FORMATOS` (escala y cuatro pesos del bloque `ib`), así que cambiar de formato // no toca el bucle. Las cuatro variantes descuantizan al MISMO valor: el formato // reordenado tiene que dar los mismos bits que el original. // // Licencia: código propio, Apache-2.0 (ver SPDX arriba y LICENSE). Sin dependencias externas. import { HELPERS } from './kernels.wgsl.js'; import { matmulGemmShader } from './kernels.gemm.wgsl.js'; // Tipos que este GEMM sabe leer, y de qué tipo del GGUF sale cada reordenado. export const GEMM2_TIPOS = new Set(['Q8_0', 'Q4_0', 'Q8_0R', 'Q4_0R']); const ORIGEN = { Q8_0: 'Q8_0', Q4_0: 'Q4_0', Q8_0R: 'Q8_0', Q4_0R: 'Q4_0' }; export const tipoBase = (type) => ORIGEN[type] || type; // Palabras u32 de cuantos por bloque en los reordenados. La región de escalas // empieza justo detrás de la de cuantos: palabra W = ppb · R · B, con R las filas // del TENSOR (no las de una llamada que pida menos, como la cabeza con el // vocabulario) y B bloques por fila. ops.gemm2.js no la usa: saca W de la marca // del cargador (`escalasDesde` con el N del tensor). En los formatos del GGUF no // hay región aparte y el valor no se usa. export function baseEscalas(type, rows, bpr) { const ppb = type === 'Q8_0R' ? 8 : type === 'Q4_0R' ? 4 : 0; return ppb * rows * bpr; } // ── Lectura de bloques ────────────────────────────────────────────────────── // Cada formato da cuatro funciones, partidas para que la tesela pueda PRECARGAR: // traer las palabras crudas a registros antes de calcular, y descodificarlas // después, cuando la lectura ya ha llegado. Descodificar justo al cargar haría // esperar a la memoria en ese mismo sitio y la precarga no serviría de nada. // g2_ecruda(ib) palabra que contiene la escala f16 del bloque ib // g2_escala_de(c, ib) la escala en f32 (exacta: f16 cabe en f32) // g2_crudo(ib, e) palabras con los cuatro cuantos e..e+3 (e múltiplo de 4) // g2_cuatro(c, ib, e, d) los cuatro pesos en f32, ya escalados // Las expresiones del valor son CARÁCTER POR CARÁCTER las de `driftDequantShader`: // si se escribieran «mejor», los pesos podrían dejar de ser los mismos bits y una // diferencia en los logits ya no se sabría atribuir. // // En los formatos del GGUF los bloques miden 34 y 18 bytes: la mitad no empieza // en palabra y los cuantos se recomponen con dos palabras y un desplazamiento, // igual que `load_u32_at` (que lee la palabra siguiente aunque no haga falta: // por eso los búferes de pesos llevan cuatro bytes de holgura al final). La // escala nunca cruza palabra porque 34·i y 18·i son pares. const FORMATOS = { Q8_0: /* wgsl */` fn g2_ecruda(ib : u32) -> u32 { return w[(ib * 34u) / 4u]; } fn g2_escala_de(c : u32, ib : u32) -> f32 { return unpack2x16float((c >> (((ib * 34u) & 2u) * 8u)) & 0xFFFFu)[0]; } fn g2_crudo(ib : u32, e : u32) -> vec2 { let o = (ib * 34u + 2u + e) / 4u; return vec2(w[o], w[o + 1u]); } fn g2_cuatro(c : vec2, ib : u32, e : u32, d : f32) -> vec4 { let sh = ((ib * 34u + 2u + e) & 3u) * 8u; let q = select((c.x >> sh) | (c.y << ((32u - sh) & 31u)), c.x, sh == 0u); return 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; }`, // Byte j del bloque: peso j en el nibble bajo y j+16 en el alto; valor (q−8)·d. Q4_0: /* wgsl */` fn g2_ecruda(ib : u32) -> u32 { return w[(ib * 18u) / 4u]; } fn g2_escala_de(c : u32, ib : u32) -> f32 { return unpack2x16float((c >> (((ib * 18u) & 2u) * 8u)) & 0xFFFFu)[0]; } fn g2_crudo(ib : u32, e : u32) -> vec2 { let o = (ib * 18u + 2u + (e & 15u)) / 4u; return vec2(w[o], w[o + 1u]); } fn g2_cuatro(c : vec2, ib : u32, e : u32, d : f32) -> vec4 { let s8 = ((ib * 18u + 2u + (e & 15u)) & 3u) * 8u; let q = select((c.x >> s8) | (c.y << ((32u - s8) & 31u)), c.x, s8 == 0u); let sh = select(0u, 4u, e >= 16u); return (vec4(f32((q >> sh) & 0xFu), f32((q >> (8u + sh)) & 0xFu), f32((q >> (16u + sh)) & 0xFu), f32((q >> (24u + sh)) & 0xFu)) - 8.0) * d; }`, // Reordenado: cuantos del bloque ib en las palabras 8·ib … 8·ib+7, en el // orden del GGUF; escala f16 en la media palabra ib de la región que empieza // en `p.baseEsc`. Todo alineado: una palabra por cuarteto, sin recomponer. Q8_0R: /* wgsl */` fn g2_ecruda(ib : u32) -> u32 { return w[p.baseEsc + ib / 2u]; } fn g2_escala_de(c : u32, ib : u32) -> f32 { return unpack2x16float(c)[ib & 1u]; } fn g2_crudo(ib : u32, e : u32) -> vec2 { return vec2(w[ib * 8u + e / 4u], 0u); } fn g2_cuatro(c : vec2, ib : u32, e : u32, d : f32) -> vec4 { let q = c.x; return 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; }`, // Reordenado: 16 bytes de nibbles en las palabras 4·ib … 4·ib+3, MISMO // orden que Q4_0 (byte j: peso j abajo, j+16 arriba). Q4_0R: /* wgsl */` fn g2_ecruda(ib : u32) -> u32 { return w[p.baseEsc + ib / 2u]; } fn g2_escala_de(c : u32, ib : u32) -> f32 { return unpack2x16float(c)[ib & 1u]; } fn g2_crudo(ib : u32, e : u32) -> vec2 { return vec2(w[ib * 4u + (e & 15u) / 4u], 0u); } fn g2_cuatro(c : vec2, ib : u32, e : u32, d : f32) -> vec4 { let q = c.x; let sh = select(0u, 4u, e >= 16u); return (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 bloqueWgsl(type) { const f = FORMATOS[type]; if (!f) throw new Error(`gemm2: sin lectura de bloques para «${type}»`); return f; } // ── 1) EXACTO: la tesela de DRIFT con los pesos descuantizados en el grupo ── // Reparto de la descuantización de un trozo (`filas` filas × `nb` bloques): cada // par (fila, bloque) son 8 cuartetos de pesos; se reparten entre los hilos de // forma que cada uno lea UNA escala y cuartetos consecutivos de UN bloque. Con // la forma por defecto (32 hilos, 16 filas, 2 bloques) cada hilo descodifica un // bloque entero. export function repartoExacto(tpw, filas, nb) { const pares = filas * nb; let porPar = 1; // hilos por par: 1, 2, 4 u 8 while (porPar < 8 && pares * porPar * 2 <= tpw) porPar *= 2; return { pares, porPar, cuartetos: 8 / porPar, unidades: pares * porPar }; } // `doble`: dos trozos en memoria compartida y UNA barrera por trozo, o uno solo y // dos barreras. El de un trozo ocupa la mitad: DRIFT no usa memoria compartida y // sus grupos de un subgrupo caben muchos a la vez en cada núcleo; con la memoria // compartida eso puede pasar a estar limitado por ella, y en un grupo de un solo // subgrupo la barrera de más cuesta poco. Por eso el de un trozo es el defecto; // el otro queda para medirlo (ver `__ELFFUSS_GEMM2_TROZO` en ops.gemm2.js). // // `fma32` (sub-interruptor GEMM2_FMA32) cambia SOLO la aritmética del bucle: // cada producto en f32 con FMA, en orden de k, en vez del `dot` de cuatro en f16. // Deja de ser bit a bit con DRIFT (es más precisa: la misma cuenta que la // tesela) y mantiene la tesela de DRIFT, con su ocupación. Es la otra mitad del // A/B: si la tesela con memoria compartida resulta limitada por ocupación, esto // separa cuánto venía de la aritmética y cuánto del reparto. export function gemm2ExactoShader({ type = 'Q8_0', tpt = 2, tpw = 32, filas = 16, nb = 2, doble = false, fma32 = false } = {}) { if (!GEMM2_TIPOS.has(type)) throw new Error(`gemm2 exacto: tipo «${type}» no soportado`); if (filas !== 16 && filas !== 8) throw new Error(`gemm2 exacto: filas=${filas} (16 u 8)`); if (nb !== 1 && nb !== 2) throw new Error(`gemm2 exacto: nb=${nb} (1 o 2 bloques por trozo)`); if (!(tpw >= 1 && tpt >= 1)) throw new Error('gemm2 exacto: forma inválida'); const T = [...Array(tpt).keys()]; const R = repartoExacto(tpw, filas, nb); const KSL = nb * 8; // pasos de k (de cuatro en cuatro) por trozo const TROZO = KSL * filas; // vec4 por trozo return /* wgsl */` enable f16; struct P { ks4 : u32, rows : u32, tokens : u32, bpr : u32, baseEsc : u32, pad0 : u32, pad1 : u32, pad2 : u32 }; @group(0) @binding(0) var w : array; // pesos cuantizados (${type}) @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; ${HELPERS} ${bloqueWgsl(type)} ${doble ? `// Dos trozos: mientras unos hilos calculan con uno, nadie escribe en él, así que // basta UNA barrera por trozo (el siguiente se escribe en el otro).` : `// Un trozo: barrera tras descuantizarlo y otra antes de pisarlo con el siguiente.`} var Wt : array, ${(doble ? 2 : 1) * TROZO}u>; // [trozo][ksl][fila] @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 * ${filas}u >= p.rows) { return; } // uniforme en el grupo: antes de toda barrera 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 < ${filas}u; j++) { ${T.map(t => `a${t}[j] = 0.0;`).join(' ')} } let nTrozos = p.bpr / ${nb}u; for (var c = 0u; c < nTrozos; c++) { let base = ${doble ? `(c & 1u) * ${TROZO}u` : '0u'}; // Descuantización del trozo c, repartida: unidad u → (fila, bloque, parte). for (var u = l.x; u < ${R.unidades}u; u += ${tpw}u) { let par = u / ${R.porPar}u; let parte = u % ${R.porPar}u; let jf = par % ${filas}u; let bl = par / ${filas}u; let ib = (og * ${filas}u + jf) * p.bpr + c * ${nb}u + bl; let d = g2_escala_de(g2_ecruda(ib), ib); for (var m = 0u; m < ${R.cuartetos}u; m++) { let qd = parte * ${R.cuartetos}u + m; // cuarteto dentro del bloque Wt[base + (bl * 8u + qd) * ${filas}u + jf] = vec4(g2_cuatro(g2_crudo(ib, qd * 4u), ib, qd * 4u, d)); } } workgroupBarrier(); let ks0 = c * ${KSL}u; for (var ksl = 0u; ksl < ${KSL}u; ksl++) { ${fma32 ? T.map(t => ` let x${t} = vec4(X[x${t}i + ks0 + ksl]);`).join('\n') : T.map(t => ` let x${t} = X[x${t}i + ks0 + ksl];`).join('\n')} for (var j = 0u; j < ${filas}u; j++) { ${fma32 ? ` let wv = vec4(Wt[base + ksl * ${filas}u + j]); ${T.map(t => ` a${t}[j] = fma(x${t}.w, wv.w, fma(x${t}.z, wv.z, fma(x${t}.y, wv.y, fma(x${t}.x, wv.x, a${t}[j]))));`).join('\n')}` : ` let wv = Wt[base + ksl * ${filas}u + j]; ${T.map(t => ` a${t}[j] += f32(dot(x${t}, wv));`).join('\n')}`} } }${doble ? '' : ` workgroupBarrier();`} } let n0 = og * ${filas}u; ${T.map(t => ` if (t0 + ${t}u < p.tokens) { for (var j = 0u; j < ${filas}u; j++) { Y[(t0 + ${t}u) * p.rows + n0 + j] = a${t}[j]; } }`).join('\n')} }`; } // ── 2) TESELA: bloqueo en registros con memoria compartida ────────────────── // Reparto de hilos: t → (tr = t % NTR, tc = t / NTR). El hilo tr lleva los // cuartetos de filas tr, tr+NTR, … (G = TM/4) y el hilo tc los cuartetos de // tokens tc, tc+NTC, … (H = TN/4). Con eso, en una lectura de la tesela de pesos // los hilos de un subgrupo piden cuartetos CONSECUTIVOS (sin conflictos de // banco) y en la de activaciones casi todos piden el mismo (difusión). // // Las teselas en memoria compartida van con k como dimensión lenta: el elemento // (k, q) es un vec4 con cuatro filas (o cuatro tokens) en ese k. Una fila de // k mide BM/4 + 1 vec4: el relleno hace que al GUARDAR (cada hilo escribe un // cuarteto de filas en cuatro k seguidos) los ocho k de un subgrupo no caigan // todos en los mismos bancos. export function formaTesela({ BM = 128, BN = 64, TM = 8, TN = 4, doble = true } = {}) { const NTR = BM / TM, NTC = BN / TN; const SW = BM / 4 + 1, SX = BN / 4 + 1; const NBUF = doble ? 2 : 1; return { BM, BN, TM, TN, doble, NTR, NTC, HILOS: NTR * NTC, G: TM / 4, H: TN / 4, SW, SX, NBUF, // Bytes de memoria compartida: lo que se compara con el tope del dispositivo. compartida: NBUF * 32 * (SW + SX) * 8, unidadesW: (BM / 4) * 8, unidadesX: (BN / 4) * 8, }; } export function gemm2TeselaShader({ type = 'Q8_0', BM = 128, BN = 64, TM = 8, TN = 4, doble = true, acc16 = false, partes = 1, maxCompartida = 32768 } = {}) { if (!GEMM2_TIPOS.has(type)) throw new Error(`gemm2 tesela: tipo «${type}» no soportado`); if (TM % 4 || TN % 4 || BM % TM || BN % TN || BM % 4 || BN % 4) { throw new Error(`gemm2 tesela: forma ${BM}×${BN} con ${TM}×${TN} por hilo no encaja (múltiplos de 4)`); } const F = formaTesela({ BM, BN, TM, TN, doble }); const { NTR, NTC, HILOS, G, H, SW, SX, NBUF } = F; if (HILOS > 256) throw new Error(`gemm2 tesela: ${HILOS} hilos por grupo (tope 256)`); if (F.compartida > maxCompartida) { throw new Error(`gemm2 tesela: pide ${F.compartida} bytes de memoria compartida y el tope es ${maxCompartida}`); } // Cada unidad de carga son 4 filas × 4 k (pesos) o 4 tokens × 4 k // (activaciones). Tienen que repartirse sin resto: un hueco sin escribir en la // tesela se leería como basura de la vuelta anterior, no como cero. if (F.unidadesW > HILOS && F.unidadesW % HILOS) throw new Error('gemm2 tesela: la tesela de pesos no se reparte exacta'); if (F.unidadesX > HILOS && F.unidadesX % HILOS) throw new Error('gemm2 tesela: la tesela de activaciones no se reparte exacta'); if (!(partes >= 1 && partes <= 64)) throw new Error(`gemm2 tesela: partes=${partes}`); const UW = Math.max(1, F.unidadesW / HILOS), UX = Math.max(1, F.unidadesX / HILOS); const TW = 32 * SW, TX = 32 * SX; const L = []; const r4 = [0, 1, 2, 3]; // Declaración de las unidades de carga de este hilo. for (let i = 0; i < UW; i++) { L.push(` let uw${i} = t + ${i * HILOS}u;`); L.push(` let wkq${i} = uw${i} % 8u;`); L.push(` let wrq${i} = uw${i} / 8u;`); L.push(` let wact${i} = uw${i} < ${F.unidadesW}u;`); for (const r of r4) L.push(` var cw${i}_${r} : vec2;\n var ce${i}_${r} : u32;`); } for (let i = 0; i < UX; i++) { L.push(` let ux${i} = t + ${i * HILOS}u;`); L.push(` let xkq${i} = ux${i} % 8u;`); L.push(` let xtq${i} = ux${i} / 8u;`); L.push(` let xact${i} = ux${i} < ${F.unidadesX}u;`); for (const r of r4) L.push(` var cx${i}_${r} : vec4;`); } const DECL = L.join('\n'); // Carga a registros de la tesela `kt` (solo lecturas; nada se descodifica aquí). const carga = (kt) => { const C = []; for (let i = 0; i < UW; i++) { C.push(` if (wact${i}) {`); for (const r of r4) { C.push(` { let ib = (fila0 + wrq${i} * 4u + ${r}u) * p.bpr + ${kt}; ce${i}_${r} = g2_ecruda(ib); cw${i}_${r} = g2_crudo(ib, wkq${i} * 4u); }`); } C.push(' }'); } for (let i = 0; i < UX; i++) { C.push(` if (xact${i}) {`); for (const r of r4) { // Tokens fuera del lote: CERO, no lo que hubiera de la vuelta anterior. C.push(` { let tk = tok0 + xtq${i} * 4u + ${r}u; cx${i}_${r} = select(vec4(0.0), X[min(tk, p.tokens - 1u) * p.ks4 + ${kt} * 8u + xkq${i}], tk < p.tokens); }`); } C.push(' }'); } return C.join('\n'); }; // Descodificación de lo precargado y guardado en el búfer `b` de la tesela. const guarda = (b, kt) => { const C = []; for (let i = 0; i < UW; i++) { C.push(` if (wact${i}) {`); for (const r of r4) { C.push(` let ib${r} = (fila0 + wrq${i} * 4u + ${r}u) * p.bpr + ${kt};`); C.push(` let v${r} = g2_cuatro(cw${i}_${r}, ib${r}, wkq${i} * 4u, g2_escala_de(ce${i}_${r}, ib${r}));`); } // Transposición 4×4 en registros: cada vec4 guardado son cuatro FILAS en un k. for (let c = 0; c < 4; c++) { C.push(` Ws[${b} * ${TW}u + (wkq${i} * 4u + ${c}u) * ${SW}u + wrq${i}] = vec4(vec4(v0[${c}], v1[${c}], v2[${c}], v3[${c}]));`); } C.push(' }'); } for (let i = 0; i < UX; i++) { C.push(` if (xact${i}) {`); for (let c = 0; c < 4; c++) { C.push(` Xs[${b} * ${TX}u + (xkq${i} * 4u + ${c}u) * ${SX}u + xtq${i}] = vec4(cx${i}_0[${c}], cx${i}_1[${c}], cx${i}_2[${c}], cx${i}_3[${c}]);`); } C.push(' }'); } return C.join('\n'); }; // Acumuladores: token n (0..TN-1) × cuarteto de filas g (0..G-1), vec4 sobre // las cuatro filas: así el volcado es una escritura vec4 por token y cuarteto. const A = []; for (let n = 0; n < TN; n++) { for (let g = 0; g < G; g++) { A.push(` var a${n}_${g} = vec4(0.0);`); if (acc16) A.push(` var h${n}_${g} = vec4(0.0);`); } } const ACUM = A.join('\n'); // El producto de una tesela: 32 pasos de k; en cada uno, G lecturas de pesos y // H de activaciones alimentan TN·G FMA vectoriales. const P = []; P.push(' for (var kk = 0u; kk < 32u; kk = kk + 1u) {'); P.push(` let wb = cur * ${TW}u + kk * ${SW}u + tr;`); P.push(` let xb = cur * ${TX}u + kk * ${SX}u + tc;`); for (let g = 0; g < G; g++) { P.push(acc16 ? ` let w${g} = Ws[wb + ${g * NTR}u];` : ` let w${g} = vec4(Ws[wb + ${g * NTR}u]);`); } for (let h = 0; h < H; h++) P.push(` let x${h} = Xs[xb + ${h * NTC}u];`); for (let h = 0; h < H; h++) { for (let tk = 0; tk < 4; tk++) { const n = h * 4 + tk; P.push(acc16 ? ` let s${n} = vec4(x${h}[${tk}]);` : ` let s${n} = vec4(f32(x${h}[${tk}]));`); for (let g = 0; g < G; g++) { P.push(acc16 ? ` h${n}_${g} = fma(w${g}, s${n}, h${n}_${g});` : ` a${n}_${g} = fma(w${g}, s${n}, a${n}_${g});`); } } } P.push(' }'); if (acc16) { // Volcado a f32 al final de CADA tesela de k: la suma en f16 nunca pasa de // 32 productos, que es lo que acota su error. for (let n = 0; n < TN; n++) { for (let g = 0; g < G; g++) P.push(` a${n}_${g} = a${n}_${g} + vec4(h${n}_${g}); h${n}_${g} = vec4(0.0);`); } } const PRODUCTO = P.join('\n'); const V = []; V.push(` let off = wg.z * p.tokens * (p.rows / 4u); // parte de k (1 sola sin partir)`); for (let h = 0; h < H; h++) { for (let tk = 0; tk < 4; tk++) { const n = h * 4 + tk; V.push(` { let tok = tok0 + (tc + ${h * NTC}u) * 4u + ${tk}u;`); V.push(' if (tok < p.tokens) {'); for (let g = 0; g < G; g++) { V.push(` Y[off + tok * (p.rows / 4u) + fila0 / 4u + tr + ${g * NTR}u] = a${n}_${g};`); } V.push(' } }'); } } const VOLCADO = V.join('\n'); const BUCLE = doble ? /* wgsl */` for (var kt = kt0; kt < kt1; kt = kt + 1u) { let cur = (kt - kt0) & 1u; let hay = kt + 1u < kt1; if (hay) { ${carga('(kt + 1u)')} } ${PRODUCTO} if (hay) { ${guarda('(1u - cur)', '(kt + 1u)')} } // Una sola barrera: el búfer que se acaba de escribir nadie lo estaba leyendo // (se leyó en la vuelta anterior, y todos pasaron ya su barrera). workgroupBarrier(); }` : /* wgsl */` for (var kt = kt0; kt < kt1; kt = kt + 1u) { let cur = 0u; let hay = kt + 1u < kt1; if (hay) { ${carga('(kt + 1u)')} } ${PRODUCTO} workgroupBarrier(); if (hay) { ${guarda('0u', '(kt + 1u)')} } workgroupBarrier(); }`; return /* wgsl */` enable f16; struct P { rows : u32, tokens : u32, bpr : u32, ks4 : u32, baseEsc : u32, pad0 : u32, pad1 : u32, pad2 : u32 }; @group(0) @binding(0) var w : array; // pesos cuantizados (${type}) @group(0) @binding(1) var X : array>; // [T][K/4] @group(0) @binding(2) var Y : array>; // [partes][T][rows/4] @group(0) @binding(3) var p : P; ${HELPERS} ${bloqueWgsl(type)} var Ws : array, ${NBUF * TW}u>; // [búfer][k][cuarteto de filas] (paso ${SW}) var Xs : array, ${NBUF * TX}u>; // [búfer][k][cuarteto de tokens] (paso ${SX}) @compute @workgroup_size(${HILOS}) fn main(@builtin(workgroup_id) wg : vec3, @builtin(local_invocation_id) lid : vec3) { let t = lid.x; let tr = t % ${NTR}u; let tc = t / ${NTR}u; let fila0 = wg.y * ${BM}u; let tok0 = wg.x * ${BN}u; // Rango de teselas de k de esta parte (todas si no se parte). let kt0 = (wg.z * p.bpr) / ${partes}u; let kt1 = ((wg.z + 1u) * p.bpr) / ${partes}u; ${DECL} ${ACUM} if (kt0 < kt1) { ${carga('kt0')} ${guarda('0u', 'kt0')} } workgroupBarrier(); ${BUCLE} ${VOLCADO} }`; } // ── Suma de las partes de k (forma partida de la tesela) ──────────────────── // Y = P0 + P1 + … en ese orden fijo: determinista de una pasada a otra. export function gemm2SumaShader(partes = 2, wg = 256) { const S = [...Array(partes).keys()]; return /* wgsl */` 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; } var s = src[i]; ${S.slice(1).map(s => ` s = s + src[i + ${s}u * p.n4];`).join('\n')} dst[i] = s; }`; } // ── 5) Q4_0 y Q4_0R en el GEMM teselado de 4 a 63 tokens ──────────────────── // Tiradas para `matmulGemmShader` (kernels.gemm.wgsl.js), con su mismo contrato: // escriben `n` pesos consecutivos de la fila desde `e0` (múltiplo de 4) dentro // del bloque, a f32, en memoria compartida. El valor es CARÁCTER POR CARÁCTER el // del `decode` de Q4_0 (`f32(i32(nibble) - 8) * d`), así que los pesos son los // mismos bits que en el resto del motor. Un cuarteto alineado a 4 nunca cruza de // la mitad baja a la alta del bloque (16 es múltiplo de 4). const TIRADAS_Q4 = { Q4_0: ({ n, escribe }) => /* wgsl */` let d = load_scale(blk); for (var i = 0u; i < ${n}u; i = i + 4u) { let e = e0 + i; let q = load_u32_at(blk + 2u + (e & 15u)); let sh = select(0u, 4u, e >= 16u); for (var c = 0u; c < 4u; c = c + 1u) { ${escribe('i + c', 'f32(i32((q >> (c * 8u + sh)) & 0xFu) - 8) * d')} } }`, // El bloque se localiza por su ÍNDICE (fila · bpr + b), no por bytes; la // región de escalas empieza en la palabra 4 · nBlocks, con nBlocks los bloques // del TENSOR (ops.gemm2.js los saca de la marca, no del filas · bpr de la // llamada). Q4_0R: ({ n, escribe }) => /* wgsl */` let ib = global * bpr + b; let d = unpack2x16float(w[4u * params.nBlocks + ib / 2u])[ib & 1u]; for (var i = 0u; i < ${n}u; i = i + 4u) { let e = e0 + i; let q = w[ib * 4u + (e & 15u) / 4u]; let sh = select(0u, 4u, e >= 16u); for (var c = 0u; c < 4u; c = c + 1u) { ${escribe('i + c', 'f32(i32((q >> (c * 8u + sh)) & 0xFu) - 8) * d')} } }`, }; export const TIPOS_Q4_TESELA = new Set(Object.keys(TIRADAS_Q4)); // El `extra` que entiende `matmulGemmShader`: descriptor del bloque y tirada. export function extraQ4(type) { const tirada = TIRADAS_Q4[type]; if (!tirada) throw new Error(`gemm2: sin tirada de GEMM teselado para «${type}»`); return { info: { blockElems: 32, blockBytes: 18, helpers: '', table: null }, tirada }; } // El shader del GEMM teselado para Q4_0/Q4_0R. Los mismos números de forma que // el de Q8_0 (TM, TN, WGM, WGN, TK, maxCompartida); el relleno y el bucle plano // los sigue leyendo `matmulGemmShader` de sus interruptores, como siempre. export function gemmQ4Shader(type, forma = {}) { return matmulGemmShader(type, { ...forma, extra: extraQ4(type) }); }