elffuss-code / js /engine /ops.topk.js
KikoCis's picture
Sync with code.elffuss.com (fc5b0ba): LFM3 on our own engine, installable app, VS Code extensions, new look; README refreshed
4bd8362 verified
Raw History Blame Contribute Delete
9.53 kB
// SPDX-License-Identifier: Apache-2.0
// Copyright (c) 2026 UtopiaIA
// Elffuss Runtime · muestrear trayendo solo los candidatos (`__ELFFUSS_TOPK_GPU`).
// ─────────────────────────────────────────────────────────────────────────────
// El bucle de generación leía TODOS los logits en cada token: un buffer de
// lectura nuevo, tres ámbitos de error, el mapeo, y después `sample()` recorría
// el vocabulario entero en JavaScript. Aquí el dispositivo elige los
// candidatos (`kernels.topk.wgsl.js`), se lee un buffer pequeño y `sample()` corre sobre
// ese puñado (`topk.js`), con el MISMO token como resultado.
//
// Va DESPUÉS del forward, en su propio envío —el mismo número de envíos que la
// lectura de siempre, que también llevaba el suyo— y antes de reciclar: el
// buffer de logits sigue vivo hasta que se ha leído. Todo lo que puede salir mal
// acaba en el camino de siempre: configuración sin tope (null del plan), un
// aviso de los kernels (NaN, algo que no cupo) o una respuesta incoherente.
//
// Sin ámbitos de error por token: solo la PRIMERA vez se envuelve en uno, que es
// cuando un binding mal puesto se descubre, y al crear los bind groups de un
// buffer de logits nuevo (pocas veces por sesión). Si eso falla, o el shader no
// compila en este navegador, se apaga para el resto de la sesión y se avisa por
// consola: el camino de siempre sigue funcionando. Y como un envío inválido sin
// ámbito no lanza —deja en el buffer de lectura lo de una llamada anterior—,
// cada llamada lleva su número de serie y la cabecera tiene que devolverlo: si
// no, también se apaga, y ese token sale por el camino de siempre.
//
// Licencia: código propio, Apache-2.0 (ver SPDX arriba y LICENSE). Sin dependencias externas.
import { guard } from './device.js';
import {
topkTrozosShader, topkFinalShader, TOPK_POR_HILO, TOPK_OUTCAP, TOPK_CAP, TOPK_P_MAX, TOPK_N_MAX,
TOPK_CABECERA, topkBytesSalida, topkBytesTrozos, topkTrozos,
} from './kernels.topk.wgsl.js';
import { planTopK, muestraCandidatos, leeSalidaTopK } from './topk.js';
const ahora = () => (typeof performance !== 'undefined' ? performance.now() : Date.now());
// Cuentas de TODAS las instancias de este módulo. Las lee una prueba que solo
// ve el proveedor desde fuera: sin ellas, «sale el mismo texto con el
// interruptor puesto» no distingue «los kernels eligieron bien» de «se cayó al
// camino de siempre», que da el mismo texto sin probar nada.
export const estadisticasTopK = { gpu: 0, respaldo: 0, motivos: {} };
export function createTopKGPU(device, ctx) {
const bytesSalida = topkBytesSalida();
const bufIds = device.createBuffer({ label: 'topk.ids', size: TOPK_P_MAX * 4,
usage: GPUBufferUsage.STORAGE | GPUBufferUsage.COPY_DST });
const bufPar = device.createBuffer({ label: 'topk.params', size: 32,
usage: GPUBufferUsage.UNIFORM | GPUBufferUsage.COPY_DST });
const bufOut = device.createBuffer({ label: 'topk.out', size: bytesSalida,
usage: GPUBufferUsage.STORAGE | GPUBufferUsage.COPY_SRC });
// Dos buffers de lectura que se turnan: mientras uno se mapea el otro queda
// libre para el token siguiente. Se crean una vez, no uno por token. `ocupada`
// marca el que está en uso desde que se elige hasta que se desmapea: el estado
// de mapeo solo cambia al llamar a mapAsync, y entre la copia y esa llamada
// puede haber una espera (la del ámbito de error de la primera vez).
const lectura = [null, null], ocupada = [false, false];
let turno = 0;
let serie = 0;
let bufCand = null, trozosCand = 0;
let p1 = null, p2 = null;
// Bind groups por buffer de logits: el pozo entrega pocos distintos (con
// `__ELFFUSS_PLAN`, el mismo en cada token de generación).
let grupos = new Map();
let validado = false, roto = false;
const params = new Uint32Array(8);
const stats = { gpu: 0, respaldo: 0, motivos: {} };
const respaldo = (motivo) => {
for (const s of [stats, estadisticasTopK]) {
s.respaldo++;
s.motivos[motivo] = (s.motivos[motivo] || 0) + 1;
}
return null;
};
const apaga = (motivo, e) => {
roto = true;
console.warn(`[engine] top-k en el dispositivo desactivado (${motivo}): ${e?.message || e}`);
return respaldo(motivo);
};
const nuevaLectura = () => device.createBuffer({
label: 'topk.lectura', size: bytesSalida, usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.MAP_READ,
});
// Los dos bind groups de un buffer de logits, creados con ámbito de error: un
// bind group inválido no lanza, y el envío que lo use no se ejecutaría.
async function gruposDe(logits) {
let bg = grupos.get(logits);
if (bg) return bg;
if (grupos.size >= 8) grupos = new Map();
const ent = (bufs) => bufs.map((buffer, binding) => ({ binding, resource: { buffer } }));
bg = await guard(device, 'topk/bind', async () => [
device.createBindGroup({ layout: p1.getBindGroupLayout(0), entries: ent([logits, bufCand, bufPar]) }),
device.createBindGroup({ layout: p2.getBindGroupLayout(0), entries: ent([logits, bufCand, bufIds, bufOut, bufPar]) }),
]);
grupos.set(logits, bg);
return bg;
}
// Los candidatos de UN vector de logits: `base` es el primer logit (en
// elementos) del token que se muestrea. Devuelve null si hay que leer entero.
async function candidatos(logits, base, vocab, plan) {
if (roto) return respaldo('apagado');
const G = topkTrozos(vocab);
if (vocab >= TOPK_N_MAX || G > 65535) return respaldo('vocabulario');
if (!p1) {
try {
p1 = await ctx.pipeline(`topk_trozos_${TOPK_POR_HILO}_${TOPK_OUTCAP}`, () => topkTrozosShader());
p2 = await ctx.pipeline(`topk_final_${TOPK_OUTCAP}_${TOPK_CAP}_${TOPK_P_MAX}_${TOPK_CABECERA}`, () => topkFinalShader());
} catch (e) { p1 = null; return apaga('compilación', e); }
}
if (!bufCand || trozosCand < G) {
bufCand?.destroy();
bufCand = device.createBuffer({ label: 'topk.trozos', size: topkBytesTrozos(G), usage: GPUBufferUsage.STORAGE });
trozosCand = G;
grupos = new Map();
}
let bg;
try { bg = await gruposDe(logits); } catch (e) { return apaga('validación', e); }
let k = turno; turno ^= 1;
if (ocupada[k]) k ^= 1;
let staging, temporal = false;
if (ocupada[k]) { staging = nuevaLectura(); temporal = true; } // las dos en uso
else {
if (!lectura[k] || lectura[k].mapState !== 'unmapped') lectura[k] = nuevaLectura();
staging = lectura[k];
ocupada[k] = true;
}
serie = (serie + 1) >>> 0 || 1; // nunca 0: un buffer recién creado lee 0
const esta = serie;
const graba = () => {
params[0] = vocab; params[1] = base; params[2] = plan.M; params[3] = G; params[4] = plan.S.length;
params[5] = esta;
device.queue.writeBuffer(bufPar, 0, params);
if (plan.S.length) device.queue.writeBuffer(bufIds, 0, plan.S);
const enc = device.createCommandEncoder({ label: 'topk' });
const pass = enc.beginComputePass({ label: 'topk' });
pass.setPipeline(p1); pass.setBindGroup(0, bg[0]); pass.dispatchWorkgroups(G);
pass.setPipeline(p2); pass.setBindGroup(0, bg[1]); pass.dispatchWorkgroups(1);
pass.end();
enc.copyBufferToBuffer(bufOut, 0, staging, 0, bytesSalida);
device.queue.submit([enc.finish()]);
};
try {
if (!validado) {
try { await guard(device, 'topk', async () => graba()); }
catch (e) { grupos = new Map(); return apaga('validación', e); }
validado = true;
} else {
graba();
}
await staging.mapAsync(GPUMapMode.READ, 0, bytesSalida);
const u = new Uint32Array(staging.getMappedRange(0, bytesSalida).slice(0));
staging.unmap();
const r = leeSalidaTopK(u, plan, G, esta);
if (r.motivo === 'serie') return apaga('serie', new Error('lo leído no es de esta llamada: el envío no se ejecutó'));
return r.motivo ? respaldo(r.motivo) : r;
} catch (e) {
// Tras un fallo no se sabe en qué estado queda el buffer de lectura: fuera.
if (!temporal) { try { staging.destroy(); } catch { /* — */ } lectura[k] = null; }
throw e;
} finally {
if (temporal) staging.destroy();
else ocupada[k] = false;
}
}
return {
stats,
candidatos,
// El paso completo: plan, candidatos, `sample()` sobre el puñado. Devuelve
// { id, msLectura, msMuestreo } o null, y entonces quien llama lee el
// vector entero como siempre. `opts` es lo que se le pasaría a `sample()`
// SIN `previos`, que llega en dos mitades (el prompt y lo ya emitido).
async muestrea(logits, base, vocab, opts, previosA, previosB) {
const t0 = ahora();
const plan = planTopK(vocab, opts, previosA, previosB);
if (!plan) return respaldo('muestreo sin tope');
const c = await candidatos(logits, base, vocab, plan);
if (!c) return null;
const t1 = ahora();
const id = muestraCandidatos(plan, c.ids, c.bits, c.bitsS, opts);
if (id === null) return respaldo('incoherente');
stats.gpu++; estadisticasTopK.gpu++;
return { id, msLectura: t1 - t0, msMuestreo: ahora() - t1 };
},
destroy() {
for (const b of [bufIds, bufPar, bufOut, bufCand, ...lectura]) { try { b?.destroy(); } catch { /* — */ } }
},
};
}