File size: 17,149 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
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
// SPDX-License-Identifier: Apache-2.0
// Copyright (c) 2026 UtopiaIA
// Elffuss Runtime · despacho del GEMM del prompt con descuantización dentro (GEMM2).
// ─────────────────────────────────────────────────────────────────────────────
// Lo llama `quant.matmul` (ops.js) al principio, y SOLO si `__ELFFUSS_GEMM2 ===
// true`: con el interruptor apagado no se ejecuta ni una línea de aquí y el motor
// es el de siempre. Si el plan no aplica a la forma pedida devuelve null y
// `quant.matmul` sigue por su camino de siempre.
//
// Interruptores (todos APAGADOS por defecto; los sub-interruptores solo cuentan
// con el principal puesto):
//   __ELFFUSS_GEMM2         el GEMM exacto sustituye a DRIFT: mismos bits, sin
//                           el búfer de pesos f16 ni su despacho.
//   __ELFFUSS_GEMM2_TESELA  la tesela con memoria compartida en vez del exacto
//                           (tolerancia declarada, no bit a bit).
//   __ELFFUSS_GEMM2_ACC16   dentro de la tesela, suma en f16 por tesela de k.
//   __ELFFUSS_GEMM2_FMA32   el kernel de la tesela de DRIFT con la aritmética de
//                           la tesela (FMA f32 por producto): no bit a bit, misma
//                           tolerancia que la tesela; sin efecto con TESELA puesto.
//   __ELFFUSS_GEMM2_PARTE   formas largas y estrechas (k > filas, como ffn_down):
//                           bloques de 8 filas en el exacto (sigue exacto) o k
//                           partida en la tesela (tolerancia de la tesela).
//   __ELFFUSS_GEMM2_Q4      Q4_0/Q4_0R por el GEMM teselado de 4 a 63 tokens.
//   __ELFFUSS_GEMM2_COLA    última capa del prompt solo para el último token
//                           (lo usa model.js a través de `cola`).
//   __ELFFUSS_GEMM2_FORMA   {BM, BN, TM, TN, doble} para barrer la tesela.
//   __ELFFUSS_GEMM2_TROZO   {nb, doble, tpw, tpt} para barrer el exacto. `tpw` y
//                           `tpt` cambian SOLO su tesela (la de DRIFT sigue con
//                           sus `__ELFFUSS_DRIFT_TPW/TPT`); sigue siendo exacto
//                           con cualquier forma, porque cada salida suma lo mismo
//                           en el mismo orden. Más hilos por grupo reparten la
//                           descuantización de cada trozo entre más tokens.
// Todo lo que cambia el WGSL entra en la clave del pipeline: si no, un A/B
// mediría dos veces el mismo shader compilado.
//
// Licencia: código propio, Apache-2.0 (ver SPDX arriba y LICENSE). Sin dependencias externas.
import {
  GEMM2_TIPOS, formaTesela, gemm2ExactoShader, gemm2TeselaShader,
  gemm2SumaShader, TIPOS_Q4_TESELA, gemmQ4Shader,
} from './kernels.gemm2.wgsl.js';
import { f32aF16Shader, DRIFT_TPT, DRIFT_TPW } from './kernels.drift.wgsl.js';
import { TK_POR_DEFECTO } from './kernels.gemm.wgsl.js';
import { AXIS } from './kernels.wgsl.js';
import { TIPOS_R, escalasDesde } from './kernels.bloques.wgsl.js';
import { compruebaBufferR } from './repack.js';

