Spaces:
Running
Running
File size: 11,711 Bytes
4bd8362 | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 | // SPDX-License-Identifier: Apache-2.0
// Copyright (c) 2026 UtopiaIA
// Elffuss Runtime · operaciones de los GEMV nuevos del decode (`__ELFFUSS_GEMV2`).
// ─────────────────────────────────────────────────────────────────────────────
// Tres operaciones sobre los kernels de `kernels.gemv.wgsl.js`:
// · matmul: la proyección de siempre (1 a 3 tokens), mismo contrato que
// `quant.matmul`: y = W·x con x token-major y la salida [tokens][filas];
// · gateUp: gate y up del FFN con la SwiGLU en el epílogo: devuelve
// directamente silu(W_gate·x)·(W_up·x). Tres despachos en uno;
// · secciones: varias matrices con la MISMA entrada y la misma K (Q, K, V y la
// puerta de la atención) en un solo despacho, cada una con su salida.
//
// Cualquiera de las tres devuelve `null` cuando no aplica —tipo sin kernel
// nuevo, dispositivo sin subgrupos de 32, búfer sin la holgura que hace falta,
// demasiados enlaces, un búfer reordenado que no se deja comprobar, o un shader
// que el compilador del navegador rechazó— y quien llama sigue por el camino de
// siempre. La idea es que el interruptor no rompa un modelo: como mucho, no lo
// acelera. Dos salvedades, a propósito: una forma fijada a mano para el barrido
// (`__ELFFUSS_GEMV2_FORMA`) que no vale LANZA en vez de cambiarse por otra, y un
// búfer reordenado sin marca hace lanzar al camino de siempre, igual que con
// el interruptor quitado (ver `bloquesTensorR`).
//
// El despacho lo pone quien crea esto (`ops.js`): así estas operaciones pasan
// por el MISMO despachador que las demás —agrupado, perfilado y lo que venga—
// y no hay una segunda copia que se desincronice.
//
// Licencia: código propio, Apache-2.0 (ver SPDX arriba y LICENSE). Sin dependencias externas.
import {
gemv2Shader, gemv2Clave, gemv2Formato, gemv2Forma, gemv2Params, gemv2Escalas,
gemv2BloquesDeBuffer, gemv2BytesBufferR, gemv2BytesNecesarios, GEMV2_TIPOS, GEMV2_MAX_TOKENS,
} from './kernels.gemv.wgsl.js';
import { AXIS } from './kernels.wgsl.js';
// Los grupos en dos ejes, como el resto del motor: uno solo topa en AXIS.
function dims(grupos) {
return grupos <= AXIS ? [grupos, 1] : [AXIS, Math.ceil(grupos / AXIS)];
}
// `compruebaR(tipo, buf, { bloques }, que)`: la comprobación de los búferes
// reordenados del módulo que los fabrica (`compruebaBufferR`): lanza si el búfer
// no lleva su marca, es de otro tipo o la llamada se sale del tensor, y si no,
// devuelve el N del tensor. Sin ella (null), N sale del tamaño del búfer.
export function createGemvOps(device, { ctx, subgroupSize = 0, despacha, compruebaR = null }) {
const get = ctx.pipeline;
const limites = device.limits || {};
// `unpack4xI8` es una extensión de lenguaje; sin ella, el shader hace los
// mismos desplazamientos a mano. `__ELFFUSS_GEMV2_U4X8 = false` fuerza la
// versión a mano para compararlas (va en la clave del pipeline).
let u4x8Disp = null;
const u4x8 = () => {
if (globalThis.__ELFFUSS_GEMV2_U4X8 === false) return false;
if (u4x8Disp === null) {
u4x8Disp = !!globalThis.navigator?.gpu?.wgslLanguageFeatures?.has?.('packed_4x8_integer_dot_product');
}
return u4x8Disp;
};
// El reparto de carriles supone subgrupos de 32 exactos: con otro ancho,
// camino de siempre. `__ELFFUSS_NO_SUBGROUP` (lo usan pruebas internas) manda.
const listo = () => subgroupSize === 32 && !globalThis.__ELFFUSS_NO_SUBGROUP;
// Shaders que el compilador del navegador rechazó. naga los valida todos,
// pero el compilador de cada navegador tiene su propio análisis, y un rechazo
// no puede costar el modelo: esa clave no se vuelve a intentar (compilar cuesta
// y fallaría igual), se avisa UNA vez y esas llamadas siguen por el camino de
// siempre. El banco del dispositivo exige que la lista salga vacía.
const rechazadas = new Map(); // clave → mensaje del compilador
async function pipeline(o) {
const clave = gemv2Clave(o);
if (rechazadas.has(clave)) return null;
try {
return await get(clave, () => gemv2Shader(o));
} catch (e) {
const msg = e?.message || String(e);
rechazadas.set(clave, msg);
console.warn(`[engine] gemv2: el compilador rechazó «${clave}»; esas llamadas siguen por el camino de siempre:`, msg);
return null;
}
}
// Despachos hechos por cada operación. Solo diagnóstico: con esto un banco
// con el interruptor puesto comprueba que el GEMV nuevo corrió DE VERDAD y no
// cayó en silencio al camino de siempre (que da números casi iguales).
const hechos = { matmul: 0, gateUp: 0, secciones: 0 };
// Bloques del TENSOR que guarda un búfer reordenado, o null si no se pueden
// saber con seguridad. Las escalas empiezan tras los cuantos de TODOS sus
// bloques, y una llamada puede pedir menos filas de las que tiene el tensor
// (la cabeza pide las del vocabulario): hace falta el N del tensor, no el de
// la llamada.
// · Con `compruebaR` (la marca que el cargador le pone a cada búfer): la
// MISMA comprobación que hace el camino de siempre —marca, tipo y que la
// llamada no se salga del tensor— y el N de la marca. Si no pasa, null, y
// el camino de siempre lanza con su porqué: el interruptor no cambia qué
// búferes se aceptan.
// · Sin ella: del tamaño, y solo si el búfer mide EXACTAMENTE lo que el
// cargador le da a un tensor de ese N. Uno más grande (el pozo redondea a
// 256) se leería como un tensor de más bloques, con las escalas en otro
// sitio y sin un error. Queda un caso que el tamaño no decide —un búfer
// que por casualidad mide justo lo que el de otro N (ver
// `gemv2BloquesDeBuffer`)—; sin la marca no hay cargador que fabrique
// estos búferes, y quien los fabrique a mano tiene que darles ese tamaño.
function bloquesTensorR(tipo, buf, bloquesLlamada) {
if (compruebaR) {
try { return compruebaR(tipo, buf, { bloques: bloquesLlamada }, 'gemv2'); } catch { return null; }
}
const n = gemv2BloquesDeBuffer(tipo, buf.size);
return buf.size === gemv2BytesBufferR(tipo, n) ? n : null;
}
// Lo común a las tres: ¿hay kernel para esto?, y su geometría.
function prepara(tipo, k, tokens, bufs, filasPorBuf) {
if (!listo() || !GEMV2_TIPOS.has(tipo)) return null;
if (!Number.isInteger(tokens) || tokens < 1 || tokens > GEMV2_MAX_TOKENS) return null;
const F = gemv2Formato(tipo);
if (!(k > 0) || k % F.bloque !== 0) return null;
const bpr = k / F.bloque;
// El búfer tiene que servir lo que el kernel lee, holgura incluida. Leer
// fuera de rango no lanza: devuelve otra palabra y la fila sale mal.
// En los reordenados, además, dónde empiezan las escalas depende de los
// bloques del TENSOR (ver `bloquesTensorR`): una llamada con menos filas
// que el tensor no las puede buscar donde acabarían las suyas.
const esc = [];
for (let i = 0; i < bufs.length; i++) {
const f = filasPorBuf[i];
const size = bufs[i]?.size;
if (!(f >= 1) || !(size > 0)) return null;
const n = F.repack ? bloquesTensorR(tipo, bufs[i], f * bpr) : f * bpr;
if (!Number.isInteger(n) || n < f * bpr || !(size >= gemv2BytesNecesarios(tipo, n))) return null;
esc.push(gemv2Escalas(tipo, n));
}
return { F, bpr, esc, pasos: Math.ceil(bpr / F.bloquesPaso), cola: bpr % F.bloquesPaso !== 0 };
}
return {
// y = W·x, 1 a 3 tokens. Mismo contrato y misma salida que `quant.matmul`.
async matmul(tipo, wBuf, xBuf, rows, k, tokens = 1) {
const g = prepara(tipo, k, tokens, [wBuf], [rows]);
if (!g) return null;
const forma = gemv2Forma({ tipo, filas: [rows], k, T: tokens, nm: 1,
maxCompartida: limites.maxComputeWorkgroupStorageSize || 16384 });
const o = { tipo, R: forma.R, NSG: forma.NSG, T: tokens, modo: 'una', n: 1, u4x8: u4x8(), cola: g.cola };
const p = await pipeline(o);
if (!p) return null;
const y = ctx.alloc(rows * tokens * 4, 'matmul.y');
const grupos = rows / forma.R;
const params = ctx.uniform([gemv2Params({ k, bpr: g.bpr, pasos: g.pasos, filas: [rows],
esc: g.esc, fin: [grupos] })]);
const [dx, dy] = dims(grupos);
await despacha(`matmul:${tipo}:r${rows}b${g.bpr}:g2`, p, [wBuf, xBuf, y, params], dx, dy, 1);
hechos.matmul++;
return y;
},
// silu(W_gate·x)·(W_up·x) en un despacho: las dos matrices con las mismas
// filas y la misma K, y cada grupo hace las mismas R filas de las dos.
async gateUp(tipo, wGate, wUp, xBuf, rows, k, tokens = 1) {
const g = prepara(tipo, k, tokens, [wGate, wUp], [rows, rows]);
if (!g) return null;
if ((limites.maxStorageBuffersPerShaderStage || 8) < 4) return null;
const forma = gemv2Forma({ tipo, filas: [rows], k, T: tokens, nm: 2,
maxCompartida: limites.maxComputeWorkgroupStorageSize || 16384 });
const o = { tipo, R: forma.R, NSG: forma.NSG, T: tokens, modo: 'swiglu', n: 2, u4x8: u4x8(), cola: g.cola };
const p = await pipeline(o);
if (!p) return null;
const y = ctx.alloc(rows * tokens * 4, 'swiglu.out');
const grupos = rows / forma.R;
// Una palabra de escalas por matriz (gate en .x, up en .y): dos tensores
// de la misma forma la tienen igual, pero no se da por supuesto.
const params = ctx.uniform([gemv2Params({ k, bpr: g.bpr, pasos: g.pasos, filas: [rows],
esc: g.esc, fin: [grupos] })]);
const [dx, dy] = dims(grupos);
await despacha(`matmul:${tipo}:gateup:r${rows}b${g.bpr}`, p, [wGate, wUp, xBuf, y, params], dx, dy, 1);
hechos.gateUp++;
return y;
},
// Varias matrices (2 a 4) con la misma entrada y la misma K, cada una con su
// número de filas y su salida, en un despacho. Devuelve las salidas en el
// mismo orden que los pesos.
async secciones(tipo, ws, xBuf, filas, k, tokens = 1) {
const n = ws.length;
if (n < 2 || n > 4 || filas.length !== n) return null;
// n pesos + x + n salidas: con cuatro matrices son nueve búferes de
// almacenamiento, más de lo que garantiza el mínimo de WebGPU.
if ((limites.maxStorageBuffersPerShaderStage || 8) < 2 * n + 1) return null;
const g = prepara(tipo, k, tokens, ws, filas);
if (!g) return null;
const forma = gemv2Forma({ tipo, filas, k, T: tokens, nm: 1,
maxCompartida: limites.maxComputeWorkgroupStorageSize || 16384 });
const o = { tipo, R: forma.R, NSG: forma.NSG, T: tokens, modo: 'secciones', n, u4x8: u4x8(), cola: g.cola };
const p = await pipeline(o);
if (!p) return null;
const ys = filas.map((f) => ctx.alloc(f * tokens * 4, 'matmul.y'));
const fin = [];
let acum = 0;
for (const f of filas) { acum += f / forma.R; fin.push(acum); }
const params = ctx.uniform([gemv2Params({ k, bpr: g.bpr, pasos: g.pasos, filas,
esc: g.esc, fin })]);
const [dx, dy] = dims(acum);
await despacha(`matmul:${tipo}:secciones:r${filas.join('+')}b${g.bpr}`, p, [...ws, xBuf, ...ys, params], dx, dy, 1);
hechos.secciones++;
return ys;
},
// Diagnóstico para los bancos; el forward no lo usa.
conMarca: !!compruebaR, // ¿comprueba la marca de los reordenados?
despachados: () => ({ ...hechos }), // despachos hechos por operación
rechazados: () => [...rechazadas.keys()], // claves que el compilador rechazó
};
}
|