Spaces:
Running
Running
File size: 74,067 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 306 307 308 309 310 311 312 313 314 315 316 317 318 319 320 321 322 323 324 325 326 327 328 329 330 331 332 333 334 335 336 337 338 339 340 341 342 343 344 345 346 347 348 349 350 351 352 353 354 355 356 357 358 359 360 361 362 363 364 365 366 367 368 369 370 371 372 373 374 375 376 377 378 379 380 381 382 383 384 385 386 387 388 389 390 391 392 393 394 395 396 397 398 399 400 401 402 403 404 405 406 407 408 409 410 411 412 413 414 415 416 417 418 419 420 421 422 423 424 425 426 427 428 429 430 431 432 433 434 435 436 437 438 439 440 441 442 443 444 445 446 447 448 449 450 451 452 453 454 455 456 457 458 459 460 461 462 463 464 465 466 467 468 469 470 471 472 473 474 475 476 477 478 479 480 481 482 483 484 485 486 487 488 489 490 491 492 493 494 495 496 497 498 499 500 501 502 503 504 505 506 507 508 509 510 511 512 513 514 515 516 517 518 519 520 521 522 523 524 525 526 527 528 529 530 531 532 533 534 535 536 537 538 539 540 541 542 543 544 545 546 547 548 549 550 551 552 553 554 555 556 557 558 559 560 561 562 563 564 565 566 567 568 569 570 571 572 573 574 575 576 577 578 579 580 581 582 583 584 585 586 587 588 589 590 591 592 593 594 595 596 597 598 599 600 601 602 603 604 605 606 607 608 609 610 611 612 613 614 615 616 617 618 619 620 621 622 623 624 625 626 627 628 629 630 631 632 633 634 635 636 637 638 639 640 641 642 643 644 645 646 647 648 649 650 651 652 653 654 655 656 657 658 659 660 661 662 663 664 665 666 667 668 669 670 671 672 673 674 675 676 677 678 679 680 681 682 683 684 685 686 687 688 689 690 691 692 693 694 695 696 697 698 699 700 701 702 703 704 705 706 707 708 709 710 711 712 713 714 715 716 717 718 719 720 721 722 723 724 725 726 727 728 729 730 731 732 733 734 735 736 737 738 739 740 741 742 743 744 745 746 747 748 749 750 751 752 753 754 755 756 757 758 759 760 761 762 763 764 765 766 767 768 769 770 771 772 773 774 775 776 777 778 779 780 781 782 783 784 785 786 787 788 789 790 791 792 793 794 795 796 797 798 799 800 801 802 803 804 805 806 807 808 809 810 811 812 813 814 815 816 817 818 819 820 821 822 823 824 825 826 827 828 829 830 831 832 833 834 835 836 837 838 839 840 841 842 843 844 845 846 847 848 849 850 851 852 853 854 855 856 857 858 859 860 861 862 863 864 865 866 867 868 869 870 871 872 873 874 875 876 877 878 879 880 881 882 883 884 885 886 887 888 889 890 891 892 893 894 895 896 897 898 899 900 901 902 903 904 905 906 907 908 909 910 911 912 913 914 915 916 917 918 919 920 921 922 923 924 925 926 927 928 929 930 931 932 933 934 935 936 937 938 939 940 941 942 943 944 945 946 947 948 949 950 951 952 953 954 955 956 957 958 959 960 961 962 963 964 965 966 967 968 969 970 971 972 973 974 975 976 977 978 979 980 981 982 983 984 985 986 987 988 989 990 991 992 993 994 995 996 997 998 999 1000 1001 1002 1003 1004 1005 1006 1007 1008 1009 1010 1011 1012 1013 1014 1015 1016 1017 1018 1019 1020 1021 1022 1023 1024 1025 1026 1027 1028 1029 1030 1031 1032 1033 1034 1035 1036 1037 1038 1039 1040 1041 1042 1043 1044 1045 1046 1047 1048 1049 1050 1051 1052 1053 1054 1055 1056 1057 1058 1059 1060 1061 1062 1063 1064 1065 1066 1067 1068 1069 1070 1071 1072 1073 1074 1075 1076 1077 1078 1079 1080 1081 1082 1083 1084 1085 1086 1087 1088 1089 1090 1091 1092 1093 1094 1095 1096 1097 1098 1099 1100 1101 1102 1103 1104 1105 1106 1107 1108 1109 1110 1111 1112 1113 1114 1115 1116 1117 1118 1119 1120 1121 1122 1123 1124 1125 1126 1127 1128 1129 1130 1131 1132 1133 1134 1135 1136 1137 1138 1139 1140 1141 1142 1143 1144 1145 1146 1147 1148 1149 1150 1151 1152 1153 1154 1155 1156 1157 1158 1159 1160 1161 1162 1163 1164 1165 1166 1167 1168 1169 1170 1171 1172 1173 1174 1175 1176 1177 1178 1179 1180 1181 1182 1183 1184 1185 1186 1187 1188 1189 1190 1191 1192 1193 1194 1195 1196 1197 1198 1199 1200 1201 1202 1203 1204 1205 1206 1207 1208 1209 1210 1211 1212 1213 1214 1215 1216 1217 1218 1219 1220 1221 1222 1223 1224 1225 1226 1227 1228 1229 1230 1231 1232 1233 1234 1235 1236 1237 1238 1239 1240 1241 1242 1243 1244 1245 1246 1247 1248 1249 1250 1251 1252 1253 1254 1255 1256 1257 1258 1259 1260 1261 1262 1263 1264 1265 1266 1267 1268 1269 1270 1271 1272 1273 1274 1275 1276 1277 1278 1279 1280 1281 1282 1283 1284 1285 1286 1287 1288 1289 1290 | // SPDX-License-Identifier: Apache-2.0
// Copyright (c) 2026 UtopiaIA
// Elffuss Runtime · el modelo: carga de pesos y forward de qwen35.
// ─────────────────────────────────────────────────────────────────────────────
// Aquí se encadenan las piezas que ya están verificadas una a una. Esa
// verificación por piezas NO garantiza que el conjunto funcione: puede fallar el
// orden, el layout que espera la siguiente operación, o un residual sumado en el
// sitio equivocado. Por eso el forward está escrito para poder pararse en
// cualquier capa y comparar contra el volcado de un forward real.
//
// Dos tipos de bloque, y el reparto sale del propio fichero:
// · SSM (18 de 24 en el 0.8B, 48 de 65 en el 27B): qkv fusionado → conv causal
// → silu → q/k/v → delta net con estado recurrente → norm con puerta.
// · Atención (el resto): Q y puerta INTERCALADOS en el mismo tensor, QK-norm
// antes de RoPE, RoPE parcial, GQA, y la puerta multiplicando la salida.
// Los dos acaban igual: residual, norm, SwiGLU, residual.
//
// Licencia: código propio, Apache-2.0 (ver SPDX arriba y LICENSE). Sin dependencias externas.
import { parseGGUF } from './gguf.js';
import { leeRotacion } from './hadamard.js';
import { createOps, ROPE_NEOX, ROPE_NORM } from './ops.js';
import { createFlashOps } from './ops.flash.js';
import { readHParams, createState } from './state.js';
import {
copyIntoShader, convWindowShader, convSaveShader, siluShader, mulCabezaShader,
} from './kernels.model.wgsl.js';
import { QUANT_TYPES } from './kernels.wgsl.js';
// Q8_0/Q4_0 reordenados al subir (`__ELFFUSS_REPACK`, apagado por defecto).
import {
reordenActivo, tipoReordenado, comoReordenado, bloquesDe, reordena,
creaBufferR, subeReordenadoPorTrozos,
} from './repack.js';
import { createFusionOps, fusionActiva, puedeGatherNorma } from './ops.fusion.js';
const MiB = 1024 ** 2;
// Sube todos los tensores del fichero al dispositivo, uno por buffer.
// PENDIENTE consciente: un tensor por buffer exige que cada uno quepa en
// maxStorageBufferBindingSize. En escritorio el límite suele sobrar; en otros
// navegadores es mucho menor y la tabla de embeddings, de los tensores más
// grandes del modelo, puede no caber. Ahí hará falta que el matmul lea varios shards, que es
// trabajo del kernel, no de aquí. Se comprueba y se falla claro en vez de
// devolver ceros.
// El tamaño de lote del prefill. Es un `let` con gancho SOLO para poder
// medirlo: comparar dos valores exige cambiarlo en caliente, dentro de la misma
// sesión y alternando el orden. Editando el fichero entre pasadas, lo que se
// mueve la medida de una sesión a otra se mezcla con lo que se compara, y luego
// no hay forma de separar una cosa de la otra.
// 32 y no 128: medido, un lote más corto va algo MÁS rápido (menos posiciones
// enmascaradas que se calculan para tirar) y —lo que importa aquí— cada despacho
// dura menos, que es media defensa contra el cuelgue. La otra media es
// trocear el forward en varios command buffers (ver `cede`/`ctx.corta`).
let loteActual = 32;
// El reparto de la última carga. Lo consume una prueba interna y puede
// consumirlo la UI: es la espera más larga del producto.
let medidaCarga = null;
export function ultimaCarga() { return medidaCarga; }
// Cuántos tensores DEBÍAN subirse en la última carga. No es lo mismo que los del
// fichero: la cabeza MTP (`nextn_predict_layers`) no pertenece al forward y no
// se sube — en el modelo pequeño son 15 de 335. Un banco que compare contra
// `g.tensorCount` falla por construcción, que es lo que pasaba.
let subidosEsperados = 0;
export function ultimosSubidos() { return subidosEsperados; }
export function _setLote(n) { loteActual = Math.max(1, n | 0); }
export function _getLote() { return loteActual; }
// Cada cuántas capas se le da al dispositivo un respiro real para que el compositor
// del sistema pinte. Un forward del 27B son 64 capas; sin trocear, iban todas
// en un solo despacho larguísimo y la pantalla se quedaba sin pintar mientras
// tanto. Ver `ctx.corta`.
let cederCada = 2;
export function _setCeder(n) { cederCada = Math.max(1, n | 0); }
export function _getCeder() { return cederCada; }
// El respiro se cobra por RELOJ, no por capas. Lo que se persigue —que el
// compositor del sistema pinte— es un asunto de milisegundos de pared: da igual
// si en ese rato han pasado dos capas o cuarenta. Contándolo por capas se pagaba
// un frame entero cada dos capas aunque esas dos capas durasen medio frame, y
// como un rAF no se puede partir, el prefill acababa cuantizado al refresco del
// monitor: el reloj lo marcaba la pantalla y no el modelo.
// `cederCada` sigue siendo la granularidad mínima (solo se mira el reloj en esas
// capas) y esto es el límite de frecuencia. A 0 se recupera exactamente el
// comportamiento anterior, que es lo que usan los bancos para el A/B.
let cederMs = 100;
export function _setCederMs(ms) { cederMs = Math.max(0, +ms || 0); }
export function _getCederMs() { return cederMs; }
// Cada cuántas capas se CIERRA y envía el command buffer del prefill. Es otra
// cosa que `cederCada`: eso es cuándo se drena la cola y se cede un frame, esto
// es solo cuántos submits se parten. Va con gancho porque la nota de al lado
// afirmaba que trocear en cada capa es «GRATIS» y eso nadie lo había medido:
// una tanda de prefill aprovecha el ancho de banda de pesos 6,6 veces peor que
// un token suelto (medido con una prueba interna) y el prefill es justo el único
// camino que trocea. A 1 se recupera el comportamiento de siempre.
let cortaCada = 1;
export function _setCorta(n) { cortaCada = Math.max(1, n | 0); }
// Lo mismo para el DECODE (ver el bucle de capas). Con gancho para el A/B.
// En CADA capa por defecto. Medido en la misma sesión, tres rondas alternadas:
// ×1,30 en LFM3 y ×1,52 en Qwen3.5-0.8B. Un solo envío al
// final del token dejaba el dispositivo parado mientras la CPU grababa cientos
// de despachos; cortando, empieza con la primera capa. Cortar cada 2, 4 u 8
// capas queda en medio. No cambia la numérica: la cola respeta el orden.
let cortaDecode = globalThis.__ELFFUSS_CORTA_DECODE ?? 1;
export function _setCortaDecode(n) { cortaDecode = Math.max(0, n | 0); }
export function _getCorta() { return cortaCada; }
// Cede un frame al bucle de eventos: en el navegador deja que el compositor
// del sistema componga; fuera del DOM (tests) basta un turno de macrotarea.
//
// Y vuelve TAMBIÉN en cuanto se pide parar. No es un adorno: con la pestaña en
// segundo plano el navegador deja de dar frames —el rAF no llega hasta que la
// pestaña se vuelve a ver—, y un prefill esperando aquí no podría atender un
// «para» hasta entonces. Con la señal, parar no depende de que haya pantalla.
const nuevoFrame = (senal = null) => new Promise((r) => {
if (senal?.aborted) { r(); return; }
let id = null, hecho = false;
const fin = () => {
if (hecho) return;
hecho = true;
senal?.removeEventListener?.('abort', fin);
if (id !== null && typeof cancelAnimationFrame === 'function') cancelAnimationFrame(id);
r();
};
senal?.addEventListener?.('abort', fin, { once: true });
if (typeof requestAnimationFrame === 'function') id = requestAnimationFrame(() => fin());
else setTimeout(fin, 0);
});
// El error de «se pidió parar». Lleva el NOMBRE estándar, AbortError, para que
// quien llama lo distinga de un fallo de verdad sin leer el texto: un turno
// parado no es un modelo roto, y enseñarlo como «el modelo falló» sería mentir.
export function errorParado(mensaje = 'parado a petición') {
if (typeof DOMException === 'function') return new DOMException(mensaje, 'AbortError');
const e = new Error(mensaje);
e.name = 'AbortError';
return e;
}
export async function loadModel(ranged, device, opts = {}) {
const onProgress = opts.onProgress || (() => {});
const g = await parseGGUF(ranged);
const hp = readHParams(g.meta, g.tensors);
const ops = createOps(device, { debug: opts.debug !== false, subgroupSize: opts.subgroupSize || 0 });
// Atención fusionada (`__ELFFUSS_FLASH`): solo cierres, sin pipelines ni buffers hasta que se use.
ops.flash = createFlashOps(device, { ctx: ops.ctx, despacha: ops.dispatchAny, subgroupSize: opts.subgroupSize || 0 });
const limit = device.limits.maxStorageBufferBindingSize;
// Antes de mover un solo byte: que TODOS los tipos del fichero tengan kernel.
// Un tipo sin soporte descubierto a mitad del forward sería el modelo entero
// ya subido y un error tres capas más abajo; aquí es una línea que dice cuál.
const sinKernel = new Map();
for (const t of g.tensors) {
if (!QUANT_TYPES[t.typeName]) {
if (!sinKernel.has(t.typeName)) sinKernel.set(t.typeName, t.name);
}
}
if (sinKernel.size) {
throw new Error('el fichero trae tipos sin kernel: ' +
[...sinKernel].map(([k, n]) => `${k} (p.ej. «${n}»)`).join(', '));
}
// Las rejillas de los i-quants, subidas antes del primer forward.
await ops.quant.prepare(g.tensors.map(t => t.typeName));
const weights = new Map();
let uploaded = 0;
// LA CABEZA MTP NO SE SUBE. El fichero trae `nextn_predict_layers` bloques de
// mas que el forward: state.js hace `nLayers = block_count - nextn` y nunca los
// recorre. En el modelo grande son 15 tensores que se suben al dispositivo, se
// quedan ahi y no se ejecutan NUNCA: memoria y tiempo de subida tirados en
// cada sesion, sobre un modelo cuya carga ya es la espera mas larga del
// producto.
//
// Se deriva de los METADATOS y no de un «blk.64» escrito a mano: si algun dia
// se implementa la especulacion con esa cabeza, basta con quitar este filtro y
// los pesos vuelven. Y se descuentan tambien de `total`, porque si no la barra
// de progreso no llegaria nunca al 100%.
const kNextn = Object.keys(g.meta).find((k) => k.endsWith('.nextn_predict_layers'));
const kBloques = Object.keys(g.meta).find((k) => k.endsWith('.block_count'));
const nextn = (kNextn && g.meta[kNextn]) || 0;
const nBloques = (kBloques && g.meta[kBloques]) || 0;
const saltados = nextn > 0 && nBloques > 0
? new Set(Array.from({ length: nextn }, (_, i) => `blk.${nBloques - nextn + i}.`))
: new Set();
const sobra = (t) => [...saltados].some((pre) => t.name.startsWith(pre));
const suben = saltados.size ? g.tensors.filter((t) => !sobra(t)) : g.tensors;
const total = suben.reduce((n, t) => n + t.nBytes, 0);
// ── DÓNDE SE VA EL TIEMPO DE CARGA ─────────────────────────────────────────
// Medido contra llama.cpp en la misma sesión y el mismo fichero, ellos cargan
// x3,5 más rápido que nosotros. Es la espera más larga que paga el usuario y
// nadie la había repartido nunca: «la carga tarda» tiene al menos tres causas
// que desde fuera se ven idénticas —traer los bytes, subirlos al dispositivo, y el
// número de viajes— y sin separarlas no se puede atacar ninguna.
//
// Se cuentan los TROZOS además del tiempo: este bucle pide un rango por
// tensor como mínimo, y un modelo pequeño tiene cientos. Si el tiempo está en
// la latencia de cientos de viajes en serie, el arreglo no es un kernel, es
// dejar de esperar uno por uno.
const ahoraC = () => (typeof performance !== 'undefined' ? performance.now() : Date.now());
const tCarga0 = ahoraC();
let msLeer = 0, msSubir = 0, trozos = 0;
// ── TRAMOS: una lectura para MUCHOS tensores ────────────────────────────────
// Esto pedía un rango por tensor. Medido en navegador limpio con el modelo
// pequeño: un viaje por tensor, con el 99,9 % del tiempo en LEER, menos del
// 1 % en encolar la subida y nada esperando al dispositivo. Y el coste por viaje
// apenas dependía de su tamaño, que es la firma de la LATENCIA: no se estaba
// llenando el enlace, se estaba esperando cientos de veces de una en una.
//
// En GGUF los tensores van CONTIGUOS, así que se agrupan en tramos de hasta
// TRAMO bytes y cada tramo se trae de una sola lectura; después se reparte en
// memoria, que sale gratis (encolar era el 0,1 %).
//
// Se agrupa SOLO si el tensor empieza justo donde acaba el anterior: si el
// fichero trae relleno entre tensores, agrupar a ciegas no daría error, daría
// pesos de otro sitio. Y un tensor más grande que TRAMO va en su propio tramo
// y se lee a trozos de CHUNK, igual que antes.
// Interruptor para poder medir el ANTES y el DESPUÉS en la MISMA sesión: una
// razón sacada de comparar dos tiradas no vale, porque entre tiradas los
// absolutos se mueven demasiado. A 1 byte cada tensor va en su propio tramo y
// se recupera el comportamiento de una lectura por tensor.
// El tramo por defecto, y no la mitad: barrido en la misma sesión, dos rondas
// por candidato y orden alternado, con una prueba interna. Contra el camino
// viejo —un viaje por tensor— agrupar da del orden de x7. Entre candidatos, de
// la mitad al valor elegido hay una mejora pequeña que se repite en LAS DOS
// rondas; al doble la diferencia cae dentro del ruido y pediría un buffer
// transitorio el doble de grande para nada. Ahí la curva ya está saturada:
// manda el enlace.
const TRAMO = Math.max(1, (globalThis.__ELFFUSS_TRAMO | 0) || 128 * MiB);
const CHUNK = 32 * MiB;
const tramos = [];
for (const t of suben) {
if (t.nBytes > limit) {
throw new Error(`«${t.name}» son ${(t.nBytes / MiB).toFixed(0)} MiB y el ` +
`límite de binding es ${(limit / MiB).toFixed(0)} MiB: hace falta que el ` +
`matmul lea varios shards`);
}
const ult = tramos[tramos.length - 1];
if (ult && t.start === ult.fin && (ult.fin - ult.ini) + t.nBytes <= TRAMO) {
ult.fin = t.start + t.nBytes; ult.ts.push(t);
} else {
tramos.push({ ini: t.start, fin: t.start + t.nBytes, ts: [t] });
}
}
// Holgura de 4 bytes en el buffer: la descodificación de bloques de 34 lee la
// palabra siguiente al recomponer los que no caen alineados.
const nuevoBuf = (t) => device.createBuffer({
label: t.name,
size: Math.ceil((t.nBytes + 4) / 4) * 4,
usage: GPUBufferUsage.STORAGE | GPUBufferUsage.COPY_DST,
});
// FORMATO REORDENADO (`__ELFFUSS_REPACK`): los Q8_0/Q4_0 se suben con los
// cuantos alineados y las escalas aparte, y su descriptor pasa a decir
// Q8_0R/Q4_0R (ver repack.js). La foto del interruptor se toma UNA vez por
// carga. Apagado, `tipoReordenado` da null siempre y todo lo de abajo hace
// exactamente lo de antes.
const conReorden = reordenActivo();
let reordenados = 0;
for (const tr of tramos) {
const largo = tr.fin - tr.ini;
if (largo > TRAMO) {
// Tensor suelto demasiado grande: camino de trozos, uno solo en el tramo.
const t = tr.ts[0];
const tipoR = tipoReordenado(t, conReorden);
if (tipoR) {
// Los trozos van cortados en bloques enteros y cada uno se escribe en
// sus dos regiones (cuantos y escalas).
const buf = creaBufferR(device, t, tipoR);
await subeReordenadoPorTrozos({
device, ranged, t, buf, tipoR, trozo: CHUNK, ahora: ahoraC,
cuenta: (leer, subir, n) => {
msLeer += leer; msSubir += subir; trozos++;
uploaded += n;
onProgress(uploaded, total, t.name);
},
});
weights.set(t.name, { buf, t: comoReordenado(t, tipoR) });
reordenados++;
continue;
}
const buf = nuevoBuf(t);
for (let off = 0; off < t.nBytes; off += CHUNK) {
const len = Math.min(CHUNK, t.nBytes - off);
const tL = ahoraC();
const raw = new Uint8Array(await ranged.slice(t.start + off, len));
const tS = ahoraC(); msLeer += tS - tL; trozos++;
const pad = len % 4 === 0 ? raw : (() => {
const p = new Uint8Array(Math.ceil(len / 4) * 4); p.set(raw); return p;
})();
device.queue.writeBuffer(buf, off, pad, 0, pad.byteLength);
msSubir += ahoraC() - tS;
uploaded += len;
onProgress(uploaded, total, t.name);
}
weights.set(t.name, { buf, t });
continue;
}
const tL = ahoraC();
const span = new Uint8Array(await ranged.slice(tr.ini, largo));
msLeer += ahoraC() - tL; trozos++;
// Un tramo corto se leería sin error y dejaría ceros dentro de un peso.
if (span.byteLength !== largo) {
throw new Error(`tramo incompleto: pedidos ${largo} bytes desde ${tr.ini} ` +
`y llegaron ${span.byteLength}`);
}
for (const t of tr.ts) {
const tipoR = tipoReordenado(t, conReorden);
const buf = tipoR ? creaBufferR(device, t, tipoR) : nuevoBuf(t);
const tS = ahoraC();
const desde = t.start - tr.ini;
const n4 = Math.ceil(t.nBytes / 4) * 4;
const pad = new Uint8Array(n4);
// Formato reordenado: se escribe DENTRO de la copia de relleno que ya se
// hacía, en vez de copiar tal cual. Mismo tamaño, cero memoria extra.
if (tipoR) reordena(tipoR, span.subarray(desde, desde + t.nBytes), bloquesDe(t), pad);
else pad.set(span.subarray(desde, desde + t.nBytes));
device.queue.writeBuffer(buf, 0, pad, 0, n4);
msSubir += ahoraC() - tS;
uploaded += t.nBytes;
onProgress(uploaded, total, t.name);
weights.set(t.name, { buf, t: tipoR ? comoReordenado(t, tipoR) : t });
if (tipoR) reordenados++;
}
}
// `onSubmittedWorkDone` se mide aparte: es donde se paga de verdad el trabajo
// que `writeBuffer` solo había ENCOLADO. Sin separarlo, subir parecería
// gratis y el tiempo aparecería como un hueco sin dueño.
const tEspera = ahoraC();
await device.queue.onSubmittedWorkDone();
subidosEsperados = suben.length;
medidaCarga = {
tensores: suben.length, saltados: g.tensors.length - suben.length, trozos, bytes: total,
leerMs: msLeer, subirMs: msSubir, esperaMs: ahoraC() - tEspera,
totalMs: ahoraC() - tCarga0,
// Cuántos tensores se subieron reordenados (0 con `__ELFFUSS_REPACK` apagado).
reordenados,
};
console.log(`[engine] carga: ${suben.length} tensores en ${trozos} trozos · ` +
`leer ${msLeer.toFixed(0)} ms · encolar ${msSubir.toFixed(0)} ms · ` +
`esperar GPU ${medidaCarga.esperaMs.toFixed(0)} ms · total ${medidaCarga.totalMs.toFixed(0)} ms`);
// `picoGPU` es el pico de memoria pedida al dispositivo sin reciclar dentro de un
// solo forward. Un prefill largo acumula TODOS los intermedios de todas las
// capas, y cada uno escala con el número de tokens.
return { g, hp, ops, weights, device, bytes: total, picoGPU: () => ops.ctx.picoBytes };
}
export function createSession(model, opts = {}) {
const { device, hp, ops, weights } = model;
// Sonda de diagnostico: cuando esta puesta, cada intermedio con nombre se
// ofrece al llamador. Es lo que permite comparar contra el volcado nodo a
// nodo de un forward real y localizar el paso exacto donde algo se desvia,
// en vez de ver solo que la capa entera no cuadra.
const probe = opts.probe || null;
let capaActual = -1;
// Buffers que una sonda ha pedido CONSERVAR hasta el final del forward. Sin
// esto el mecanismo solo servía para la última capa, y de la forma más
// traicionera que hay: `ctx.recycleDesde` recicla los intermedios en cuanto
// la capa termina —protege los de `tap`, pero no los que se entregan por
// `probe`—, así que leer uno después del forward devolvía el trozo de memoria
// REUTILIZADO por las capas siguientes. Un banco que sondeó nueve capas sacó
// la misma cifra en ocho de ellas, idéntica hasta el decimal, y solo la última
// era real. No fallaba nada: contestaba otra cosa.
// El contrato: si la sonda devuelve `true`, ese buffer no se recicla.
let conservadas = new Set();
const P = (name, buf, n) => {
if (probe && probe(name, buf, n, capaActual) === true) conservadas.add(buf);
return buf;
};
const { quant, nn, ssm: ssmOps, attn, ctx } = ops;
// ── FUSIÓN DE KERNELS DE FILA (`__ELFFUSS_FUSION`, apagada por defecto) ─────
// Cuatro cadenas de despachos pequeños pasan a uno cada una, con la MISMA
// aritmética en el mismo orden (ver `kernels.fusion.wgsl.js`): post-norma +
// residual + norma siguiente (F1), embedding + primera norma (F2), la
// convolución corta tras `in_proj` (F4) y QK-norm + RoPE + escritura en la
// caché (F6). Se decide por PASADA (`fusionPase`), no por sesión: un A/B
// alterna en la misma sesión sin recargar el modelo. Apagada, nada de esto
// se toca y el forward es el de siempre, despacho a despacho.
const fus = createFusionOps(ops);
let fusionPase = false;
// La norma de ENTRADA que ya dejó hecha la capa anterior (F1) o el embedding
// (F2): { capa, peso, buf }, con `capa` el índice de la capa que la consume o
// 'salida' para la norma final, y `peso` el tensor con el que se hizo. Se
// consume una vez: quien la pide la borra. Quien la pide dice además QUÉ peso
// usaría él: si no coincide, no se usa y se calcula la de siempre.
let nrmPendiente = null;
const normaHecha = (capa, peso) => {
const n = nrmPendiente;
nrmPendiente = null;
return n && n.capa === capa && n.peso === peso ? n.buf : null;
};
// Qué norma va DESPUÉS de cada capa: la de entrada de la siguiente o la final.
// Todos los bloques (ssm, conv, atención) empiezan por su `attn_norm`.
const normaSiguiente = new Map((hp.layers || []).map((l, k) => {
const sig = hp.layers[k + 1];
return [l.index, sig ? { capa: sig.index, peso: `blk.${sig.index}.attn_norm.weight` }
: { capa: 'salida', peso: 'output_norm.weight' }];
}));
const state = createState(device, hp, opts);
const W = (name) => {
const w = weights.get(name);
if (!w) throw new Error('falta el tensor «' + name + '»');
return w;
};
const get = (name) => W(name).buf;
const has = (name) => weights.has(name);
// Una proyección. El tipo de cuantización lo pone el FICHERO, no esta función:
// el 0.8B lo trae todo en Q8_0, otros ficheros mezclan varios tipos, y el
// forward es el mismo. Este es el único punto donde el modelo toca la
// cuantización; de aquí en adelante todo es f32.
// ROTACIÓN DE HADAMARD. Si el fichero la declara, las activaciones que entran
// a los tensores enumerados hay que girarlas antes del matmul. No aplicarla no
// falla: carga, ejecuta y devuelve ruido con cara de respuesta.
const rot = leeRotacion((model.g && model.g.meta) || {});
const bufSignos = new Map(); // anchura -> buffer subido una sola vez
const signosDe = (ancho) => {
if (!bufSignos.has(ancho)) {
const v = rot.signos.get(ancho);
if (!v) throw new Error(`la rotación no trae signos para la anchura ${ancho}`);
// NO se pide al pozo de buffers: `ctx.alloc` entrega memoria reciclable y
// `recycle()` la devuelve, así que el mismo buffer acababa siendo el
// DESTINO de otra operación dentro del mismo pase — y WebGPU lo rechaza
// con «includes writable usage and another usage in the same
// synchronization scope», que no dice ni una palabra de reciclaje. Los
// signos viven lo que vive el modelo, como los pesos.
const buf = device.createBuffer({
label: `signos.${ancho}`, size: v.byteLength,
usage: GPUBufferUsage.STORAGE | GPUBufferUsage.COPY_DST,
});
device.queue.writeBuffer(buf, 0, v);
bufSignos.set(ancho, buf);
}
return bufSignos.get(ancho);
};
// Varios tensores comparten la MISMA activación de entrada (por ejemplo la
// proyección fusionada y la puerta, las dos tras la misma norma). Sin memoria
// se giraría lo mismo dos veces: correcto y tirado a la basura.
let memoRot = new Map();
// Geometría del reordenado de rasgos que pide `gdn_v_grouped`. Solo lo lleva
// la salida del SSM: su activación llega por teselas [hd, nk, rep] y el peso
// se guardó agrupado [hd, rep, nk]. Los nombres salen de la cabecera, no de
// constantes: n_v es el rango del paso temporal y n_k el número de grupos.
const meta = (model.g && model.g.meta) || {};
const clave = (suf) => Object.keys(meta).find((k) => k.endsWith(suf));
const nV = Number(meta[clave('.ssm.time_step_rank')] || 0);
const nK = Number(meta[clave('.ssm.group_count')] || 0);
const permDe = (name, ancho) => {
if (!rot || !rot.vGrouped || !name.includes('.ssm_out.')) return null;
if (!nV || !nK || nV % nK !== 0 || ancho % nV !== 0) {
throw new Error(`geometría de cabezas incompatible con el reordenado: ancho ${ancho}, n_v ${nV}, n_k ${nK}`);
}
return { hd: ancho / nV, nk: nK, rep: nV / nK };
};
const giraEntrada = async (x, ancho, tokens, perm) => {
// La clave lleva el reordenado: `ssm_out` comparte la activación de entrada
// con otros tensores pero su transformada NO es la misma, y compartir la
// memoria entre los dos daría el resultado del primero que pasara.
const k = perm ? `${perm.hd}:${perm.nk}:${perm.rep}` : 'llana';
// La MISMA activación alimenta varios tensores —`nrm` va a siete matmuls en
// una capa— y para todos salvo `ssm_out` la rotación es idéntica. Sin
// memoria se calcula una vez por matmul: cientos de veces por token, y cada
// una escribe su resultado a memoria para que el matmul lo lea de vuelta.
//
// La memoria estuvo APAGADA por una razón buena: se indexaba por el buffer,
// y los buffers se reciclan, así que el que fue una activación podía ser
// otra distinta más adelante y la segunda recibía la rotación de la primera.
// No fallaba, no avisaba, y el modelo decía ruido.
//
// Ahora la clave es la MARCA DE REPARTO (`ctx.marcaDe`): el pozo le pone un
// número distinto a cada buffer cada vez que lo entrega, de modo que un
// buffer reciclado es un valor nuevo y no puede alias con el anterior.
// Sin marca —un buffer que no salió del pozo— no se memoriza nada: es
// preferible repetir el trabajo a arriesgarse a devolver lo que no es.
const marca = ops.ctx.marcaDe?.get(x);
if (marca === undefined || globalThis.__ELFFUSS_ROT_MEMO === false) {
return await nn.hadamard(x, signosDe(ancho), { rows: tokens, ancho, bloque: rot.bloque, perm });
}
const clave = `${marca}:${k}`;
// Diagnóstico: sin contar aciertos no se sabe si la memoria sirve. Un x1,00
// puede ser «no hay nada que ahorrar» o «no está acertando», y son cosas
// muy distintas.
ops.ctx.rotStats = ops.ctx.rotStats || { acierto: 0, fallo: 0 };
if (memoRot.has(clave)) { ops.ctx.rotStats.acierto++; return memoRot.get(clave); }
ops.ctx.rotStats.fallo++;
const y = await nn.hadamard(x, signosDe(ancho), { rows: tokens, ancho, bloque: rot.bloque, perm });
memoRot.set(clave, y);
return y;
};
// Cuenta cuántos tensores rotados se han visto de verdad. Si el fichero
// declara 401 y el forward toca 12, algo no encaja y hay que enterarse.
const rotVistos = new Set();
// GEMV2: proyecciones que ya dejó hechas el despacho fusionado de Q/K/V/puerta
// (ver `qkvFusion`), por nombre de peso. Sin el interruptor está siempre vacío.
const hechas = new Map();
const mm = async (name, x, rows, k, tokens) => {
// Una proyección ya hecha se entrega UNA vez, y solo a quien la pide sobre
// la MISMA entrada: misma marca de reparto, así que un búfer reciclado no
// vale aunque sea el mismo objeto.
if (hechas.size) {
const h = hechas.get(name);
if (h) {
hechas.delete(name);
if (h.marca === ctx.marcaDe?.get(x) && h.rows === rows && h.tokens === tokens) return h.y;
}
}
const w = W(name);
let xin = x;
if (rot && rot.pesos.has(name)) {
rotVistos.add(name);
xin = await giraEntrada(x, k, tokens, permDe(name, k));
}
return quant.matmul(w.t.typeName, w.buf, xin, rows, k, tokens);
};
// Los pesos F32 (normas, ssm_a, dt) se usan tal cual; los cuantizados pasan
// por el matmul, que descuantiza dentro del shader.
const pipe = ctx.pipeline;
const eps = hp.eps;
const D = hp.headDim, H = hp.heads, KVH = hp.kvHeads, E = hp.embd;
const SH = hp.ssmHeads; // cabezas de CLAVE (q, k)
const SV = hp.ssmVHeads; // cabezas de VALOR (v, alpha, beta, salida)
const SS = hp.ssmState, CC = hp.convChannels, CK = hp.convKernel;
const KEY = SH * SS; // key_dim = value_dim = 2048 en el 0.8B
// GEMV fusionados del decode (`__ELFFUSS_GEMV2`, apagado por defecto): gate+up
// con la SwiGLU en el epílogo, y Q/K/V/puerta en un despacho. Están hechos para
// dar bit a bit lo mismo que las matrices sueltas con el GEMV nuevo: el orden
// de la suma de cada fila es el mismo (ver kernels.gemv.wgsl.js).
// Si no aplican —más de 3 tokens, tipos distintos, rotación de Hadamard,
// dispositivo sin subgrupos de 32— no hacen nada y el bloque sigue como siempre.
const gemv2 = quant.gemv || null;
const conRotacion = (name) => !!(rot && (rot.pesos.has(name) || rot.inversos.has(name)));
async function gateUpFusion(i, nrm, tokens) {
if (!gemv2 || tokens > 3) return null;
const ng = `blk.${i}.ffn_gate.weight`, nu = `blk.${i}.ffn_up.weight`;
if (conRotacion(ng) || conRotacion(nu)) return null;
const wg = W(ng), wu = W(nu);
if (wg.t.typeName !== wu.t.typeName) return null;
return gemv2.gateUp(wg.t.typeName, wg.buf, wu.buf, nrm, hp.ffnLength, E, tokens);
}
// Q, K, V y la puerta de una capa de atención en UN despacho. Las salidas no
// se devuelven: se dejan en `hechas`, por nombre de peso, y `mm` las entrega
// cuando el bloque pide esas proyecciones sobre la misma entrada. Así el
// bloque sigue igual línea a línea, y cualquier variante que pida las
// proyecciones en otro orden o desde otro sitio las encuentra hechas.
// Con el mínimo de búferes por etapa las cuatro no caben (nueve búferes):
// entonces van Q/K/V juntas (siete) y la puerta por su GEMV suelto.
async function qkvFusion(i, nrm, tokens) {
hechas.clear();
if (!gemv2 || tokens > 3) return;
const marca = ctx.marcaDe?.get(nrm);
if (marca === undefined) return;
const nombres = [`blk.${i}.attn_q.weight`, `blk.${i}.attn_k.weight`, `blk.${i}.attn_v.weight`];
const filas = [(hp.qGate ? 2 : 1) * H * D, KVH * D, KVH * D];
// La puerta por cabeza solo la usa el bloque cuando no hay puerta en Q.
if (!hp.qGate && hp.headGate) { nombres.push(`blk.${i}.attn_gate.weight`); filas.push(H); }
if (nombres.some(conRotacion)) return;
const ws = nombres.map(W);
const tipo = ws[0].t.typeName;
if (ws.some((w) => w.t.typeName !== tipo)) return;
let n = nombres.length;
let ys = await gemv2.secciones(tipo, ws.map((w) => w.buf), nrm, filas, E, tokens);
if (!ys && n === 4) {
n = 3;
ys = await gemv2.secciones(tipo, ws.slice(0, 3).map((w) => w.buf), nrm, filas.slice(0, 3), E, tokens);
}
if (!ys) return;
for (let j = 0; j < n; j++) hechas.set(nombres[j], { y: ys[j], marca, rows: filas[j], tokens });
}
async function gather(idsBuf, tokens) {
const w = W('token_embd.weight');
const z = await quant.gather(w.t.typeName, w.buf, idsBuf, E, tokens);
// La tabla guarda las filas YA giradas, así que aquí se deshace: h = s ⊙ (H z).
// Los signos van DESPUÉS, al revés que en el camino normal — es la inversa,
// y confundir el orden no falla, da ruido.
if (rot && rot.inversos.has('token_embd.weight')) {
rotVistos.add('token_embd.weight');
return await nn.hadamard(z, signosDe(E), { rows: tokens, ancho: E, bloque: rot.bloque, inverso: true });
}
return z;
}
// FUSIÓN (F2): el embedding y la norma de entrada de la primera capa en un
// despacho, que deja la norma para esa capa (`nrmPendiente`). Solo con el
// lector de bloques de siempre y sin rotación inversa: una tabla girada,
// o con rejilla va por `gather` y la norma de siempre (una reordenada al cargar
// sí entra: ver `puedeGatherNorma`).
async function gatherFusion(idsBuf, tokens) {
const w = W('token_embd.weight');
const l0 = hp.layers[0];
if (!l0 || (rot && rot.inversos.has('token_embd.weight')) || !puedeGatherNorma(w)) {
return await gather(idsBuf, tokens);
}
const { x, nrm } = await fus.gatherNorma(w.t.typeName, w.buf, idsBuf,
get(`blk.${l0.index}.attn_norm.weight`), E, tokens, eps);
nrmPendiente = { capa: l0.index, peso: `blk.${l0.index}.attn_norm.weight`, buf: nrm };
return x;
}
const raw = (label, p, buffers, groups) => ops.dispatchAny(label, p, buffers, groups);
async function silu(src, n) {
const p = await pipe('silu', siluShader());
const dst = ctx.alloc(n * 4, 'silu');
const params = ctx.uniform([new Uint32Array([n, 0, 0, 0])]);
await raw('silu', p, [src, dst, params], Math.ceil(n / 256));
return dst;
}
// `dstF16` va en la CLAVE del pipeline, no solo en el shader: con una sola
// clave, la primera llamada fijaría el compilado y la segunda escribiría con
// el tipo de la primera. La caché saldría escrita a medias y sin un error.
async function copyInto(src, dst, dstOffset, n, srcOffset = 0, dstF16 = false) {
const p = await pipe(`copy_into${dstF16 ? '_h' : ''}`, copyIntoShader(256, dstF16));
const params = ctx.uniform([new Uint32Array([n, dstOffset, srcOffset, 0])]);
await raw('copy_into', p, [src, dst, params], Math.ceil(n / 256));
}
// Corte contiguo de una fila ancha: q, k y v salen del mismo tensor de 6144.
const slice = (src, offset, width, tokens, rowWidth) =>
attn.strideCopy(src, { headDim: width, heads: 1, tokens, stride: rowWidth, offset });
// El cierre común de los dos tipos de bloque: residual, norm, SwiGLU, residual.
// Con `postNorms` (lfm3) la salida del bloque y la del FFN pasan por su propia
// RMSNorm ANTES de sumarse al residual.
async function feedForward(x, layerOut, i, tokens) {
const n = tokens * E;
// FUSIÓN (F1): post-norma + residual + norma del FFN en un despacho. Sin
// fusión `f1` es null y lo de abajo es exactamente lo de siempre.
const f1 = fusionPase ? await fus.normaResidual(layerOut, x,
hp.postNorms ? get(`blk.${i}.post_attention_norm.weight`) : null,
get(`blk.${i}.${hp.ffnNorm}.weight`), tokens, E, eps) : null;
if (hp.postNorms && !f1) {
layerOut = await nn.rmsnorm(layerOut, get(`blk.${i}.post_attention_norm.weight`), tokens, E, eps);
}
const res = f1 ? f1.res : await nn.add(x, layerOut, n);
// El nombre sale del perfil, no de `has(...)`: si se decidiera por presencia
// del tensor, un modelo al que le faltara dejaría de fallar y empezaría a
// mentir con una norma menos.
const nrm = f1 ? f1.nrm : await nn.rmsnorm(res, get(`blk.${i}.${hp.ffnNorm}.weight`), tokens, E, eps);
// gate+up+SwiGLU en un despacho (`__ELFFUSS_GEMV2`); null = camino de siempre.
const f3 = globalThis.__ELFFUSS_GEMV2 === true ? await gateUpFusion(i, nrm, tokens) : null;
const gate = f3 ? null : await mm(`blk.${i}.ffn_gate.weight`, nrm, hp.ffnLength, E, tokens);
const up = f3 ? null : await mm(`blk.${i}.ffn_up.weight`, nrm, hp.ffnLength, E, tokens);
// La intermedia del FFN lleva sonda. No es simetría con los otros nodos:
// las tres matrices del FFN son dos tercios de los pesos del modelo, y si
// esta activación es dispersa, las columnas de `ffn_down` que multiplican a
// un canal despreciable no hace falta ni LEERLAS. Medir eso exige poder
// verla, y sin sonda no se puede.
const sw = P('ffn_sw', f3 || await nn.swiglu(gate, up, tokens * hp.ffnLength), tokens * hp.ffnLength);
let down = await mm(`blk.${i}.ffn_down.weight`, sw, E, hp.ffnLength, tokens);
if (f1) return await cierreFusion(down, res, i, tokens);
if (hp.postNorms) down = await nn.rmsnorm(down, get(`blk.${i}.post_ffw_norm.weight`), tokens, E, eps);
return await nn.add(res, down, n);
}
// FUSIÓN (F1), el cierre del bloque: post-norma del FFN + residual + la norma
// de lo que viene después (la `attn_norm` de la capa siguiente o la final),
// que se deja hecha en `nrmPendiente` para quien la consuma. Esa norma nace
// con los intermedios del FFN de esta capa aún sin reciclar: en un modelo sin
// post-normas el pico de memoria puede llevar una fila de activaciones más;
// con ellas (lfm3) baja, porque las post-normas ya no se materializan.
async function cierreFusion(down, res, i, tokens) {
const sig = normaSiguiente.get(i);
const r = await fus.normaResidual(down, res,
hp.postNorms ? get(`blk.${i}.post_ffw_norm.weight`) : null, get(sig.peso), tokens, E, eps);
nrmPendiente = { capa: sig.capa, peso: sig.peso, buf: r.nrm };
return r.res;
}
// ── LA ÚLTIMA CAPA, SOLO PARA EL ÚLTIMO TOKEN (interruptor GEMM2_COLA) ─────
// De la última capa de un prompt solo se usa la fila del último token: es la
// única que llega a la cabeza. Sus cachés (KV, ventana de la convolución,
// estado recurrente) sí necesitan TODOS los tokens, y se escriben antes de la
// proyección de salida. Así que el corte va justo ahí: la mezcla se calcula
// entera, y la proyección de salida, las normas sándwich, el FFN y las sumas
// residuales se hacen para UNA fila.
//
// Tiene que dar los MISMOS bits. Las normas, las sumas y SwiGLU van fila a
// fila o elemento a elemento, así que una fila sola sale igual que dentro del
// lote. Los matmuls no: con un token caerían en el matvec, que suma en otro
// orden. Por eso van por `quant.gemm2.cola`, que usa el mismo kernel y la misma
// forma que habría tocado al lote entero. Si alguno de los cuatro pesos no
// puede ir así, la capa se calcula como siempre (ver `colaReproducible`).
//
// `colaLote` vale el tamaño del lote SOLO mientras se calcula la última capa
// con el corte puesto; se fija antes de cada capa y se borra al empezar cada
// pasada, para que un forward que lanzó a medias no deje el corte armado.
// `colaCortada` lo pone `colaFinal`: dice que el bloque llegó de verdad al
// corte, que es lo que `unaPasada` exige antes de dar la capa por cortada.
let colaLote = 0;
let colaCortada = false;
const mmCola = async (name, x1, rows, k, lote) => {
const w = W(name);
let xin = x1;
if (rot && rot.pesos.has(name)) {
rotVistos.add(name);
xin = await giraEntrada(x1, k, 1, permDe(name, k));
}
const y = await quant.gemm2.cola(w.t.typeName, w.buf, xin, rows, k, lote);
// `colaReproducible` lo comprobó antes de empezar: si aun así no aplica es
// un fallo de programación, y se dice. Caer al matvec daría otros bits.
if (!y) throw new Error(`cola: «${name}» no se puede calcular con el kernel del lote`);
return y;
};
async function feedForwardCola(x1, out1, i, lote) {
let layerOut = out1;
if (hp.postNorms) {
layerOut = await nn.rmsnorm(layerOut, get(`blk.${i}.post_attention_norm.weight`), 1, E, eps);
}
const res = await nn.add(x1, layerOut, E);
const nrm = await nn.rmsnorm(res, get(`blk.${i}.${hp.ffnNorm}.weight`), 1, E, eps);
const gate = await mmCola(`blk.${i}.ffn_gate.weight`, nrm, hp.ffnLength, E, lote);
const up = await mmCola(`blk.${i}.ffn_up.weight`, nrm, hp.ffnLength, E, lote);
const sw = await nn.swiglu(gate, up, hp.ffnLength);
let down = await mmCola(`blk.${i}.ffn_down.weight`, sw, E, hp.ffnLength, lote);
if (hp.postNorms) down = await nn.rmsnorm(down, get(`blk.${i}.post_ffw_norm.weight`), 1, E, eps);
return await nn.add(res, down, E);
}
// `mezcla` es la salida del bloque ANTES de su proyección de salida, con
// `ancho` columnas; `x` la entrada del bloque (el residual). Devuelve UNA fila.
async function colaFinal(x, mezcla, nombreSalida, ancho, i, tokens) {
colaCortada = true;
const mezclaFila = ctx.alloc(ancho * 4, 'cola.mezcla');
await copyInto(mezcla, mezclaFila, 0, ancho, (tokens - 1) * ancho);
const x1 = ctx.alloc(E * 4, 'cola.x');
await copyInto(x, x1, 0, E, (tokens - 1) * E);
const out1 = await mmCola(nombreSalida, mezclaFila, E, ancho, tokens);
return await feedForwardCola(x1, out1, i, tokens);
}
function colaReproducible(l, tokens) {
const i = l.index;
const salida = l.kind === 'conv' ? [`blk.${i}.shortconv.out_proj.weight`, E, E]
: l.kind === 'ssm' ? [`blk.${i}.ssm_out.weight`, E, hp.ssmInner]
: [`blk.${i}.attn_output.weight`, E, H * D];
return [salida,
[`blk.${i}.ffn_gate.weight`, hp.ffnLength, E],
[`blk.${i}.ffn_up.weight`, hp.ffnLength, E],
[`blk.${i}.ffn_down.weight`, E, hp.ffnLength],
].every(([n, r, k]) => has(n) && quant.gemm2.reproducible(W(n).t.typeName, r, k, tokens));
}
// La convolución CORTA de lfm3. Mismo andamio que la conv del SSM (ventana con
// el estado de los tokens anteriores, conv depthwise causal, guardar el
// estado), pero sin silu y entre dos puertas:
// in_proj → [B | C | x] → B·x → conv(K) → C·y → out_proj
// El orden de los tres trozos es el de llama.cpp (`build_lfm_shortconv`):
// B primero, luego C, luego x. Cambiarlo no peta, da ruido con cara de texto.
async function convBlock(x, i, tokens) {
capaActual = i;
const nrm = P('attn_norm', normaHecha(i, `blk.${i}.attn_norm.weight`) ?? await nn.rmsnorm(x, get(`blk.${i}.attn_norm.weight`), tokens, E, eps), tokens * E);
const bcx = P('in_proj', await mm(`blk.${i}.shortconv.in_proj.weight`, nrm, 3 * E, E, tokens), tokens * 3 * E);
let y;
if (fusionPase && fus.convCabe(CK)) {
// FUSIÓN (F4): de `in_proj` a la entrada de `out_proj` en un despacho —los
// tres cortes, B·x, la ventana, la conv, guardar el estado y C·y—. Solo
// sustituye esa fontanería y deja `y` donde la deja la cadena: la cola del
// bloque (`out_proj` y el FFN) es UNA para los dos caminos, y lo que se le
// cuelgue a esa cola lo ven los dos. Los intermedios `bx` y `conv` no
// llegan a existir, así que esas dos sondas no se ofrecen. Un kernel de
// conv más largo que la tesela del kernel fusionado va por la cadena.
y = await fus.convCorta(bcx, state.ssm.get(i).conv, get(`blk.${i}.shortconv.conv.weight`), E, tokens, CK);
} else {
const b = await slice(bcx, 0, E, tokens, 3 * E);
const c = await slice(bcx, E, E, tokens, 3 * E);
const xs = await slice(bcx, 2 * E, E, tokens, 3 * E);
const bx = P('bx', await attn.mul(b, xs, tokens * E), tokens * E);
const st = state.ssm.get(i);
const window = CK - 1 + tokens;
const pw = await pipe('conv_window', convWindowShader());
const win = ctx.alloc(E * window * 4, 'convwin');
const pwp = ctx.uniform([new Uint32Array([E, tokens, CK - 1, window])]);
await raw('conv_window', pw, [st.conv, bx, win, pwp], Math.ceil(E * window / 256));
const conv = P('conv', await ssmOps.conv(win, get(`blk.${i}.shortconv.conv.weight`), E, tokens, CK), tokens * E);
const ps = await pipe('conv_save', convSaveShader());
const psp = ctx.uniform([new Uint32Array([E, tokens, CK - 1, window])]);
await raw('conv_save', ps, [win, st.conv, psp], Math.ceil(E * (CK - 1) / 256));
y = await attn.mul(c, conv, tokens * E);
}
if (colaLote) return await colaFinal(x, y, `blk.${i}.shortconv.out_proj.weight`, E, i, tokens);
const out = P('conv_out', await mm(`blk.${i}.shortconv.out_proj.weight`, y, E, E, tokens), tokens * E);
return await feedForward(x, out, i, tokens);
}
async function ssmBlock(x, i, tokens) {
capaActual = i;
const nrm = P('attn_norm', normaHecha(i, `blk.${i}.attn_norm.weight`) ?? await nn.rmsnorm(x, get(`blk.${i}.attn_norm.weight`), tokens, E, eps), tokens * E);
// qkv fusionado → ventana de conv (transposición + concatenación con el
// estado del token anterior) → conv depthwise causal → silu.
const qkv = P('qkv', await mm(`blk.${i}.attn_qkv.weight`, nrm, CC, E, tokens), tokens * CC);
const st = state.ssm.get(i);
const window = CK - 1 + tokens;
const pw = await pipe('conv_window', convWindowShader());
const win = ctx.alloc(CC * window * 4, 'convwin');
const pwp = ctx.uniform([new Uint32Array([CC, tokens, CK - 1, window])]);
await raw('conv_window', pw, [st.conv, qkv, win, pwp], Math.ceil(CC * window / 256));
const conv = P('conv_raw', await ssmOps.conv(win, get(`blk.${i}.ssm_conv1d.weight`), CC, tokens), tokens * CC);
const act = P('conv_silu', await silu(conv, CC * tokens), tokens * CC);
// El estado de conv se guarda DESPUÉS de leer la ventana, no antes.
const ps = await pipe('conv_save', convSaveShader());
const psp = ctx.uniform([new Uint32Array([CC, tokens, CK - 1, window])]);
await raw('conv_save', ps, [win, st.conv, psp], Math.ceil(CC * (CK - 1) / 256));
const qRawS = P('q_conv', await slice(act, 0, KEY, tokens, CC), tokens * KEY);
const kRawS = P('k_conv', await slice(act, KEY, KEY, tokens, CC), tokens * KEY);
const q = P('q_l2', await ssmOps.l2norm(qRawS, tokens * SH, SS, eps), tokens * KEY);
const k = P('k_l2', await ssmOps.l2norm(kRawS, tokens * SH, SS, eps), tokens * KEY);
const v = P('v_conv', await slice(act, 2 * KEY, hp.ssmInner, tokens, CC), tokens * hp.ssmInner);
// alpha y beta salen de la ENTRADA normalizada, no del qkv ni de la conv.
const alpha = P('alpha', await mm(`blk.${i}.ssm_alpha.weight`, nrm, SV, E, tokens), tokens * SV);
const gdecay = P('gate', await ssmOps.decayGate(alpha, get(`blk.${i}.ssm_dt.bias`),
get(`blk.${i}.ssm_a`), SV, tokens), tokens * SV);
const betaRaw = await mm(`blk.${i}.ssm_beta.weight`, nrm, SV, E, tokens);
const beta = P('beta', await ssmOps.sigmoid(betaRaw, SV * tokens), tokens * SV);
const o = P('gdn_out', await ssmOps.gatedDeltaNet(q, k, v, gdecay, beta, st.state, SV, tokens, SH), tokens * hp.ssmInner);
// La puerta del norm final sale de su propia proyección.
//
// Los tres nodos que van de aquí al residual llevan sonda porque son el
// último tramo del bloque donde el recuento de cabezas de VALOR vuelve a
// importar: la norma con puerta normaliza por filas de SS sobre tokens×SV.
// Sin sonda, un fallo aquí no aparecía como «la norma con puerta está mal»,
// aparecía como una escalera que se desvía desde el bloque 0 sin decir en
// qué operación.
const z = P('z', await mm(`blk.${i}.attn_gate.weight`, nrm, hp.ssmInner, E, tokens), tokens * hp.ssmInner);
const gn = P('gated_norm',
await ssmOps.gatedNorm(o, get(`blk.${i}.ssm_norm.weight`), z, tokens * SV, SS, eps),
tokens * hp.ssmInner);
if (colaLote) return await colaFinal(x, gn, `blk.${i}.ssm_out.weight`, hp.ssmInner, i, tokens);
const out = P('ssm_out', await mm(`blk.${i}.ssm_out.weight`, gn, E, hp.ssmInner, tokens), tokens * E);
return await feedForward(x, out, i, tokens);
}
// `rope_freqs` (lfm3): un solo tensor para todas las capas globales.
const factoresRope = has('rope_freqs.weight') ? get('rope_freqs.weight') : null;
async function attnBlock(x, l, tokens, posBuf) {
const i = l.index;
capaActual = i;
// Base de RoPE y ventana POR CAPA (lfm3); en el resto, las del modelo.
const ropeBase = l.ropeBase ?? hp.ropeFreqBase;
const factores = l.ropeFactores ? factoresRope : null;
if (l.ropeFactores && !factores) throw new Error(`la capa ${i} pide rope_freqs y el fichero no lo trae`);
const nrm = normaHecha(i, `blk.${i}.attn_norm.weight`) ?? await nn.rmsnorm(x, get(`blk.${i}.attn_norm.weight`), tokens, E, eps);
// En qwen35 `attn_q` proyecta al DOBLE —Q y una puerta INTERCALADOS por
// cabeza— y hay que partirlo. En llama proyecta a H*D y ya está, así que no
// hay nada que partir: el matmul deja [T][H*D], que es justo [T][H][D], la
// forma que esperan RoPE y los scores. Ni una copia de por medio.
// GEMV2: Q, K, V y la puerta en un despacho; las recoge `mm` (ver `qkvFusion`).
if (globalThis.__ELFFUSS_GEMV2 === true) await qkvFusion(i, nrm, tokens);
let qRaw, gRaw = null;
if (hp.qGate) {
const qfull = await mm(`blk.${i}.attn_q.weight`, nrm, 2 * H * D, E, tokens);
qRaw = await attn.strideCopy(qfull, { headDim: D, heads: H, tokens, stride: 2 * D, offset: 0 });
gRaw = await attn.strideCopy(qfull, { headDim: D, heads: H, tokens, stride: 2 * D, offset: D });
} else {
qRaw = await mm(`blk.${i}.attn_q.weight`, nrm, H * D, E, tokens);
}
// QK-norm ANTES de RoPE.
//
// Y el RoPE va en NEOX aunque la referencia use MRoPE intercalado (qwen35
// declara IMROPE, con cuatro secciones de dimensiones). NO es una
// simplificación: para texto puro las dos son la MISMA función, y conviene
// dejar por qué, porque parece un bug cada vez que se lee.
// 1. El MRoPE reparte las dimensiones entre cuatro ejes de posición
// (t, h, w y uno extra) — de ahí que sea multimodal.
// 2. Con tokens de texto, llama.cpp escribe la MISMA posición en las
// cuatro ranuras, así que los cuatro ángulos valen lo mismo y da igual
// qué eje toque a cada dimensión.
// 3. Los cuatro avanzan en bloque: `indep_sects` sale de `is_vision`, que
// es falso aquí, o sea que ninguna sección reinicia su ángulo.
// 4. Y el emparejamiento de elementos es literalmente la misma llamada
// que el NEOX, `rotate_pairs(n_dims, n_dims/2)`.
// Deja de valer en cuanto entre una imagen: ahí las posiciones dejan de ser
// iguales y hace falta el MRoPE de verdad.
// ⚠️ EL MODO DE RoPE SALE DEL PERFIL, y es el cambio que más miedo da de
// toda esta lista: equivocarse NO peta. Sale texto gramatical que se
// degrada al crecer el contexto, o sea el fallo más caro de detectar que
// hay. qwen35 empareja como NEOX; llama usa NORM porque su conversor a GGUF
// ya permuta los pesos. Ver `state.js`, ARQUITECTURAS.
const modoRope = hp.ropeMode === 'norm' ? ROPE_NORM : ROPE_NEOX;
// A la caché, a partir de nPast: nunca se pisa lo ya cacheado.
const cache = state.kv.get(i);
const per = KVH * D;
// UNA sola fuente de verdad para la precisión de la caché, leída del estado
// que la reservó. Escribirla y leerla con precisiones distintas no lanza:
// devuelve basura, y por eso el dato no se repite en cuatro sitios.
const kvF16 = !!state.kvF16;
let q;
if (fusionPase && fus.qkvCabe(D, hp.ropeDims, { norma: !!hp.qkNorm, factores: !!factores })) {
// FUSIÓN (F6): QK-norm + RoPE de q y k + K y V a la caché, en un despacho.
// Las proyecciones de k y v se piden aquí, antes, porque el kernel quiere
// las tres a la vez; el orden entre proyecciones independientes no cambia
// ningún resultado. La misma precisión de caché que la cadena (`kvF16`).
// Si el dispositivo no admite tantos buffers por despacho, va partido en
// dos (consulta, y clave con valor); si ni así, por la cadena.
const kRaw = await mm(`blk.${i}.attn_k.weight`, nrm, KVH * D, E, tokens);
const v = await mm(`blk.${i}.attn_v.weight`, nrm, KVH * D, E, tokens);
q = await fus.qkNormaRopeCache({
q: qRaw, k: kRaw, v, pos: posBuf,
wq: hp.qkNorm ? get(`blk.${i}.attn_q_norm.weight`) : null,
wk: hp.qkNorm ? get(`blk.${i}.attn_k_norm.weight`) : null,
cacheK: cache.k, cacheV: cache.v,
heads: H, kvHeads: KVH, headDim: D, tokens, nPast: state.nPast,
nDims: hp.ropeDims, mode: modoRope, freqBase: ropeBase, factores, kvF16, eps,
});
} else {
// La QK-norm tampoco es universal: llama no trae `attn_q_norm` siquiera.
const qn = hp.qkNorm
? await nn.rmsnorm(qRaw, get(`blk.${i}.attn_q_norm.weight`), tokens * H, D, eps)
: qRaw;
q = await nn.rope(qn, posBuf,
{ rows: tokens * H, ne0: D, heads: H, nDims: hp.ropeDims, mode: modoRope, freqBase: ropeBase, factores });
const kRaw = await mm(`blk.${i}.attn_k.weight`, nrm, KVH * D, E, tokens);
const kn = hp.qkNorm
? await nn.rmsnorm(kRaw, get(`blk.${i}.attn_k_norm.weight`), tokens * KVH, D, eps)
: kRaw;
const k = await nn.rope(kn, posBuf,
{ rows: tokens * KVH, ne0: D, heads: KVH, nDims: hp.ropeDims, mode: modoRope, freqBase: ropeBase, factores });
const v = await mm(`blk.${i}.attn_v.weight`, nrm, KVH * D, E, tokens);
await copyInto(k, cache.k, state.nPast * per, tokens * per, 0, kvF16);
await copyInto(v, cache.v, state.nPast * per, tokens * per, 0, kvF16);
}
const nKv = state.nPast + tokens;
const cfg = { headDim: D, heads: H, kvHeads: KVH, tokens, nKv, nPast: state.nPast, kvF16 };
// ── Atención FUSIONADA (`__ELFFUSS_FLASH`, ver ops.flash.js) ────────────
// Puntuaciones, softmax con la máscara causal y de ventana y combinación en
// uno o dos despachos, sin materializar las puntuaciones, y con la puerta
// por cabeza de lfm3 dentro de su epílogo. Misma matemática salvo redondeo.
// Sustituye SOLO al núcleo: lo de después (la puerta de Q de qwen35, la
// proyección de salida, el residual) es el mismo código para las dos rutas,
// y así lo que se añada ahí vale también para esta. Si la forma no se puede
// atender, `fusionada` queda en null y va la cadena de siempre, que da lo
// mismo más despacio. La puerta de cabeza va dentro solo si no hay la de Q:
// la misma precedencia que abajo. `puede` recibe la misma forma (con la
// puerta) que `atencion`: si no, preguntaría por otro kernel.
const fusionada = globalThis.__ELFFUSS_FLASH === true && ops.flash?.puede({ ...cfg, ventana: l.ventana || 0, puerta: !hp.qGate && !!hp.headGate })
? await ops.flash.atencion(q, cache.k, cache.v, { ...cfg, ventana: l.ventana || 0,
puerta: !hp.qGate && hp.headGate ? await mm(`blk.${i}.attn_gate.weight`, nrm, H, E, tokens) : null })
: null;
const scores = fusionada ? null : await attn.scores(q, cache.k, cfg);
const probs = fusionada ? null : await nn.softmax(scores,
{ rows: H * tokens, nKv, nQ: tokens, nPast: state.nPast, scale: 1 / Math.sqrt(D), ventana: l.ventana || 0 });
const att = fusionada || await attn.combine(probs, cache.v, cfg);
// La puerta multiplica la salida ANTES de la proyección — cuando la hay.
// En llama la atención va directa a la proyección de salida.
let gated = att;
if (hp.qGate) {
const gsig = await ssmOps.sigmoid(gRaw, tokens * H * D);
gated = await attn.mul(att, gsig, tokens * H * D);
} else if (hp.headGate && !fusionada) {
// lfm3: un escalar por cabeza, de la ENTRADA normalizada (no de Q).
const gh = await mm(`blk.${i}.attn_gate.weight`, nrm, H, E, tokens);
const p = await pipe('mul_cabeza', mulCabezaShader());
gated = ctx.alloc(tokens * H * D * 4, 'gated');
const pp = ctx.uniform([new Uint32Array([tokens * H * D, D, 0, 0])]);
await raw('mul_cabeza', p, [att, gh, gated, pp], Math.ceil(tokens * H * D / 256));
}
if (colaLote) return await colaFinal(x, gated, `blk.${i}.attn_output.weight`, H * D, i, tokens);
const out = await mm(`blk.${i}.attn_output.weight`, gated, E, H * D, tokens);
return await feedForward(x, out, i, tokens);
}
// El reloj del respiro de un prefill troceado, con `__ELFFUSS_PLAN` (si no,
// null y todo como siempre). Sin él, cada pasada arrancaba en «ya toca» y
// pagaba, tras su segunda capa, un frame entero con el dispositivo parado:
// uno por lote. Dos cosas lo evitan sin perder para qué existe el respiro
// (que el compositor pinte):
// · el reloj se COMPARTE entre las pasadas del mismo forward, como si
// fueran una sola: un respiro cada `cederMs` como mucho;
// · un frame PINTADO cuenta como respiro. Un latido con rAF apunta cuándo
// se pintó el último; si el compositor está pintando mientras esperamos
// al dispositivo entre lotes, forzar otro hueco no compra nada. Si deja de
// pintar, el latido se para y el respiro vuelve a entrar igual que antes.
// El PRIMERO del forward sigue entrando en cuanto se puede (lo que busca es
// que lo último de la pantalla se vea antes de que el dispositivo se ocupe),
// pero con PLAN cede el frame SIN vaciar la cola (`respiroSinVaciar`): en ese
// momento el dispositivo solo tiene en cola las capas recién enviadas, el
// compositor entra entre un envío y el siguiente, y el dispositivo sigue
// trabajando mientras llega el frame en vez de esperarlo parado. Esto vale
// también para el prefill de una sola pasada, que era un frame ocioso por
// forward. Los respiros siguientes, si hacen falta (si no se ve pintar),
// vacían la cola como siempre: ahí el hueco es lo que garantiza el frame.
// Con `cederMs = 0` (el A/B) nada cambia: respira cada `cederCada` capas y
// vaciando siempre.
let relojRespiro = null;
let respiroSinVaciar = false;
const nuevoRelojRespiro = () => {
const r = { t: -Infinity, frame: -Infinity, actividad: performance.now() };
if (typeof requestAnimationFrame === 'function') {
const late = () => {
// Se apaga solo cuando el forward deja de dar señales (acabó o se paró).
if (performance.now() - r.actividad > 2000 || typeof requestAnimationFrame !== 'function') return;
r.frame = performance.now();
requestAnimationFrame(late);
};
requestAnimationFrame(late);
}
return r;
};
// UNA pasada: la implementación de siempre, intacta. La trocea `forward`.
//
// `signal` se mira en cada FRONTERA DE CAPA, y parar no rompe el lote a
// medias: se deja de grabar, el callback devuelve null y `ctx.batch` cierra y
// envía lo grabado por su camino normal (ops.js no sabe nada de parar). Lo que
// sí hay que hacer antes de lanzar es esperar al dispositivo: los uniformes del lote
// solo se pueden reciclar después de una sincronización —ver `forward`—, y
// quien recibe el error va a reciclar. `state.advance` NO se llama: el lote no
// terminó, así que nPast sigue donde estaba y lo que se escribió en la caché
// por encima queda tapado por la máscara causal. El estado recurrente sí quedó
// a medias, y por eso todo turno empieza con `restaura()` o `reset()`.
const unaPasada = async (tokenIds, { tap = null, todosLosLogits = false, signal = null } = {}) => {
let logitsTokens = 1;
let parado = false;
const tokens = tokenIds.length;
const taps = new Map();
const idsBuf = ctx.alloc(tokens * 4, 'ids');
device.queue.writeBuffer(idsBuf, 0, new Uint32Array(tokenIds));
const posBuf = ctx.alloc(tokens * 4, 'pos');
device.queue.writeBuffer(posBuf, 0,
Int32Array.from({ length: tokens }, (_, i) => state.nPast + i));
memoRot = new Map(); // la memoria de rotación vale para UN forward
conservadas = new Set(); // y lo que las sondas pidan conservar, también
// FUSIÓN: el interruptor se lee UNA vez por pasada, y una norma pendiente de
// una pasada anterior (parada a medias) no vale para esta.
fusionPase = fusionActiva();
nrmPendiente = null;
// GEMM2_COLA (ver `colaFinal`). Nunca con sondas, taps ni todos los logits:
// ahí se leen las filas de todos los tokens de la última capa.
colaLote = 0;
colaCortada = false;
const ultimaCapa = hp.layers[hp.layers.length - 1];
const cola = globalThis.__ELFFUSS_GEMM2 === true && globalThis.__ELFFUSS_GEMM2_COLA === true &&
tokens > 1 && !tap && !todosLosLogits && !probe && !!quant.gemm2 && colaReproducible(ultimaCapa, tokens);
let colaHecha = false;
const logits = await ops.batch('forward', async () => {
let x = fusionPase ? await gatherFusion(idsBuf, tokens) : await gather(idsBuf, tokens);
// El índice −1 es el embedding, antes de la primera capa. No es un
// capricho de simetría: si los ids o la tabla se leen mal, TODAS las
// capas se desvían y la escalera señala la 0 sin distinguir «entré mal»
// de «la capa 0 calcula mal». Con este ancla esa duda se resuelve.
if (tap && tap.has(-1)) taps.set(-1, x);
let capaN = 0;
// Arranca en «ya toca»: la primera capa de un prefill largo es un buen
// momento para dejar pintar, y no depender del reloj del forward anterior.
// Con PLAN, las pasadas siguientes del MISMO forward siguen su reloj.
let ultimoRespiro = relojRespiro ? relojRespiro.t : -Infinity;
for (const l of hp.layers) {
if (signal?.aborted) { parado = true; break; }
// Se recicla lo de CADA capa en cuanto termina, en vez de guardarlo
// todo hasta el final del forward. Sin esto el pico de memoria del dispositivo
// crecía con capas × tokens, o sea que con un prompt normal llegaba a
// pedir varias veces lo que pesa el modelo entero — y el factor empeora
// cuantas más capas tiene.
const marca = ctx.scratch.length;
// FUSIÓN: la norma que dejó hecha la capa anterior muere al acabar ESTA,
// como la norma que sustituye (ver `reciclableDesde`). Sin fusión no hay
// pendiente y la marca es la de siempre.
const marcaCapa = nrmPendiente ? fus.reciclableDesde(nrmPendiente.buf, marca) : marca;
const previo = x;
colaLote = cola && l === ultimaCapa ? tokens : 0;
x = l.kind === 'ssm' ? await ssmBlock(x, l.index, tokens)
: l.kind === 'conv' ? await convBlock(x, l.index, tokens)
: await attnBlock(x, l, tokens, posBuf);
if (colaLote) {
// Que el corte estuviera armado no basta: el bloque tiene que haber
// pasado por `colaFinal`. Un camino del bloque que vuelva antes del
// corte (otra variante del mismo bloque, una fusión) devuelve TODAS
// las filas, y la cabeza de una fila leería la del PRIMER token:
// logits de otro token, sin un error. Se dice aquí, antes de la cabeza.
if (!colaCortada) throw new Error(`cola: la capa ${l.index} volvió sin pasar por el corte (colaFinal)`);
colaHecha = true; colaLote = 0; // x es ya UNA fila
}
if (tap && tap.has(l.index)) taps.set(l.index, x);
// Vivos: la salida de esta capa (entra en la siguiente), la entrada si
// el bloque la devolvió tal cual, y cualquier tensor con sonda puesta,
// que el llamador va a leer DESPUÉS del forward.
// Con fusión, también la norma que esta capa deja hecha para la siguiente.
ctx.recycleDesde(marcaCapa, x, previo, ...taps.values(), ...conservadas,
...(nrmPendiente ? [nrmPendiente.buf] : []));
// Trocear el forward para no colgar el ordenador. SOLO en prefill
// (tokens>1): el decode es 1 token y nunca colgó, y trocearlo lo
// ralentizaría sin motivo. Se corta el command buffer en CADA capa
// (barato: solo un submit más) y de vez en cuando se drena la cola y se
// cede un frame, para que el compositor tenga su hueco. No cambia la
// numérica: el orden de la cola se respeta. Ver ctx.corta.
//
// El troceo es GRATIS y va en todas las capas; el respiro es CARO (drena
// la cola, que mata el solape entre la CPU y el dispositivo, y encima espera
// al refresco) y va
// limitado por reloj. Ver `cederMs`: antes iba atado al contador de capas
// y era lo que fijaba el techo del prefill.
// DECODE: cortar el command buffer cada `cortaDecode` capas deja que el
// dispositivo empiece mientras la CPU sigue grabando el resto del token.
// Sin respiro (no hace falta: un token no cuelga nada). 0 = no cortar.
if (tokens === 1 && cortaDecode > 0 && (capaN + 1) % cortaDecode === 0 && capaN + 1 < hp.layers.length) ctx.corta();
if (tokens === 1) capaN++;
if (tokens > 1) {
if (relojRespiro) {
relojRespiro.actividad = performance.now();
if (relojRespiro.frame > ultimoRespiro) ultimoRespiro = relojRespiro.frame;
}
const toca = (capaN + 1) % cortaCada === 0;
// El respiro drena la cola; si el pase sigue abierto, lo que drena es
// una cola VACÍA —el trabajo ni se ha enviado— y se paga el frame sin
// conseguir el hueco que se buscaba. Así que cuando el respiro va a
// entrar, se corta aunque no tocase por intervalo.
const respira = (capaN + 1) % cederCada === 0 && performance.now() - ultimoRespiro >= cederMs;
if (toca || respira) ctx.corta();
capaN++;
if (respira) {
// Con PLAN, el primero del forward no vacía la cola (ver arriba).
if (!(respiroSinVaciar && cederMs > 0 && ultimoRespiro === -Infinity)) await device.queue.onSubmittedWorkDone();
await nuevoFrame(signal);
ultimoRespiro = performance.now();
if (relojRespiro) relojRespiro.t = ultimoRespiro;
}
}
}
// La última frontera: tras la última capa solo queda la cabeza, y unos
// logits que nadie va a leer no merecen la espera.
if (signal?.aborted) parado = true;
if (parado) return null;
if (colaHecha) {
// La última capa ya dejó solo la fila del último token: la misma norma
// y la misma cabeza que abajo, sin el recorte (ya está hecho).
const nrm1 = await nn.rmsnorm(x, get('output_norm.weight'), 1, E, eps);
const cabeza = has('output.weight') ? 'output.weight' : 'token_embd.weight';
logitsTokens = 1;
return await mm(cabeza, nrm1, model.g.meta['tokenizer.ggml.tokens'].length, E, 1);
}
// Con fusión, la norma final ya la dejó hecha la última capa (F1).
const nrm = normaHecha('salida', 'output_norm.weight') ?? await nn.rmsnorm(x, get('output_norm.weight'), tokens, E, eps);
// SOLO EL ÚLTIMO TOKEN. La cabeza es la matriz más grande del modelo
// (vocabulario × embedding) y para generar solo hace falta la última fila:
// calcularla para todo el prompt costaba cientos de veces más, y se pagaba
// por N−1 vectores de logits que se descartan enteros.
let entradaCabeza = nrm, tokensCabeza = tokens;
if (!todosLosLogits && tokens > 1) {
const fila = ctx.alloc(E * 4, 'ultimo');
await copyInto(nrm, fila, 0, E, (tokens - 1) * E);
entradaCabeza = fila; tokensCabeza = 1;
}
const head = has('output.weight') ? 'output.weight' : 'token_embd.weight';
logitsTokens = tokensCabeza;
return await mm(head, entradaCabeza, model.g.meta['tokenizer.ggml.tokens'].length,
E, tokensCabeza);
});
if (parado) {
// La espera va ANTES de lanzar, no es opcional: ver arriba.
await device.queue.onSubmittedWorkDone();
throw errorParado();
}
state.advance(tokens);
// `logitsTokens` dice para CUÁNTOS tokens hay logits: casi siempre 1,
// aunque `tokens` sea el prompt entero. Sin este dato, quien deduzca el
// tamaño del vocabulario dividiendo por `tokens` se equivoca.
return { logits, tokens, logitsTokens, taps };
};
// DIAGNÓSTICO DE COBERTURA. El fichero enumera cuántos tensores llevan
// rotación; si el forward toca muchos menos, hay un camino que se la salta —
// y eso no falla, devuelve ruido.
const _rotacion = () => (rot ? {
declarados: rot.pesos.size, inversos: rot.inversos.size,
aplicados: rotVistos.size, bloque: rot.bloque,
faltan: [...rot.pesos, ...rot.inversos].filter((n) => !rotVistos.has(n)),
} : null);
return {
_rotacion,
state,
hp,
// Ejecuta el forward y devuelve los logits del ÚLTIMO token.
// `tap` permite pedir el residual de una capa concreta para compararlo con
// el oráculo: es la diferencia entre «el texto suena raro» y «el bloque 7
// se desvía y los seis anteriores cuadran».
// Prefill TROCEADO. La máscara causal se aplica en el softmax, DESPUÉS de
// calcular los scores, así que una pasada de N tokens calcula la matriz
// N×N entera y tira la mitad. Troceando, cada lote solo se mide contra lo
// que ya hay: para 1347 tokens en lotes de 512 son 1,22 M de posiciones en
// vez de 1,81 M, y la diferencia CRECE con la longitud (×1,6 a 2048, ×1,78
// a 4096). Es la parte «superlineal» que la medida del prefill detectó y la
// razón de que llama.cpp —que trocea por defecto— fuera 58× más rápido.
//
// No toca ningún kernel ni la numérica: es la misma maquinaria del decode,
// con nPast avanzando entre lotes. Lo que cambia es cuánto trabajo inútil
// se hace, no el resultado.
//
// PARAR: `opts.signal` (un AbortSignal) se mira al entrar, entre lotes y en
// cada frontera de capa dentro de un lote. Al entrar no se toca nada; entre
// lotes, nPast queda al final del último lote completo; dentro de uno, donde
// empezó ese lote. Las tres salidas lanzan un AbortError y dejan el
// dispositivo en reposo, así que `recycle()` es seguro justo después. Todo lote terminado
// se avisa por `onProgress`, también el último antes del «para»: lo que se
// cuenta es trabajo hecho, y nPast lo incluye.
async forward(tokenIds, opts = {}) {
const senal = opts.signal || null;
if (senal?.aborted) throw errorParado();
// 128 y no 512, y la razón NO es la memoria: es que el dispositivo tiene que poder
// ATENDER AL ESCRITORIO entre despacho y despacho. El bucle del SSM recorre
// todos los tokens del lote DENTRO de un solo despacho, sin ceder; con 512
// ese núcleo corre largo, y el sistema puede matar la sesión gráfica cuando
// el compositor no consigue pintar dentro del plazo de su vigilante.
//
// Trocear más fino además REDUCE trabajo: la máscara causal se aplica en el
// softmax, o sea que cada lote calcula su matriz entera; a lotes más cortos,
// menos posiciones enmascaradas se calculan para tirarlas.
const LOTE = loteActual;
// Con `tap` NO se trocea: la referencia contra la que se compara sale de
// UNA pasada, y comparar 64 escalones contra tres pasadas concatenadas no
// significa nada. Con `todosLosLogits`
// tampoco, porque troceando solo sobreviven los del último lote.
// `onProgress(hechos, total)` se llama DESPUÉS de cada lote, que es justo
// después de esperar a que el dispositivo lo termine. Así lo que se reporta es
// trabajo HECHO y no encolado: una barra que avanza por encolado llega al
// 100 % y se queda ahí mientras el dispositivo sigue, que es peor que no tenerla.
const avisa = typeof opts.onProgress === 'function' ? opts.onProgress : null;
// Un reloj nuevo por forward troceado (ver `relojRespiro`): nunca se
// hereda el de otro forward.
relojRespiro = globalThis.__ELFFUSS_PLAN === true && !opts.tap && !opts.todosLosLogits &&
tokenIds.length > LOTE ? nuevoRelojRespiro() : null;
respiroSinVaciar = globalThis.__ELFFUSS_PLAN === true && !opts.tap && !opts.todosLosLogits;
if (opts.tap || opts.todosLosLogits || tokenIds.length <= LOTE) {
const r = await unaPasada(tokenIds, opts);
avisa?.(tokenIds.length, tokenIds.length);
return r;
}
let ultimo = null;
for (let i = 0; i < tokenIds.length; i += LOTE) {
ultimo = await unaPasada(tokenIds.slice(i, i + LOTE), opts);
// ESPERAR a que el lote termine en el dispositivo antes de encolar el siguiente.
// Los buffers uniform se reciclan ENTRE lotes (ops.js lo dice: «se
// reciclan entre lotes, no dentro»), y eso solo es seguro si hay una
// sincronización en medio. El bucle de decode la tiene sin buscarla,
// porque lee los logits en cada paso; aquí no había ninguna, así que el
// lote siguiente reutilizaba uniformes que el anterior todavía no había
// consumido. El resultado no era un error: era OTRO token (197 en vez
// de 62), que es la peor forma de fallar porque sale texto plausible.
await device.queue.onSubmittedWorkDone();
// El aviso va JUSTO DESPUÉS de esa espera y ANTES de mirar la señal: el
// lote ya está hecho y nPast lo incluye, así que se cuenta aunque el
// prefill se pare aquí mismo. Callarlo dejaría el progreso un lote por
// detrás de lo que de verdad entró. Quien no quiera avisos después de
// un «para» los filtra él: el proveedor deja de pasarlos a `onPrefill`
// en cuanto nota la señal.
avisa?.(Math.min(i + LOTE, tokenIds.length), tokenIds.length);
// Y ahora la señal, con el dispositivo parado y nPast al final del último lote
// completo. Tras el último lote no se mira: el trabajo ya está hecho y
// tirarlo no ahorra nada, así que el forward termina y el «para» lo
// nota quien llama en su siguiente comprobación.
if (senal?.aborted && i + LOTE < tokenIds.length) throw errorParado();
}
// `tokens` se corrige al total: quien lo lea espera cuántos entraron, no
// cuántos traía el último lote.
return { ...ultimo, tokens: tokenIds.length };
},
recycle: () => ctx.recycle(),
destroy: () => state.destroy(),
};
}
|