// Una sola lectura de los interruptores por decisión. Los del camino al que
// sustituye (DRIFT_DESDE, DRIFT, GEMM, la forma de DRIFT) se leen con la MISMA
// expresión que en ops.js: GEMM2 elige lo mismo que elegiría él, no un rango
// propio que se desincronice.
export function leeInterruptores(g = globalThis) {
  return {
    gemm2: g.__ELFFUSS_GEMM2 === true,
    tesela: g.__ELFFUSS_GEMM2_TESELA === true,
    acc16: g.__ELFFUSS_GEMM2_ACC16 === true,
    fma32: g.__ELFFUSS_GEMM2_FMA32 === true,
    parte: g.__ELFFUSS_GEMM2_PARTE === true,
    q4: g.__ELFFUSS_GEMM2_Q4 === true,
    forma: g.__ELFFUSS_GEMM2_FORMA || null,
    trozo: g.__ELFFUSS_GEMM2_TROZO || {},
    driftDesde: g.__ELFFUSS_DRIFT_DESDE || 64,
    driftApagado: g.__ELFFUSS_DRIFT === false,
    gemmApagado: g.__ELFFUSS_GEMM === false,
    tpt: g.__ELFFUSS_DRIFT_TPT || DRIFT_TPT,
    tpw: g.__ELFFUSS_DRIFT_TPW || DRIFT_TPW,
    formaGemm: g.__ELFFUSS_GEMM_FORMA || {},
    pad: g.__ELFFUSS_PAD_TESELA === 1 ? 1 : 0,
    llano: g.__ELFFUSS_GEMM_PLANO === true ? 1 : 0,
  };
}

// La tesela estrecha del GEMM teselado según el lote: la MISMA tabla que el
// camino GEMM de `quant.matmul` (ops.js). Está copiada a propósito, para no
// tocar aquel bloque; si allí cambia, aquí hay que cambiarlo también.
const anchoTesela = (n) => (n <= 4 ? { TM: 2, TN: 1, WGM: 16, WGN: 4 }
  : n <= 8 ? { TM: 2, TN: 1, WGM: 8, WGN: 8 }
  : n <= 16 ? { TM: 2, TN: 2, WGM: 8, WGN: 8 }
  : { TM: 2, TN: 4, WGM: 8, WGN: 8 });

// Qué camino toma un matmul. Función pura (sin WebGPU) para poder probarla en Node.
// Devuelve null si GEMM2 no aplica y `quant.matmul` debe seguir como siempre.
export function planGemm2({ type, rows, k, tokens, f16 = true, maxCompartida = 32768, sw = leeInterruptores() }) {
  if (!sw.gemm2 || !GEMM2_TIPOS.has(type) || k % 32 !== 0 || !(tokens >= 1)) return null;
  const bpr = k / 32;
  // El rango de DRIFT con su mismo predicado (ops.js): lote largo, f16 en el
  // dispositivo, filas múltiplo de 16. GEMM2 lo sustituye; no lo amplía.
  if (tokens >= sw.driftDesde && !sw.driftApagado && f16 && rows % 16 === 0) {
    // Forma «larga y estrecha»: k mayor que las filas. Con la tesela de siempre
    // salen pocos grupos con bucles largos (ffn_down: la cuarta parte de grupos
    // que gate/up con bucles cuatro veces más largos).
    const larga = sw.parte && k > rows;
    if (sw.tesela) {
      const F = formaTesela(sw.forma || {});
      if (rows % F.BM === 0 && F.HILOS <= 256 && F.compartida <= maxCompartida) {
        // k partida en tantas partes como veces cabe `rows` en k (así cada grupo
        // hace una cantidad de trabajo parecida a la de las formas anchas), con
        // al menos cuatro teselas de k por parte.
        const partes = larga ? Math.max(1, Math.min(8, Math.ceil(k / rows), Math.floor(bpr / 4))) : 1;
        return { via: 'tesela', type, bpr, forma: F, acc16: sw.acc16, partes };
      }
    }
    // Dos bloques por trozo si la fila lo permite (menos barreras por k) y un
    // solo trozo en memoria compartida (ver `gemm2ExactoShader`). Un trozo de 2
    // con un número impar de bloques dejaría el último sin calcular: se baja a 1.
    const nb = (sw.trozo.nb === 1 || bpr % 2 !== 0) ? 1 : 2;
    return {
      via: 'exacto', type, bpr, tpt: (sw.trozo.tpt | 0) || sw.tpt, tpw: (sw.trozo.tpw | 0) || sw.tpw,
      filas: larga ? 8 : 16, nb, doble: sw.trozo.doble === true, fma32: sw.fma32,
    };
  }
  // Q4_0/Q4_0R por el GEMM teselado, con las mismas reglas que Q8_0 allí.
  if (sw.q4 && TIPOS_Q4_TESELA.has(type) && tokens >= 4 && !sw.gemmApagado) {
    const Fg = sw.formaGemm;
    const TK = (Fg.TK | 0) || TK_POR_DEFECTO;
    if (TK % 4 !== 0 || 32 % TK !== 0 || k % TK !== 0) {
      // Igual que ops.js: un TK pedido a mano que no vale LANZA; nunca se mide
      // otro camino con la etiqueta de este.
      if (Fg.TK) throw new Error(`GEMM: TK=${Fg.TK} no vale para «${type}» (bloque 32, k=${k})`);
      return null;
    }
    const A = anchoTesela(tokens);
    const G = { TM: Fg.TM || A.TM, TN: Fg.TN || A.TN, WGM: Fg.WGM || A.WGM, WGN: Fg.WGN || A.WGN, TK, maxCompartida };
    return { via: 'q4', type, bpr, G, pad: sw.pad, llano: sw.llano };
  }
  return null;
}

