Spaces:
Running
Running
Download js/engine/kernels.gemm.wgsl.js from UtopiaIA/elffuss-code: direct link, hf CLI and curl.
- Browser
- Download file 23.7 kB
-
https://huggingface.co/spaces/UtopiaIA/elffuss-code/resolve/main/js/engine/kernels.gemm.wgsl.js
- Command line
-
hf download hf://spaces/UtopiaIA/elffuss-code/js/engine/kernels.gemm.wgsl.js
-
curl -L -o kernels.gemm.wgsl.js https://huggingface.co/spaces/UtopiaIA/elffuss-code/resolve/main/js/engine/kernels.gemm.wgsl.js
23.7 kB
| // SPDX-License-Identifier: Apache-2.0 | |
| // Copyright (c) 2026 UtopiaIA | |
| // GEMM con teselado en REGISTROS para el prefill. | |
| // | |
| // El matmul de este motor da una fila de salida por subgrupo y procesa un token | |
| // cada vez: cada peso que se trae de memoria se usa UNA vez. Con un lote de 32 | |
| // tokens eso son 32 lecturas de los mismos pesos. Y el decode está limitado por | |
| // traerse los pesos, no por calcular, así que ese factor se paga entero. | |
| // | |
| // Se ve por los dos lados: el prefill va por detrás de llama.cpp en el MISMO | |
| // navegador, y una pasada de 8 tokens cuesta 5,15 veces una de 1 cuando debería | |
| // costar poco más que una — que es también la razón por la que el decodificado | |
| // especulativo no compensa aquí (verificar K borradores es justo esa pasada). | |
| // | |
| // La idea es la de cualquier GEMM por bloques, y es la que usa ggml-webgpu: | |
| // | |
| // · una tesela de pesos y otra de activaciones se llevan a memoria compartida | |
| // UNA vez, ya descuantizadas — así el descuantizador también se paga una vez | |
| // por tesela y no una vez por salida; | |
| // · cada hilo acumula un bloque TM×TN en REGISTROS, así que cada peso que lee | |
| // de memoria compartida alimenta TN multiplicaciones en vez de una. | |
| // | |
| // Con TM=TN=4 y un grupo de 8×8 hilos, un peso traído de memoria global acaba | |
| // usándose 32 veces. Ese es todo el cambio. | |
| // | |
| // Las teselas van en f32 y no en f16 a propósito. f16 halvaría el tráfico de | |
| // memoria compartida, pero mezclaría el cambio de MECANISMO con un cambio de | |
| // PRECISIÓN, y entonces una diferencia en los logits no se sabría atribuir. | |
| // Primero que el mecanismo se mida solo; f16 es un interruptor posterior. | |
| // | |
| // ── TK NO es el bloque del tipo ───────────────────────────────────────────── | |
| // La primera versión ataba `TK` —el paso del bucle sobre k— al `blockElems` del | |
| // tipo, porque con Q8_0 (bloques de 32) las dos cosas coincidían y la tirada por | |
| // hilo caía dentro de un solo bloque sin pensarlo. PQ2_0, que es el tipo del | |
| // modelo de producción, tiene bloques de 128, y ahí esa atadura se rompe por | |
| // TRES sitios a la vez: | |
| // | |
| // 1. MEMORIA COMPARTIDA. Con la forma ganadora (2×4 en un grupo de 8×8) y | |
| // TK=128 la tesela son (16 filas + 32 tokens)·128·4 = 24.576 bytes de los | |
| // 32.768 que suelen dar los adaptadores. CABE —o sea que atarlo no habría fallado, | |
| // habría ido lento y callado— pero se come el 75% del presupuesto, y eso | |
| // hunde las ondas residentes. Lo que hizo ganar a 2×4 sobre 4×4 fue | |
| // exactamente lo contrario. Se estaría pagando con ocupación lo que se | |
| // gana con reúso, y ese cambio no sale a cuenta. | |
| // 2. EL BARRIDO SE HUNDE. Las formas de 256 hilos (2×4 g16×16) piden | |
| // (32+64)·128·4 = 49.152 bytes: no caben en ningún caso. O sea que el tipo | |
| // del modelo decidiría qué formas se pueden ni siquiera probar. | |
| // 3. ES UNA COINCIDENCIA, NO UNA RELACIÓN. TK es una propiedad del BUCLE | |
| // (cuánta k cabe en la tesela); blockElems es del FORMATO (cada cuántos | |
| // pesos hay una escala). Atarlas hace que la forma más rápida dependa del | |
| // tipo de cuantización por accidente. | |
| // | |
| // Y no es un argumento de sobremesa: el punto 1 está MEDIDO. Con todo lo demás | |
| // igual sobre el 27B PQ2_0, atar TK al bloque —la opción que no requería tocar | |
| // nada— habría dejado sobre la mesa un factor 2,4 frente a TK=32. Todas las | |
| // variantes eligen el mismo token, así que se comparan cosas que calculan lo | |
| // mismo. | |
| // | |
| // Así que TK se desacopla: la carga a memoria compartida sabe descuantizar un | |
| // tramo PARCIAL de un bloque. La condición que se impone es que **TK divida a | |
| // blockElems**, y no la general «TK y blockElems cualesquiera». No es pereza: | |
| // mientras una tesela no cruce de bloque, cada tirada lee UNA escala y la | |
| // dirección del peso sigue siendo `(fila·bpr + b)·blockBytes`, sin partir nada. | |
| // Permitir el cruce obligaría a llevar dos escalas y dos direcciones por tirada | |
| // para ganar formas que nadie ha pedido. | |
| // | |
| // Con TK = blockElems (SUB = 1) el bucle interno queda de una sola vuelta y el | |
| // código generado es el de antes: el orden de acumulación de Q8_0 no se mueve, | |
| // así que sus logits siguen siendo los mismos bit a bit que antes del cambio. | |
| // | |
| // Lo que el desacoplo NO regala: que un tipo pueda entrar aquí sigue dependiendo | |
| // de que un tramo parcial se pueda descuantizar por sí solo. PQ2_0 puede porque | |
| // son cuatro pesos consecutivos por byte y una escala por bloque. PTQ1_0, por | |
| // ejemplo, NO: guarda cinco trits por byte y el orden de salida no es el de | |
| // los bytes, así que un tramo contiguo de pesos no es un tramo contiguo de | |
| // fichero. De ahí que `TIRADAS` sea una tabla explícita y no un `decode` genérico. | |
| import { HELPERS, AXIS, quantInfo } from './kernels.wgsl.js'; | |
| // Paso por defecto del bucle sobre k. 32 no es el bloque de nadie en concreto: | |
| // es el que sale mejor en el 27B PQ2_0, por delante de 16, 64 y 128, y a la vez | |
| // el que ya estaba medido en Q8_0. Para un tipo de bloque mayor se toma igual | |
| // —min(32, blockElems)— en vez de seguir al bloque, por lo de arriba. | |
| export const TK_POR_DEFECTO = 32; | |
| // Descuantización de UNA tirada de `n` pesos consecutivos de una fila, dentro de | |
| // un solo bloque. Vive aquí y no en el descriptor del tipo porque el contrato es | |
| // distinto: el descriptor entrega valores a un `emit` que acumula; esto los | |
| // ESCRIBE en memoria compartida. Mezclarlos haría que un cambio en el camino de | |
| // decode moviera en silencio el de prefill. | |
| // | |
| // El andamio les da tres nombres: `blk` (offset en bytes del bloque), `e0` (el | |
| // índice del primer peso de la tirada DENTRO del bloque) y `n` como constante. | |
| // `e0` es múltiplo de 4 por construcción — lo garantizan las guardas del | |
| // constructor— y de eso dependen las dos tiradas. | |
| const TIRADAS = { | |
| // 32 pesos, 34 bytes: escala f16 + 32 enteros de 8 bits con signo. | |
| Q8_0: ({ n, escribe }) => /* wgsl */` | |
| // La escala se lee UNA vez por tirada, no una por peso: es lo que permite | |
| // esta forma y no la del decode, donde la tirada es de 8. | |
| let d = load_scale(blk); | |
| for (var i = 0u; i < ${n}u; i = i + 4u) { | |
| let q = load_u32_at(blk + 2u + e0 + i); | |
| for (var c = 0u; c < 4u; c = c + 1u) { | |
| ${escribe('i + c', 'f32(get_byte_i32(q, c)) * d')} | |
| } | |
| }`, | |
| // 128 pesos, 34 bytes: escala f16 + 32 bytes de ranuras de 2 bits. CUATRO | |
| // pesos consecutivos por byte, así que un tramo parcial alineado a 4 es un | |
| // tramo de bytes entero: ni se parte un byte ni hace falta una segunda escala. | |
| // La expresión del valor es CARÁCTER POR CARÁCTER la del `decode` del tipo | |
| // (`f32(i32((by >> (c*2)) & 3) - 1) * d`): si se escribiera «mejor» —sacar la | |
| // escala del bucle, por ejemplo— los pesos dejarían de ser los mismos bits y | |
| // una diferencia en los logits ya no se sabría atribuir al mecanismo. | |
| PQ2_0: ({ n, escribe }) => /* wgsl */` | |
| let d = load_scale(blk); | |
| for (var i = 0u; i < ${n}u; i = i + 4u) { | |
| let by = load_byte(blk + 2u + (e0 + i) / 4u); | |
| for (var c = 0u; c < 4u; c = c + 1u) { | |
| ${escribe('i + c', 'f32(i32((by >> (c * 2u)) & 3u) - 1) * d')} | |
| } | |
| }`, | |
| // Q8_0 REORDENADO al cargar (`__ELFFUSS_REPACK`, kernels.bloques.wgsl.js): | |
| // la tirada de Q8_0 de arriba con las dos lecturas cambiadas. `blk` sale como | |
| // si el formato fuera el del GGUF y se divide por 34 para tener el índice del | |
| // bloque; los cuatro bytes que empiezan en e0+i son la palabra (e0+i)/4 de sus | |
| // cuantos (e0 e i son múltiplos de 4). Mismos bits, mismo valor escrito en la | |
| // tesela: el GEMM no cambia ni un bit. Q4_0R no está, igual que Q4_0. | |
| Q8_0R: ({ n, escribe }) => /* wgsl */` | |
| let bi = blk / 34u; | |
| let d = bq_escala(bi); | |
| for (var i = 0u; i < ${n}u; i = i + 4u) { | |
| let q = bq_palabra(bi, (e0 + i) / 4u); | |
| for (var c = 0u; c < 4u; c = c + 1u) { | |
| ${escribe('i + c', 'f32(get_byte_i32(q, c)) * d')} | |
| } | |
| }`, | |
| }; | |
| // Qué tipos saben pasar por aquí. La lista SON las claves de `TIRADAS`: tener | |
| // dos sitios que decir lo mismo es tener dos sitios que desincronizar. | |
| export const TIPOS_GEMM = new Set(Object.keys(TIRADAS)); | |
| // Paso del bucle sobre k para un tipo. `override` es para el barrido. | |
| export function tkPara(type, override = 0) { | |
| const d = quantInfo(type); | |
| const tk = (override | 0) || Math.min(TK_POR_DEFECTO, d.blockElems); | |
| return tk; | |
| } | |
| export function soportaGemm(type, k, TK = 0) { | |
| if (!TIPOS_GEMM.has(type)) return false; | |
| const d = quantInfo(type); | |
| const tk = tkPara(type, TK); | |
| // TK divide al bloque (una tesela no cruza de bloque), TK es múltiplo de 4 | |
| // (las dos tiradas leen de 4 en 4) y k entero en teselas. | |
| return tk > 0 && tk % 4 === 0 && d.blockElems % tk === 0 && k % tk === 0; | |
| } | |
| /** | |
| * Y = W · X con W cuantizada (rows×k) y X token-major (tokens×k). | |
| * Salida y[token * rows + row], igual que el matmul de siempre: es un sustituto | |
| * intercambiable, no un camino paralelo con otro contrato. | |
| * | |
| * `maxCompartida` es el tope de memoria compartida por grupo del dispositivo | |
| * (`limits.maxComputeWorkgroupStorageSize`). Se pasa para poder RECHAZAR una | |
| * forma que no cabe con un mensaje que diga cuánto pedía, en vez de que reviente | |
| * la validación de WebGPU al crear el pipeline con un texto genérico. | |
| */ | |
| export function matmulGemmShader(type, { TM = 4, TN = 4, WGM = 8, WGN = 8, TK = 0, maxCompartida = 32768, extra = null } = {}) { | |
| // `extra` (interruptor GEMM2_Q4, ver kernels.gemm2.wgsl.js): un tipo que NO | |
| // está en TIRADAS trae su descriptor de bloque y su tirada. Sin él, todo | |
| // sigue exactamente igual que antes. | |
| const d = extra ? extra.info : quantInfo(type); | |
| if (!TIPOS_GEMM.has(type) && !extra) { | |
| throw new Error(`matmulGemmShader: «${type}» todavía no pasa por el GEMM (ver TIRADAS)`); | |
| } | |
| const tk = extra ? ((TK | 0) || Math.min(TK_POR_DEFECTO, d.blockElems)) : tkPara(type, TK); | |
| if (tk % 4 !== 0) { | |
| throw new Error(`matmulGemmShader: TK=${tk} tiene que ser múltiplo de 4 (las tiradas leen de 4 en 4)`); | |
| } | |
| // Una tesela que cruzara de bloque necesitaría dos escalas y dos direcciones | |
| // por tirada. No se soporta, así que se rechaza: leerla con una sola escala | |
| // daría pesos mal escalados SIN lanzar, que es el modo de fallo caro. | |
| if (d.blockElems % tk !== 0) { | |
| throw new Error(`matmulGemmShader: TK=${tk} tiene que dividir al bloque de «${type}» (${d.blockElems})`); | |
| } | |
| const SUB = d.blockElems / tk; // sub-teselas por bloque; 1 = el caso de antes | |
| const HILOS = WGM * WGN; | |
| const FILAS_WG = WGM * TM; // filas de salida por grupo | |
| const TOKS_WG = WGN * TN; // tokens por grupo | |
| // ── PASO DE LA TESELA: CON RELLENO ───────────────────────────────────────── | |
| // El paso entre filas de la tesela era `tk` floats. Con el tk medido como | |
| // mejor (32) eso son 32 floats = 128 bytes, y en una arquitectura de 32 bancos | |
| // de 4 bytes el banco es `índice % 32`: todas las filas caen en EL MISMO | |
| // banco. Conflicto de 32 vías, o sea los accesos de un subgrupo serializados. | |
| // Es el peor caso posible y era el último candidato sin probar del prefill | |
| // (el matmul corre al 37 % del techo de cálculo). | |
| // | |
| // Un float de relleno por fila rompe la periodicidad: con paso tk+1, la fila | |
| // r en kk cae en el banco (r·(tk+1) + kk) % 32 = (r + kk) % 32 con tk=32, o | |
| // sea un banco distinto por fila. Cuesta (FILAS_WG + TOKS_WG) floats de | |
| // memoria compartida, que es ruido. | |
| // | |
| // ⚠️ MEDIDO Y DESCARTADO. Apagado por defecto: con RELLENO=0 el shader | |
| // generado es EXACTAMENTE el de antes. | |
| // | |
| // En un A/B del prefill completo, con el orden alternado en la misma sesión, | |
| // el ganador cambia de una ronda a otra: es ruido, no efecto. (Se alterna el | |
| // orden y se exige que el ganador se repita porque la primera medida paga la | |
| // compilación del shader.) | |
| // | |
| // Y la razón de que no haya nada que ganar está en el propio bucle: en | |
| // `xs[(ln*TN+tn)*SW + kk]` los hilos de un subgrupo que comparten `ln` leen la | |
| // MISMA dirección, que es un broadcast y no un conflicto. Un conflicto de | |
| // banco exige hilos leyendo direcciones DISTINTAS del mismo banco, y aquí el | |
| // patrón es broadcast más paso 1 en kk. Nunca hubo un conflicto de 32 vías | |
| // que romper, aunque el paso de 128 bytes lo sugiriera sobre el papel. | |
| // | |
| // Se conserva el mecanismo (a 1 rellena) porque la medida cuesta una línea y | |
| // en otro adaptador, u otro reparto de hilos, podría dejar de ser broadcast. | |
| const RELLENO = globalThis.__ELFFUSS_PAD_TESELA === 1 ? 1 : 0; | |
| const SW = tk + RELLENO; | |
| // La memoria compartida se comprueba AQUÍ y no se deja al driver: el barrido | |
| // necesita distinguir «esta forma no cabe» de «esta forma va lenta». | |
| // Se cuenta con SW y no con tk: si no, el relleno quedaría fuera de la cuenta | |
| // y una tesela al límite pasaría la guarda para que la rechazara el driver, | |
| // que es exactamente lo que esta comprobación existe para evitar. | |
| const compartida = (FILAS_WG + TOKS_WG) * SW * 4; | |
| if (compartida > maxCompartida) { | |
| throw new Error(`matmulGemmShader: la tesela pide ${compartida} bytes de memoria compartida ` + | |
| `y el tope es ${maxCompartida} (filas ${FILAS_WG} + tokens ${TOKS_WG}, TK=${tk})`); | |
| } | |
| // Cuántos elementos pone cada hilo en cada tesela. Tiene que repartirse | |
| // EXACTO: un reparto con resto dejaría huecos sin escribir en memoria | |
| // compartida, y lo que se leería de ahí sería basura de la iteración anterior | |
| // —no ceros—, o sea un resultado incorrecto que además no es reproducible. | |
| if ((FILAS_WG * tk) % HILOS !== 0 || (TOKS_WG * tk) % HILOS !== 0) { | |
| throw new Error(`matmulGemmShader: la tesela no se reparte exacta entre ${HILOS} hilos`); | |
| } | |
| const POR_HILO_W = (FILAS_WG * tk) / HILOS; | |
| const POR_HILO_X = (TOKS_WG * tk) / HILOS; | |
| if (POR_HILO_W % 4 !== 0) { | |
| throw new Error('matmulGemmShader: la tirada de pesos por hilo debe ser múltiplo de 4 (se leen de 4 en 4)'); | |
| } | |
| // La carga a memoria compartida calcula UNA fila y UN bloque por hilo, así que | |
| // la tirada no puede cruzar de fila. Sin esta guarda, una forma con la tirada | |
| // más larga que el bloque lee los pesos de la fila equivocada y devuelve un | |
| // resultado incorrecto SIN lanzar — que es justo lo que pasó con 8x4 g16x4: | |
| // salía a toda velocidad y contestaba otra cosa. Una forma que no vale tiene | |
| // que ser rechazada, no medida. | |
| if (POR_HILO_W > tk || POR_HILO_X > tk) { | |
| throw new Error(`matmulGemmShader: la tirada por hilo (pesos ${POR_HILO_W}, activaciones ${POR_HILO_X}) ` + | |
| `no puede pasar de la tesela (${tk}): cruzaría de fila`); | |
| } | |
| // Y no basta con que quepa: tiene que ENCAJAR. Con una tirada que no divide a | |
| // TK, el hilo `tid` arranca en `(tid·POR_HILO) % TK` y se sale por el final de | |
| // su fila, pisando el principio de la siguiente y dejando un hueco detrás. Con | |
| // formas potencia de dos no pasa nunca, pero «no pasa nunca con las que he | |
| // probado» no es una guarda. | |
| if (tk % POR_HILO_W !== 0 || tk % POR_HILO_X !== 0) { | |
| throw new Error(`matmulGemmShader: la tirada por hilo (pesos ${POR_HILO_W}, activaciones ${POR_HILO_X}) ` + | |
| `tiene que dividir a la tesela (${tk}): si no, se desborda de fila`); | |
| } | |
| // Y la tirada tampoco puede cruzar de BLOQUE dentro de la fila. Con TK | |
| // dividiendo al bloque y la tirada dividiendo a TK esto ya se cumple, pero se | |
| // deja escrito porque es la condición de la que depende leer UNA sola escala. | |
| if (d.blockElems % POR_HILO_W !== 0) { | |
| throw new Error(`matmulGemmShader: la tirada de pesos (${POR_HILO_W}) cruzaría de bloque (${d.blockElems})`); | |
| } | |
| // El bucle del producto, en DOS formas. La de siempre indexa arrays por la | |
| // variable de bucle; la plana genera un escalar por acumulador y ni un indice | |
| // dinamico. | |
| // | |
| // Importa porque un array en ambito de funcion indexado dinamicamente puede | |
| // acabar en memoria de RASCADO en vez de en registros, a criterio del | |
| // compilador. Si los acumuladores no estan en registros, cada | |
| // multiplicacion-acumulacion es un viaje a memoria. | |
| // | |
| // OJO con lo que esto NO es: el teselado por registros YA estaba puesto —los | |
| // pesos se leen una vez por kk y alimentan las TN columnas—. Esto solo probaba | |
| // si el indexado dinamico se derrama, que es una duda de compilador y no una | |
| // palanca nueva. | |
| // | |
| // ⚠️ MEDIDO Y DESCARTADO: x1,00 en el prefill completo, y el ganador alterna | |
| // entre rondas. El compilador ya mantiene los acumuladores en registros. | |
| // Apagado por defecto; el shader que genera el defecto es el de siempre. | |
| // | |
| // Y una leccion del INSTRUMENTO que vale mas que el resultado: sin calentar, | |
| // la primera medida paga la compilacion del shader y sale muy por debajo, y | |
| // ese artefacto cae siempre sobre la primera variante medida. Sin calentar, | |
| // el plano parecia ganar; calentando las DOS formas y descartando esas | |
| // medidas, la diferencia desaparece. Si una variante compila su propio | |
| // pipeline, hay que calentarla antes de cronometrarla. | |
| const plano = globalThis.__ELFFUSS_GEMM_PLANO === true; | |
| const L = []; | |
| L.push(` for (var kk = 0u; kk < ${tk}u; kk = kk + 1u) {`); | |
| if (plano) { | |
| for (let tm = 0; tm < TM; tm++) { | |
| L.push(` let w${tm} = ws[(lm * ${TM}u + ${tm}u) * ${SW}u + kk];`); | |
| } | |
| for (let tn = 0; tn < TN; tn++) { | |
| L.push(` let x${tn} = xs[(ln * ${TN}u + ${tn}u) * ${SW}u + kk];`); | |
| for (let tm = 0; tm < TM; tm++) { | |
| L.push(` a${tm}_${tn} = a${tm}_${tn} + w${tm} * x${tn};`); | |
| } | |
| } | |
| } else { | |
| L.push(` var wr : array<f32, ${TM}u>;`); | |
| L.push(` for (var tm = 0u; tm < ${TM}u; tm = tm + 1u) {`); | |
| L.push(` wr[tm] = ws[(lm * ${TM}u + tm) * ${SW}u + kk];`); | |
| L.push(' }'); | |
| L.push(` for (var tn = 0u; tn < ${TN}u; tn = tn + 1u) {`); | |
| L.push(` let xv = xs[(ln * ${TN}u + tn) * ${SW}u + kk];`); | |
| L.push(` for (var tm = 0u; tm < ${TM}u; tm = tm + 1u) {`); | |
| L.push(' acc[tm][tn] = acc[tm][tn] + wr[tm] * xv;'); | |
| L.push(' }'); | |
| L.push(' }'); | |
| } | |
| L.push(' }'); | |
| const PRODUCTO = L.join('\n'); | |
| // Declaración de los acumuladores y volcado final, coherentes con la forma | |
| // elegida: si el producto usa escalares, aquí NO puede quedar un array, o el | |
| // shader ni compila. | |
| const D = []; | |
| if (plano) { | |
| D.push(' // Acumuladores como ESCALARES: ni un indice dinamico en el kernel.'); | |
| for (let tm = 0; tm < TM; tm++) { | |
| for (let tn = 0; tn < TN; tn++) D.push(` var a${tm}_${tn} = 0.0;`); | |
| } | |
| } else { | |
| D.push(' // Acumulador TM x TN en registros. Esto es el kernel entero: lo que lo'); | |
| D.push(' // hace rapido es que estas celdas no vuelven a memoria hasta el final.'); | |
| D.push(` var acc : array<array<f32, ${TN}u>, ${TM}u>;`); | |
| D.push(` for (var tm = 0u; tm < ${TM}u; tm = tm + 1u) {`); | |
| D.push(` for (var tn = 0u; tn < ${TN}u; tn = tn + 1u) { acc[tm][tn] = 0.0; }`); | |
| D.push(' }'); | |
| } | |
| const DECL_ACC = D.join('\n'); | |
| const V = []; | |
| if (plano) { | |
| for (let tn = 0; tn < TN; tn++) { | |
| V.push(` {`); | |
| V.push(` let tok = tok0 + ln * ${TN}u + ${tn}u;`); | |
| V.push(' if (tok < params.tokens) {'); | |
| for (let tm = 0; tm < TM; tm++) { | |
| V.push(` let f${tm} = fila0 + lm * ${TM}u + ${tm}u;`); | |
| V.push(` if (f${tm} < params.rows) { y[tok * params.rows + f${tm}] = a${tm}_${tn}; }`); | |
| } | |
| V.push(' }'); | |
| V.push(' }'); | |
| } | |
| } else { | |
| V.push(` for (var tn = 0u; tn < ${TN}u; tn = tn + 1u) {`); | |
| V.push(` let tok = tok0 + ln * ${TN}u + tn;`); | |
| V.push(' if (tok >= params.tokens) { continue; }'); | |
| V.push(` for (var tm = 0u; tm < ${TM}u; tm = tm + 1u) {`); | |
| V.push(` let fila = fila0 + lm * ${TM}u + tm;`); | |
| V.push(' if (fila < params.rows) {'); | |
| V.push(' y[tok * params.rows + fila] = acc[tm][tn];'); | |
| V.push(' }'); | |
| V.push(' }'); | |
| V.push(' }'); | |
| } | |
| const VOLCADO = V.join('\n'); | |
| const tirada = (extra ? extra.tirada : TIRADAS[type])({ | |
| n: POR_HILO_W, | |
| escribe: (i, v) => `ws[fila * ${SW}u + kk0 + ${i}] = ${v};`, | |
| }); | |
| return /* wgsl */` | |
| struct Params { nBlocks: u32, blocksPerRow: u32, rows: u32, k: u32, | |
| tokens: u32, pad0: u32, pad1: u32, pad2: u32 }; | |
| @group(0) @binding(0) var<storage, read> w : array<u32>; | |
| @group(0) @binding(1) var<storage, read> x : array<f32>; | |
| @group(0) @binding(2) var<storage, read_write> y : array<f32>; | |
| @group(0) @binding(3) var<uniform> params : Params; | |
| ${d.table ? '@group(0) @binding(4) var<storage, read> tbl : array<u32>;' : ''} | |
| ${HELPERS}${d.helpers} | |
| var<workgroup> ws : array<f32, ${FILAS_WG * SW}u>; // tesela de pesos, ya descuantizada (paso con relleno) | |
| var<workgroup> xs : array<f32, ${TOKS_WG * SW}u>; // tesela de activaciones (paso con relleno) | |
| @compute @workgroup_size(${HILOS}) | |
| fn main(@builtin(workgroup_id) wid : vec3<u32>, | |
| @builtin(local_invocation_id) lid : vec3<u32>) { | |
| let tid = lid.x; | |
| // Reparto del hilo dentro de la tesela de salida. | |
| let lm = tid % ${WGM}u; | |
| let ln = tid / ${WGM}u; | |
| // Las filas van en DOS ejes: uno solo topa en 65.535 y la cabeza de salida | |
| // son cientos de miles de filas. Los tokens van en el tercero. | |
| let fila0 = (wid.x + wid.y * ${AXIS}u) * ${FILAS_WG}u; | |
| let tok0 = wid.z * ${TOKS_WG}u; | |
| let bpr = params.blocksPerRow; | |
| // Acumulador TM×TN en registros. Esto es el kernel entero: lo que lo hace | |
| // rápido es que estas ${TM * TN} celdas no vuelven a memoria hasta el final. | |
| ${DECL_ACC} | |
| for (var b = 0u; b < bpr; b = b + 1u) { | |
| // Sub-teselas dentro del bloque. Con SUB=1 (TK = blockElems) esta vuelta | |
| // desaparece y queda exactamente el bucle de antes, incluido el orden de | |
| // acumulación: por eso Q8_0 no cambia ni un bit al desacoplar TK. | |
| for (var s = 0u; s < ${SUB}u; s = s + 1u) { | |
| let kOff = s * ${tk}u; // offset dentro del bloque | |
| let k0 = b * ${d.blockElems}u + kOff; // offset absoluto en k | |
| // ── Tesela de PESOS a memoria compartida, descuantizada una sola vez ── | |
| { | |
| let plano = tid * ${POR_HILO_W}u; | |
| let fila = plano / ${tk}u; | |
| let kk0 = plano % ${tk}u; | |
| let e0 = kOff + kk0; | |
| let global = fila0 + fila; | |
| if (global < params.rows) { | |
| let blk = (global * bpr + b) * ${d.blockBytes}u; | |
| ${tirada} | |
| } else { | |
| // Fuera de rango se escriben CEROS, no se deja lo de la vuelta anterior: | |
| // esas filas se calculan igual y solo se descartan al guardar, así que | |
| // basura aquí sería basura sumada en acumuladores que sí se guardan. | |
| for (var i = 0u; i < ${POR_HILO_W}u; i = i + 1u) { ws[fila * ${SW}u + kk0 + i] = 0.0; } | |
| } | |
| } | |
| // ── Tesela de ACTIVACIONES ── | |
| { | |
| let plano = tid * ${POR_HILO_X}u; | |
| let t = plano / ${tk}u; | |
| let kk0 = plano % ${tk}u; | |
| let global = tok0 + t; | |
| let base = global * params.k + k0 + kk0; | |
| for (var i = 0u; i < ${POR_HILO_X}u; i = i + 1u) { | |
| xs[t * ${SW}u + kk0 + i] = select(0.0, x[base + i], global < params.tokens); | |
| } | |
| } | |
| workgroupBarrier(); | |
| ${PRODUCTO} | |
| workgroupBarrier(); | |
| } | |
| } | |
| ${VOLCADO} | |
| } | |
| `; | |
| } | |