Spaces:
Running
Running
Download js/engine/ops.topk.js from UtopiaIA/elffuss-code: direct link, hf CLI and curl.
- Browser
- Download file 9.53 kB
-
https://huggingface.co/spaces/UtopiaIA/elffuss-code/resolve/main/js/engine/ops.topk.js
- Command line
-
hf download hf://spaces/UtopiaIA/elffuss-code/js/engine/ops.topk.js
-
curl -L -o ops.topk.js https://huggingface.co/spaces/UtopiaIA/elffuss-code/resolve/main/js/engine/ops.topk.js
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 { /* — */ } } | |
| }, | |
| }; | |
| } | |