// Clave del pipeline de cada plan: TODO lo que cambia el WGSL generado.
export function clavePlan(pl) {
  if (pl.via === 'exacto') return `gemm2x_${pl.type}_${pl.tpt}_${pl.tpw}_f${pl.filas}_n${pl.nb}_d${pl.doble ? 1 : 0}_m${pl.fma32 ? 1 : 0}`;
  if (pl.via === 'tesela') {
    const F = pl.forma;
    return `gemm2t_${pl.type}_${F.BM}_${F.BN}_${F.TM}_${F.TN}_d${F.doble ? 1 : 0}_a${pl.acc16 ? 1 : 0}_p${pl.partes}`;
  }
  const G = pl.G;
  return `gemm_${pl.type}_${G.TM}_${G.TN}_${G.WGM}_${G.WGN}_k${G.TK}_p${pl.pad}_f${pl.llano}_g2q4`;
}

const rowsToDims = (rows) => (rows <= AXIS ? [rows, 1] : [AXIS, Math.ceil(rows / AXIS)]);

// `dispatch`, `dispatchXYZ` y `dispatchN` son los de ops.js (se pasan para que
// estos despachos vayan por el mismo sitio que todos: lote, perfilado y scopes).
export function createGemm2Ops(ctx, { dispatch, dispatchXYZ, dispatchN }) {
  const device = ctx.device;
  const get = ctx.pipeline;
  const conF16 = () => !!device.features?.has('shader-f16');
  const maxComp = () => device.limits?.maxComputeWorkgroupStorageSize || 16384;
  const plan = (type, rows, k, tokens) =>
    planGemm2({ type, rows, k, tokens, f16: conF16(), maxCompartida: maxComp() });

  // ── x → f16, con memoria ───────────────────────────────────────────────────
  // La misma activación entra en varios matmuls seguidos (la salida de la norma
  // va a q, k, v y la puerta; la del FFN a gate y up) y DRIFT la convertía otra
  // vez en cada uno. La conversión es la misma operación sobre los mismos datos,
  // así que reutilizarla no cambia ni un bit.
  //
  // La clave es la MARCA DE REPARTO (`ctx.marcaDe`), no el búfer: un búfer
  // reciclado recibe marca nueva al volver a entregarse, así que no puede
  // confundirse con la activación que fue antes. Y el resultado guardado solo
  // vale mientras SU marca siga siendo la misma: si el pozo lo ha vuelto a
  // entregar, alguien lo está reescribiendo. Mientras no lo haya entregado, su
  // contenido sigue intacto aunque esté en el pozo (nadie lo ha pedido), y el
  // despacho que lo lee se graba antes que cualquiera que lo pida después.
  // Supuesto, el mismo que la memoria de rotación de model.js: nadie reescribe
  // en el sitio un búfer del pozo que ya entregó.
  //
  // Y solo se reutiliza una conversión que siga PRESTADA. Una que ya volvió al
  // pozo conserva su contenido mientras nadie la pida, pero el mismo matmul que
  // la reutiliza pide después su búfer de salida, y si mide lo mismo el pozo
  // puede entregarle justo ese: leer y escribir el mismo búfer en un despacho
  // no es válido, y sin los scopes de error eso no lanza, deja la salida sin
  // escribir. Con el flujo de model.js no ocurre (las conversiones se reutilizan
  // dentro de la misma capa, antes de reciclar), pero comprobarlo es barato y
  // solo corre en el prompt.
  const prestado = (buf) => ctx.scratch.some((e) => e.buf === buf);
  const memo = [];
  async function aF16(xBuf, tokens, k) {
    const n4 = tokens * k / 4;
    const marca = ctx.marcaDe?.get(xBuf);
    if (marca !== undefined) {
      for (let i = memo.length - 1; i >= 0; i--) {
        const m = memo[i];
        if (m.marca === marca && m.n4 === n4 && ctx.marcaDe.get(m.xh) === m.marcaXh && prestado(m.xh)) return m.xh;
      }
    }
    // El mismo shader y la misma clave que usa DRIFT: es la misma conversión.
    const px = await get('drift_x16', () => f32aF16Shader(256));
    const xh = ctx.alloc(n4 * 8, 'gemm2.x');
    await dispatchN(ctx, 'gemm2_x16', px, [xBuf, xh, ctx.uniform([new Uint32Array([n4, 0, 0, 0])])],
      Math.ceil(n4 / 256));
    if (marca !== undefined) {
      memo.push({ marca, n4, xh, marcaXh: ctx.marcaDe.get(xh) });
      if (memo.length > 4) memo.shift();
    }
    return xh;
  }

  // Bloques del TENSOR que guarda `wBuf`. En los reordenados (Q8_0R, Q4_0R) 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 se pide con el
  // vocabulario del tokenizador): el `rows·bpr` de la llamada no sirve. Sale de
  // la marca del cargador, con la MISMA comprobación que hace el camino de
  // siempre (`compruebaBufferR`: marca, tipo y que la llamada no se salga del
  // tensor), y lanza igual que él: el interruptor no cambia qué búferes se
  // aceptan. En los formatos del GGUF no hay región de escalas aparte.
  const bloquesTensor = (type, wBuf, rows, bpr) => (TIPOS_R.has(type)
    ? compruebaBufferR(type, wBuf, { bloques: rows * bpr }, 'gemm2')
    : rows * bpr);
  // La palabra donde empiezan las escalas: la de `escalasDesde` con el N del
  // tensor; 0 en los del GGUF (el kernel no la lee).
  const baseEscalasDe = (type, n) => (TIPOS_R.has(type) ? escalasDesde(type, n) : 0);

  async function exacto(pl, wBuf, xh, rows, k, tokens, baseEsc) {
    const { type, tpt, tpw, filas, nb, doble, fma32, bpr } = pl;
    const pg = await get(clavePlan(pl), () => gemm2ExactoShader({ type, tpt, tpw, filas, nb, doble, fma32 }));
    const y = ctx.alloc(rows * tokens * 4, 'matmul.y');
    const og = rows / filas;
    await dispatchXYZ(ctx, `gemm2x:${type}:r${rows}b${bpr}`, pg,
      [wBuf, xh, y, ctx.uniform([new Uint32Array([k / 4, rows, tokens, bpr, baseEsc, 0, 0, 0])])],
      Math.ceil(tokens / (tpw * tpt)), Math.min(og, 65535), Math.ceil(og / 65535));
    return y;
  }

  async function tesela(pl, wBuf, xh, rows, k, tokens, baseEsc) {
    const { type, forma: F, acc16, partes, bpr } = pl;
    const pg = await get(clavePlan(pl), () => gemm2TeselaShader({
      type, BM: F.BM, BN: F.BN, TM: F.TM, TN: F.TN, doble: F.doble, acc16, partes, maxCompartida: maxComp(),
    }));
    const n = rows * tokens;
    const dst = ctx.alloc(n * 4 * partes, partes > 1 ? 'gemm2.partes' : 'matmul.y');
    const params = ctx.uniform([new Uint32Array([rows, tokens, bpr, k / 4, baseEsc, 0, 0, 0])]);
    // Teselas de TOKENS en el eje x: los grupos que el dispositivo lanza seguidos
    // comparten la tesela de pesos, que se lee de memoria una vez y el resto de
    // veces sale de la caché.
    await dispatchXYZ(ctx, `gemm2t:${type}:r${rows}b${bpr}`, pg, [wBuf, xh, dst, params],
      Math.ceil(tokens / F.BN), rows / F.BM, partes);
    if (partes === 1) return dst;
    const ps = await get(`gemm2s_${partes}`, () => gemm2SumaShader(partes, 256));
    const y = ctx.alloc(n * 4, 'matmul.y');
    const n4 = n / 4;
    await dispatchN(ctx, `gemm2s:r${rows}`, ps, [dst, y, ctx.uniform([new Uint32Array([n4, 0, 0, 0])])],
      Math.ceil(n4 / 256));
    return y;
  }

  async function q4(pl, wBuf, xBuf, rows, k, tokens, nTensor) {
    const { type, G, bpr } = pl;
    const pg = await get(clavePlan(pl), () => gemmQ4Shader(type, G));
    const y = ctx.alloc(rows * tokens * 4, 'matmul.y');
    // `nBlocks` solo lo lee la tirada de Q4_0R, y como base de sus escalas
    // (4 · nBlocks): tienen que ser los bloques del TENSOR, no los de la llamada.
    const params = ctx.uniform([new Uint32Array([nTensor, bpr, rows, k, tokens, 0, 0, 0])]);
    const [gx, gy] = rowsToDims(Math.ceil(rows / (G.WGM * G.TM)));
    await dispatch(ctx, `gemm:${type}:r${rows}b${bpr}`, pg, [wBuf, xBuf, y, params],
      gx, gy, Math.ceil(tokens / (G.WGN * G.TN)));
    return y;
  }

  return {
    // Diagnóstico: qué haría con esta forma (null = el camino de siempre).
    plan,
    // Para los bancos: vacía la memoria de x→f16, de modo que una medida no se
    // ahorre conversiones que en la otra rama sí se pagan.
    olvida() { memo.length = 0; },

    async matmul(type, wBuf, xBuf, rows, k, tokens) {
      // El decode (un token) nunca es de GEMM2 salvo que alguien baje
      // DRIFT_DESDE a mano: se sale aquí sin leer el resto de interruptores, que
      // en el bucle de decode serían cientos de lecturas por token para nada.
      if (tokens < 4 && tokens < (globalThis.__ELFFUSS_DRIFT_DESDE || 64)) return null;
      const pl = plan(type, rows, k, tokens);
      if (!pl) return null;
      const n = bloquesTensor(type, wBuf, rows, pl.bpr);
      if (pl.via === 'q4') return await q4(pl, wBuf, xBuf, rows, k, tokens, n);
      const xh = await aF16(xBuf, tokens, k);
      const baseEsc = baseEscalasDe(type, n);
      return pl.via === 'tesela'
        ? await tesela(pl, wBuf, xh, rows, k, tokens, baseEsc)
        : await exacto(pl, wBuf, xh, rows, k, tokens, baseEsc);
    },

    // ── La cola de la última capa (interruptor GEMM2_COLA, ver model.js) ──────
    // `x1` es UNA fila: la del último token de un lote de `lote` tokens. Se
    // calcula con el MISMO plan (mismo shader, misma forma, mismas partes de k)
    // que habría tocado al lote entero, despachado para un solo token. En los dos
    // kernels de aquí la salida de un token solo depende de su fila de x y de los
    // pesos, sumados en el mismo orden, así que da los mismos bits que su fila
    // dentro del lote. Con otro camino (el matvec de un token suma en otro
    // orden) eso ya no se cumple: por eso `reproducible` dice antes si se puede.
    reproducible(type, rows, k, lote) {
      const pl = plan(type, rows, k, lote);
      return !!pl && (pl.via === 'exacto' || pl.via === 'tesela');
    },
    async cola(type, wBuf, x1, rows, k, lote) {
      const pl = plan(type, rows, k, lote);
      if (!pl || (pl.via !== 'exacto' && pl.via !== 'tesela')) return null;
      const baseEsc = baseEscalasDe(type, bloquesTensor(type, wBuf, rows, pl.bpr));
      const xh = await aF16(x1, 1, k);
      return pl.via === 'tesela'
        ? await tesela(pl, wBuf, xh, rows, k, 1, baseEsc)
        : await exacto(pl, wBuf, xh, rows, k, 1, baseEsc);
    },
  };
}