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 { /* — */ } }
    },
  };
}