Spaces:
Running
Running
File size: 9,532 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 | // 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 { /* — */ } }
},
};
}
|