Spaces:
Running
Running
File size: 62,524 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 | // SPDX-License-Identifier: Apache-2.0
// Copyright (c) 2026 UtopiaIA
// Elffuss Runtime · shaders WGSL de pesos cuantizados. Seis tipos.
// ─────────────────────────────────────────────────────────────────────────────
// La decisión de fondo: los pesos NO se descuantizan en CPU. Se suben tal cual
// salen del GGUF y se descuantizan dentro del shader. Eso ahorra la pasada de
// CPU, el pico de memoria del doble y, sobre todo, el ancho de banda — que es lo
// que limita de verdad un matmul cuantizado.
//
// El precio es el layout: un bloque Q8_0 son 34 bytes (escala f16 + 32 int8) y
// en WGSL un storage buffer se lee como array<u32>. Como 34·i alterna resto 0 y
// 2 al dividir por 4, la mitad de los bloques NO empieza en palabra. Se ataca
// combinando dos palabras con desplazamientos, igual que llama.cpp.
//
// Una nota buena: 34·i SIEMPRE es par, así que la escala f16 nunca cruza la
// frontera de palabra — basta una carga y un desplazamiento de 0 o 16 bits. Y
// `unpack2x16float` es del NÚCLEO de WGSL, así que convertir f16→f32 no
// necesita la extensión shader-f16.
//
// ── Por qué hay UN andamio y seis descodificadores ──────────────────────────
// Los seis tipos comparten TODO menos la descodificación: mismo reparto de filas
// en dos ejes, mismo teselado de tokens, misma reducción en árbol. Escribir seis
// matmuls sería mantener seis veces la misma reducción y que se desincronicen.
// Aquí el andamio (`matmulShader`/`dequantShader`) es común y cada tipo aporta
// solo un `decode(emit)` que va sacando (índice dentro del bloque, valor). El
// andamio decide qué hacer con cada valor: acumularlo contra las activaciones
// (matmul) o escribirlo (dequant).
//
// El orden de las operaciones aritméticas es el de ggml, a propósito: `d1·q − m1`
// y no `d·(sc·q − …)`. No es superstición — cambiarlo mueve el último bit y el
// test de igualdad exacta contra la referencia deja de poder ser exacto.
//
// Las rejillas de los i-quants viven en `quant-tables.js` porque son parte del
// FORMATO, no de este código.
//
// Licencia: código propio, Apache-2.0 (ver SPDX arriba y LICENSE). Sin dependencias externas.
// Lectura de bloques del formato REORDENADO al cargar (Q8_0R/Q4_0R, `__ELFFUSS_REPACK`).
import { bloquesWGSL } from './kernels.bloques.wgsl.js';
export const Q8_BLOCK = 32;
export const Q8_BLOCK_BYTES = 34;
// Tope de workgroups por eje del despacho. NO es una constante de rendimiento:
// pasarse es un error de validación. Las filas se reparten en dos ejes porque la
// cabeza de salida son 248.320 y aquí topa en 65.535. El shader la necesita para
// recomponer el índice, así que vive aquí y `ops.js` la importa: dos copias que
// se desincronicen darían filas a cero sin un solo error.
export const AXIS = 65535;
// ── Helpers compartidos ─────────────────────────────────────────────────────
// `w` es el buffer de pesos cuantizados, declarado por quien incluya esto.
export const HELPERS = /* wgsl */`
// Byte con signo dentro de una palabra: se sube al tope y se baja con
// desplazamiento ARITMÉTICO. Es el idiom correcto, no restar 256.
fn get_byte_i32(value: u32, index: u32) -> i32 {
return bitcast<i32>(((value >> (index * 8u)) & 0xFFu) << 24u) >> 24u;
}
// Byte sin signo en un offset CUALQUIERA. Una sola palabra basta: un byte nunca
// cruza la frontera.
fn load_byte(byte_offset: u32) -> u32 {
return (w[byte_offset / 4u] >> ((byte_offset & 3u) * 8u)) & 0xFFu;
}
// Palabra de 32 bits en un offset de bytes CUALQUIERA, combinando dos palabras.
// El «& 31u» no es adorno: con shift==0 el desplazamiento sería de 32 bits, que
// en WGSL da un valor indeterminado. Enmascarando, ese caso queda en hi<<0 y el
// select lo descarta. Es el bug número uno de esta técnica.
fn load_u32_at(byte_offset: u32) -> u32 {
let word_idx = byte_offset / 4u;
let shift = (byte_offset & 3u) * 8u;
let lo = w[word_idx];
let hi = w[word_idx + 1u];
return select((lo >> shift) | (hi << ((32u - shift) & 31u)), lo, shift == 0u);
}
// Media palabra en un offset PAR. Todos los campos de 16 bits de todos los tipos
// caen en offsets pares, así que nunca cruzan la frontera de palabra.
fn load_u16_at(byte_offset: u32) -> u32 {
return (w[byte_offset / 4u] >> ((byte_offset & 2u) * 8u)) & 0xFFFFu;
}
// Escala f16 → f32, en un offset par.
fn load_scale(byte_offset: u32) -> f32 {
return unpack2x16float(load_u16_at(byte_offset))[0];
}
`;
// Helper exclusivo de Q4_K y Q5_K: seis bits de escala y seis de mínimo,
// guardados en 12 bytes para ocho sub-bloques. Los cuatro primeros van
// enteros; los cuatro últimos toman los cuatro bits bajos de un sitio y los dos
// altos de otro. Es la descodificación más fácil de equivocar del formato.
const SCALE_MIN_K4 = /* wgsl */`
fn scale_min_k4(sbase: u32, j: u32) -> vec2<u32> {
if (j < 4u) {
return vec2<u32>(load_byte(sbase + j) & 63u, load_byte(sbase + j + 4u) & 63u);
}
let a = load_byte(sbase + j + 4u);
let b = load_byte(sbase + j - 4u);
let c = load_byte(sbase + j);
return vec2<u32>((a & 0xFu) | ((b >> 6u) << 4u), (a >> 4u) | ((c >> 6u) << 4u));
}
`;
// ── Descodificadores por tipo ───────────────────────────────────────────────
// Cada uno recibe `emit(idxExpr, valExpr)` y devuelve WGSL. Dentro del cuerpo
// hay dos nombres dados por el andamio: `blk` (offset en bytes del bloque) y el
// índice que emite cada valor, relativo al bloque.
const DECODERS = {
// Sin cuantizar. No es un caso hipotético: llama.cpp deja en f32 o f16 los
// tensores cuyo ne[0] no es múltiplo de 256, y basta UNA proyección así para
// que el modelo no cargue. Aquí el «bloque» es el propio elemento, y el resto
// del andamio (reparto de filas, teselado, reducción) no se entera.
F32: {
blockElems: 1,
blockBytes: 4,
helpers: '',
decode: (emit) => `
${emit('0u', 'bitcast<f32>(w[blk / 4u])')}`,
},
F16: {
blockElems: 2,
blockBytes: 4,
helpers: '',
decode: (emit) => `
let pair = unpack2x16float(w[blk / 4u]);
${emit('0u', 'pair.x')}
${emit('1u', 'pair.y')}`,
},
// BF16 — la conversion mas barata que existe: los 16 bits de un bfloat16 SON
// la mitad alta de un f32, asi que basta desplazarlos y reinterpretar. Ni
// tabla ni aritmetica de exponentes.
//
// Se lee de dos en dos, como F16, porque el almacen es `array<u32>` y una
// palabra trae dos pesos. El de indice 0 esta en la mitad BAJA (little-endian).
//
// Hace falta para los modelos ternarios: dejan el camino recurrente del SSM
// en mas precision que el resto, y ahi es donde aparece este tipo.
BF16: {
blockElems: 2,
blockBytes: 4,
helpers: '',
decode: (emit) => `
let par = w[blk / 4u];
${emit('0u', 'bitcast<f32>(par << 16u)')}
${emit('1u', 'bitcast<f32>(par & 0xFFFF0000u)')}`,
},
// 32 pesos, 34 bytes: escala f16 + 32 enteros de 8 bits con signo.
Q8_0: {
blockElems: Q8_BLOCK,
blockBytes: Q8_BLOCK_BYTES,
helpers: '',
// La escala se saca FUERA del bucle: (Σ q·x)·d en vez de Σ (q·d)·x sería
// aún mejor, pero rompería el contrato de `emit`, que entrega valores ya
// escalados. Se paga una multiplicación por peso y se gana un andamio único.
decode: (emit) => /* wgsl */`
let d = load_scale(blk);
for (var i = 0u; i < 8u; i = i + 1u) {
let q = load_u32_at(blk + 2u + i * 4u);
for (var c = 0u; c < 4u; c = c + 1u) {
${emit('i * 4u + c', 'f32(get_byte_i32(q, c)) * d')}
}
}`,
},
// 32 pesos, 18 bytes: escala f16 + 16 bytes de nibbles. El nibble BAJO del
// byte j es el peso j y el ALTO el peso j+16 (no los dos seguidos), y el valor
// es (q − 8)·d. LFM3 se publica así (QAD-Q4_0), con los embeddings en Q6_K.
// 18·i es par: la escala nunca cruza palabra; los nibbles sí, y por eso van
// por load_u32_at.
Q4_0: {
blockElems: 32,
blockBytes: 18,
helpers: '',
decode: (emit) => /* wgsl */`
let d = load_scale(blk);
for (var i = 0u; i < 4u; i = i + 1u) {
let q = load_u32_at(blk + 2u + i * 4u);
for (var c = 0u; c < 4u; c = c + 1u) {
let by = (q >> (c * 8u)) & 0xFFu;
${emit('i * 4u + c', 'f32(i32(by & 0xFu) - 8) * d')}
${emit('i * 4u + c + 16u', 'f32(i32(by >> 4u) - 8) * d')}
}
}`,
},
// 256 pesos, 84 bytes: 16 escalas/mínimos de 4+4 bits, 64 bytes de 2 bits,
// y d/dmin al FINAL del bloque (no al principio, como en Q4_K/Q5_K).
Q2_K: {
blockElems: 256,
blockBytes: 84,
helpers: '',
decode: (emit) => /* wgsl */`
let d = load_scale(blk + 80u);
let dmin = load_scale(blk + 82u);
for (var n = 0u; n < 2u; n = n + 1u) {
let qbase = blk + 16u + n * 32u;
for (var j = 0u; j < 4u; j = j + 1u) {
// El mismo byte de quants se lee CUATRO veces, dos bits cada vez:
// j no elige el byte, elige el desplazamiento dentro del byte.
let shift = j * 2u;
let sca = load_byte(blk + n * 8u + j * 2u);
let scb = load_byte(blk + n * 8u + j * 2u + 1u);
let dl1 = d * f32(sca & 0xFu); let ml1 = dmin * f32(sca >> 4u);
let dl2 = d * f32(scb & 0xFu); let ml2 = dmin * f32(scb >> 4u);
let obase = n * 128u + j * 32u;
for (var l = 0u; l < 4u; l = l + 1u) {
let wa = w[(qbase + l * 4u) / 4u];
let wb = w[(qbase + 16u + l * 4u) / 4u];
for (var c = 0u; c < 4u; c = c + 1u) {
${emit('obase + l * 4u + c', 'dl1 * f32((wa >> (c * 8u + shift)) & 3u) - ml1')}
${emit('obase + 16u + l * 4u + c', 'dl2 * f32((wb >> (c * 8u + shift)) & 3u) - ml2')}
}
}
}
}`,
},
// 256 pesos, 144 bytes: d/dmin f16, 12 bytes de escalas de 6 bits, 128 bytes
// de nibbles. Los nibbles bajos son la primera mitad de cada grupo de 64 y los
// altos la segunda: NO alternan peso a peso.
Q4_K: {
blockElems: 256,
blockBytes: 144,
helpers: SCALE_MIN_K4,
decode: (emit) => /* wgsl */`
let d = load_scale(blk);
let dmin = load_scale(blk + 2u);
for (var j = 0u; j < 4u; j = j + 1u) {
let sm1 = scale_min_k4(blk + 4u, j * 2u);
let sm2 = scale_min_k4(blk + 4u, j * 2u + 1u);
let d1 = d * f32(sm1.x); let m1 = dmin * f32(sm1.y);
let d2 = d * f32(sm2.x); let m2 = dmin * f32(sm2.y);
let qbase = blk + 16u + j * 32u;
let obase = j * 64u;
for (var l = 0u; l < 8u; l = l + 1u) {
let ql = w[(qbase + l * 4u) / 4u];
for (var c = 0u; c < 4u; c = c + 1u) {
let q = (ql >> (c * 8u)) & 0xFFu;
${emit('obase + l * 4u + c', 'd1 * f32(q & 0xFu) - m1')}
${emit('obase + 32u + l * 4u + c', 'd2 * f32(q >> 4u) - m2')}
}
}
}`,
},
// 256 pesos, 210 bytes. El que desbloquea las mezclas estándar: Q4_K_M,
// Q5_K_M y compañía ponen la salida y el embedding en Q6_K, así que SIN este
// kernel no carga ni un fichero k-quant de los que publica todo el mundo —
// aunque el resto de sus tensores sí tenga kernel.
//
// Tres diferencias con Q4_K/Q5_K, y las tres importan:
//
// · 210 NO es múltiplo de 4, así que los bloques quedan desalineados y hay
// que leer con `load_byte`/`load_scale`, no con `w[(blk + x) / 4u]` como
// hacen sus hermanos. Usar la forma alineada da pesos de otro bloque.
// · las escalas son de 8 bits CON SIGNO. Sin signo el modelo carga y genera
// texto degenerado, que es mucho peor que un error.
// · no hay mínimo: el valor es `d·escala·(q − 32)` y el −32 es entero, así
// que no se usa la forma `d·q − m`.
//
// Dentro de cada mitad de 128 pesos, los cuatro que comparten un byte de `qh`
// van a 0, 32, 64 y 96 del destino con escalas is+0, is+2, is+4, is+6.
Q6_K: {
blockElems: 256,
blockBytes: 210,
helpers: /* wgsl */`
fn load_i8_at(byte_offset: u32) -> i32 {
let b = i32(load_byte(byte_offset));
return select(b, b - 256, b > 127);
}
`,
// ⚠️ POR QUÉ ESTO LEE PALABRAS Y NO BYTES, que es la diferencia entre
// «correcto» y «usable»:
//
// La primera versión leía byte a byte con `load_byte`, y lo justifiqué
// diciendo que Q6_K solo aparece en unos pocos tensores y no es camino
// caliente. **Era falso.** En una mezcla Q4_K_M real, Q6_K es el 38 % del
// fichero: el embedding (que también es la proyección de salida) y el
// `ffn_down` de TODAS las capas — o sea camino caliente en cada token y en
// cada posición del prompt. Medido con un 4B, el prefill caía a ~1/30 del
// de un modelo con Q8_0, y el banco lo cazó porque el prefill dejaba de ir
// más rápido que la generación, que es imposible si procesa en bloque.
//
// Ahora cada vuelta trae CUATRO pesos con tres lecturas de 32 bits en vez
// de doce de un byte, y las cuatro escalas salen del bucle interno: `is`
// solo cambia cada 16 posiciones, así que dentro de un grupo de 4 es
// constante. De 128 lecturas de escala por bloque se baja a 32.
//
// `load_u32_at` sigue siendo obligatorio —no `w[(blk + x) / 4u]`— porque
// 210 bytes no es múltiplo de 4 y el bloque arranca desalineado la mitad de
// las veces.
decode: (emit) => /* wgsl */`
let d = load_scale(blk + 208u);
for (var n = 0u; n < 2u; n = n + 1u) {
let qlb = blk + n * 64u;
let qhb = blk + 128u + n * 32u;
let scb = blk + 192u + n * 8u;
let obase = n * 128u;
for (var l4 = 0u; l4 < 32u; l4 = l4 + 4u) {
let is = l4 >> 4u;
let d1 = d * f32(load_i8_at(scb + is));
let d2 = d * f32(load_i8_at(scb + is + 2u));
let d3 = d * f32(load_i8_at(scb + is + 4u));
let d4 = d * f32(load_i8_at(scb + is + 6u));
let w0 = load_u32_at(qlb + l4);
let w32 = load_u32_at(qlb + 32u + l4);
let wh = load_u32_at(qhb + l4);
for (var c = 0u; c < 4u; c = c + 1u) {
let sh = c * 8u;
let lo0 = (w0 >> sh) & 0xFFu;
let lo32 = (w32 >> sh) & 0xFFu;
let h = (wh >> sh) & 0xFFu;
let q1 = i32((lo0 & 0xFu) | (((h >> 0u) & 3u) << 4u)) - 32;
let q2 = i32((lo32 & 0xFu) | (((h >> 2u) & 3u) << 4u)) - 32;
let q3 = i32((lo0 >> 4u) | (((h >> 4u) & 3u) << 4u)) - 32;
let q4 = i32((lo32 >> 4u) | (((h >> 6u) & 3u) << 4u)) - 32;
${emit('obase + l4 + c', 'd1 * f32(q1)')}
${emit('obase + 32u + l4 + c', 'd2 * f32(q2)')}
${emit('obase + 64u + l4 + c', 'd3 * f32(q3)')}
${emit('obase + 96u + l4 + c', 'd4 * f32(q4)')}
}
}
}`,
},
// 256 pesos, 176 bytes: como Q4_K más 32 bytes con el quinto bit. El bit que
// le toca a cada peso avanza DOS posiciones por grupo de 64 (u1 <<= 2).
Q5_K: {
blockElems: 256,
blockBytes: 176,
helpers: SCALE_MIN_K4,
decode: (emit) => /* wgsl */`
let d = load_scale(blk);
let dmin = load_scale(blk + 2u);
for (var j = 0u; j < 4u; j = j + 1u) {
let sm1 = scale_min_k4(blk + 4u, j * 2u);
let sm2 = scale_min_k4(blk + 4u, j * 2u + 1u);
let d1 = d * f32(sm1.x); let m1 = dmin * f32(sm1.y);
let d2 = d * f32(sm2.x); let m2 = dmin * f32(sm2.y);
let u1 = 1u << (j * 2u);
let u2 = 2u << (j * 2u);
let qbase = blk + 48u + j * 32u;
let obase = j * 64u;
for (var l = 0u; l < 8u; l = l + 1u) {
let ql = w[(qbase + l * 4u) / 4u];
let qh = w[(blk + 16u + l * 4u) / 4u];
for (var c = 0u; c < 4u; c = c + 1u) {
let lo = (ql >> (c * 8u)) & 0xFFu;
let hi = (qh >> (c * 8u)) & 0xFFu;
let a = (lo & 0xFu) + select(0u, 16u, (hi & u1) != 0u);
let b = (lo >> 4u) + select(0u, 16u, (hi & u2) != 0u);
${emit('obase + l * 4u + c', 'd1 * f32(a) - m1')}
${emit('obase + 32u + l * 4u + c', 'd2 * f32(b) - m2')}
}
}
}`,
},
// 256 pesos, 66 bytes. Cada 32 pesos: dos palabras. La primera son cuatro
// índices de 8 bits a una rejilla de 256 octetos; la segunda, cuatro paquetes
// de 7 bits de signos más 4 bits de escala local en el tope.
IQ2_XXS: {
blockElems: 256,
blockBytes: 66,
table: 'IQ2XXS',
helpers: '',
decode: (emit) => /* wgsl */`
let d = load_scale(blk);
for (var ib = 0u; ib < 8u; ib = ib + 1u) {
let a0 = load_u32_at(blk + 2u + ib * 8u);
let a1 = load_u32_at(blk + 6u + ib * 8u);
let db = d * (0.5 + f32(a1 >> 28u)) * 0.25;
for (var l = 0u; l < 4u; l = l + 1u) {
let gi = (a0 >> (l * 8u)) & 0xFFu;
// ggml guarda una tabla de 128 bytes de signos; es exactamente el
// índice completado a paridad PAR, así que se calcula en vez de subirla.
let bits = (a1 >> (l * 7u)) & 127u;
let signs = bits | ((countOneBits(bits) & 1u) << 7u);
let g0 = tbl[gi * 2u];
let g1 = tbl[gi * 2u + 1u];
let obase = ib * 32u + l * 8u;
for (var j = 0u; j < 8u; j = j + 1u) {
let gw = select(g0, g1, j >= 4u);
let gv = f32((gw >> ((j & 3u) * 8u)) & 0xFFu);
let sg = select(1.0, -1.0, (signs & (1u << j)) != 0u);
${emit('obase + j', 'db * gv * sg')}
}
}
}`,
},
// 256 pesos, 50 bytes. Cada 32 pesos: cuatro índices de 11 bits (8 en `qs`,
// 3 en `qh`) a una rejilla de 2048 octetos de valores en {-1,0,1}, más una
// escala local de 3 bits y un signo que decide el desplazamiento ±1/8.
// PQ2_0 — ternario en ranuras de 2 bits, bloque de 128. Tampoco es un tipo de
// llama.cpp. 34 bytes: escala f16 + 32 de cuantizacion.
//
// ESTE es el formato que encaja con este kernel, y no por el tamaño —ocupa MAS
// que el de base 3— sino por como reparte. 128 pesos a 2 bits son 32 bytes
// EXACTOS y, con subgrupos de 32 carriles, toca un byte por carril: una carga,
// sin etapas y sin divergencia. Y los cuatro pesos de cada carril son
// CONSECUTIVOS, asi que sus activaciones entran en una lectura vec4.
//
// Comparado con IQ1_S, que por bloque hace tres cargas de peso mas DOS
// lecturas dispersas de una tabla de rejilla indexada por carril. Aqui el peso
// sale de un desplazamiento y una mascara: no hay tabla que leer.
//
// PTQ1_0 no sirve para esto aunque ocupe menos: guarda cinco trits por byte
// en etapas de tamaños distintos (16, 8, y los dos bytes de qh), lo que parte
// los 32 carriles en tres caminos con direcciones distintas.
PQ2_0: {
blockElems: 128,
blockBytes: 34,
helpers: '',
decode: (emit) => /* wgsl */`
let d = load_scale(blk);
for (var i = 0u; i < 32u; i = i + 1u) {
let by = load_byte(blk + 2u + i);
for (var c = 0u; c < 4u; c = c + 1u) {
${emit('i * 4u + c', 'f32(i32((by >> (c * 2u)) & 3u) - 1) * d')}
}
}`,
// Reparto por carril: el carril `sl` se queda el byte `sl`, que son sus
// cuatro pesos. Una carga de peso por carril y por bloque.
decodeCarril: (emit, xv = false) => /* wgsl */`
let d = load_scale(blk);
let by = load_byte(blk + 2u + sl);
let obase = sl * 4u;
${xv ? ` // Los 4 pesos del carril son consecutivos y obase es multiplo de 4, igual
// que k0 = b*128 y toda k del decode: caben en UNA lectura vectorial.
let xb = (base_t * params.k${globalThis.__ELFFUSS_X_FIJA === true ? '' : ' + k0 + obase'}) >> 2u;
let xv0 = x[xb];` : ''}
${Array.from({ length: 4 }, (_, j) => ` {
${emit(`obase + ${j}u`, `f32(i32((by >> ${j * 2}u) & 3u) - 1) * d`, j)}
}`).join('\n')}`,
},
// PTQ1_0 — ternario en base 3, bloque de 128. NO es un tipo de llama.cpp:
// lo define un fork de terceros. 28 bytes: qs[24] · qh[2] · escala f16.
//
// LA DIFERENCIA QUE IMPORTA, y no es el tamaño: NO HAY CODEBOOK. En IQ1_S el
// peso sale de una tabla de rejilla indexada por carril —dos lecturas
// dependientes y dispersas por bloque— y aquí sale de multiplicar un byte por
// una potencia de tres y mirarle los bits de arriba. Cero lecturas de tabla.
//
// El formato mete CINCO trits en un byte (3^5 = 243 <= 256) con el truco
// de siempre: al codificar se escala a 256/243 y al descodificar se recupera
// con `(q * pow3[n] * 3) >> 8`, donde el producto por la potencia va en
// aritmetica de OCHO bits y envuelve a proposito.
//
// El orden de salida NO es el de los bytes: por cada grupo, primero los 16 (u
// 8) pesos de la potencia 0, luego los de la potencia 1, etc. Las etapas son
// {32,16,8} y con qs de 24 bytes dan dos grupos —16 y 8—, o sea 80 + 40
// valores, mas 8 que salen de qh. Total 128.
//
// VALIDADO CONTRA UN TERCERO, no contra si mismo: este mismo esquema con los
// parametros de TQ1_0 (qs de 48 bytes) se reduce al «32 y luego 16» de
// upstream, y da 16.384 valores IDENTICOS BIT A BIT a los de gguf-py. La ida
// y vuelta contra uno mismo no habria distinguido un orden mal entendido.
PTQ1_0: {
blockElems: 128,
blockBytes: 28,
helpers: '',
// `blk` aqui SI esta alineado a 4 (28 es multiplo de 4), al reves que IQ1_S.
decode: (emit) => /* wgsl */`
let d = load_scale(blk + 26u);
var p3 = 1u;
for (var n = 0u; n < 5u; n = n + 1u) {
for (var m = 0u; m < 16u; m = m + 1u) {
let q = (load_byte(blk + m) * p3) & 0xFFu;
${emit('n * 16u + m', 'f32(i32((q * 3u) >> 8u) - 1) * d')}
}
p3 = p3 * 3u;
}
p3 = 1u;
for (var n = 0u; n < 5u; n = n + 1u) {
for (var m = 0u; m < 8u; m = m + 1u) {
let q = (load_byte(blk + 16u + m) * p3) & 0xFFu;
${emit('80u + n * 8u + m', 'f32(i32((q * 3u) >> 8u) - 1) * d')}
}
p3 = p3 * 3u;
}
p3 = 1u;
for (var n = 0u; n < 4u; n = n + 1u) {
for (var h = 0u; h < 2u; h = h + 1u) {
let q = (load_byte(blk + 24u + h) * p3) & 0xFFu;
${emit('120u + n * 2u + h', 'f32(i32((q * 3u) >> 8u) - 1) * d')}
}
p3 = p3 * 3u;
}`,
// REPARTO POR CARRIL. Cuesta mas que en PQ2_0 y lo pagan las direcciones:
// alli 128 pesos a 2 bits son 32 bytes JUSTOS y toca un byte por carril; aqui
// el formato va en tres etapas de tamaños distintos —16 bytes, luego 8, y
// aparte los dos de `qh`— asi que los carriles caen en tres sitios.
//
// Se resuelve con ARITMETICA y no con ramas, para que los 32 carriles emitan
// las mismas instrucciones y solo cambien los numeros. Cada carril se queda
// 4 pesos consecutivos (obase = 4*sl), que es lo que permite la lectura vec4
// de activaciones, y los saca de UNA palabra de 32 bits:
// · carriles 0-19 -> 4 bytes seguidos de qs[0..15], una sola potencia
// · carriles 20-29 -> 4 bytes seguidos de qs[16..23], una sola potencia
// · carriles 30-31 -> los dos bytes de qh, con DOS potencias
// El ultimo caso es el que ensucia: los demas leen cuatro bytes distintos con
// la misma potencia y estos leen dos bytes alternos con potencias que cambian
// a mitad. De ahi que el techo aqui sea peor que en PQ2_0 aunque el fichero
// ocupe menos.
//
// Las tres direcciones se calculan siempre y `select` elige: en WGSL los dos
// brazos de un select se evaluan igual, asi que `sl - 20u` da la vuelta en
// los carriles bajos. No importa — ese valor no llega a usarse como
// direccion, solo el elegido.
decodeCarril: (emit, xv = false) => /* wgsl */`
let d = load_scale(blk + 26u);
let obase = sl * 4u;
// Base de la palabra que le toca a este carril.
let baseG = select(
select(blk + 24u, blk + 16u + ((sl - 20u) & 1u) * 4u, sl < 30u),
blk + (sl & 3u) * 4u, sl < 20u);
let w4 = load_u32_at(baseG);
// Potencia de tres del carril (para los carriles de qh cambia por peso).
let pBase = select(select(2u * (sl - 30u), (sl - 20u) >> 1u, sl < 30u), sl >> 2u, sl < 20u);
let deQh = sl >= 30u;
${xv ? ` // Los 4 pesos del carril son consecutivos y obase es multiplo de 4, igual
// que k0 = b*128 y toda k del decode: una sola lectura vectorial.
let xb = (base_t * params.k${globalThis.__ELFFUSS_X_FIJA === true ? '' : ' + k0 + obase'}) >> 2u;
let xv0 = x[xb];` : ''}
${Array.from({ length: 4 }, (_, j) => ` {
let by = (w4 >> (select(${j}u, ${j & 1}u, deQh) * 8u)) & 0xFFu;
let pe = pBase + select(0u, ${j >> 1}u, deQh);
let p3 = select(select(select(select(1u, 3u, pe >= 1u), 9u, pe >= 2u), 27u, pe >= 3u), 81u, pe >= 4u);
let q = (by * p3) & 0xFFu;
${emit(`obase + ${j}u`, 'f32(i32((q * 3u) >> 8u) - 1) * d', j)}
}`).join('\n')}`,
},
IQ1_S: {
blockElems: 256,
blockBytes: 50,
table: 'IQ1S',
helpers: '',
// Reparto ALTERNATIVO: el carril posee un SUB-GRUPO de 8 pesos en vez de un
// bloque entero. Un bloque son 8 sub-bloques x 4 grupos = 32 unidades de 8
// pesos, que encaja EXACTO con los 32 carriles de un subgrupo.
//
// Por que: con el reparto por bloque, una fila de bpr=20 ocupa 20 carriles de
// 32 y emite 8.192 ranuras-peso para 5.120 utiles (62,5%). Repartiendo por
// sub-grupo, todos los carriles trabajan en TODOS los bloques: 5.120 ranuras,
// todas utiles. El perfil por forma demostro que este kernel esta limitado por
// emision, asi que esa utilizacion se traduce casi 1:1 en tiempo (~x1,5).
//
// Precio: cada carril calcula su propio qh/dl/delta para solo 8 pesos en vez
// de para 32, asi que las operaciones por peso suben ~4%. Y sobre todo NO es
// bit a bit: cambia que sumandos caen en que carril, o sea la particion de la
// suma en coma flotante. Se valida con tolerancia, no con igualdad exacta.
//
// Exige ancho de workgroup 32 (un subgrupo); ops.js no lo activa si no.
decodeCarril: (emit, xv = false) => {
// DESENROLLAR EL BUCLE DE 8 (`__ELFFUSS_DESENROLLA`).
//
// OJO: este comentario decia que «~70% del decode es EMITIR instrucciones».
// REFUTADO por una medida interna con marcas de tiempo del dispositivo:
// el descuantizador entero es el 8,3% del matmul, y traer activaciones el
// 44%. Por eso desenrollar no pagaba: atacaba un 8%. Se conserva el
// interruptor porque es
// bit a bit exacto y es requisito de la lectura vec4. Este
// bucle da 8 vueltas con `j` conocido en compilacion y paga por peso tres
// cosas que desaparecen al desenrollar:
// · el contador, la comparacion y el salto del bucle,
// · `select(g0, g1, j >= 4u)` -> queda g0 o g1, decidido en compilacion,
// · `get_byte_i32(gw, j & 3u)` -> desplazamiento por cantidad CONSTANTE
// en vez de por cantidad variable.
//
// Es BIT A BIT identico por construccion: mismos valores, mismo orden de
// acumulacion (j ascendente), no toca la particion de la suma entre
// carriles. Mismo perfil que izar la guarda, que ya rindio.
//
// Riesgo real: ocho copias del cuerpo suben la presion de registros y
// pueden hundir la ocupancia — asi se perdio la rejilla compartida (x0,44).
// Por eso va detras de un interruptor y se mide antes de quedarse.
// La lectura vec4 exige indices CONSTANTES, asi que fuerza el desenrollado.
const desenrolla = globalThis.__ELFFUSS_DESENROLLA === true || xv;
// ORACULO DEL DESCUANTIZADOR — solo medicion, NUNCA en produccion.
// X_FIJA y W_FIJA acotan el coste de TRAER datos; este acota el de
// TRANSFORMARLOS. Se emite `f32(gw & 1u)` y no una constante a proposito:
// `gw` cuelga de g0/g1, o sea de las dos lecturas de `tbl`. Con una
// constante el compilador mataria tambien esas lecturas y estariamos
// midiendo memoria de rejilla, que W_FIJA YA cuenta — sumar las dos celdas
// contaria ese coste dos veces.
// Acota la cota CONJUNTA de {extraer el byte + la aritmetica por peso},
// no la de un candidato suelto. Da numeros FALSOS por diseno.
// OJO CON LA ETIQUETA: mide MAS que «la aritmetica». Al sustituir `wv`,
// `dl` y `delta` quedan muertas y con ellas `d`, asi que el compilador
// borra tambien `load_scale`. Mide {una carga por bloque} + {toda la
// aritmetica por peso}. `qh` sigue viva porque la usa `gi`.
// ESTA CONTENIDO EN W_FIJA, no es disjunto: con `blk` invariante, todo lo
// que cuelga de el (incluida esta aritmetica) queda fuera del bucle. Son
// ANIDADOS, asi que NO se suman — sumarlos cuenta el mismo coste dos veces
// y es lo que produjo el falso «49% explicado». Cotas validas: x <= 26%,
// w <= 7%, luego sin explicar >= 67%.
const deqPlana = globalThis.__ELFFUSS_DEQ_PLANA === true;
const lazo = desenrolla
? Array.from({ length: 8 }, (_, j) => ` {
let gw = ${j < 4 ? 'g0' : 'g1'};
let gv = f32(get_byte_i32(gw, ${j % 4}u));
${emit(`obase + ${j}u`, deqPlana ? 'f32(gw & 1u)' : 'dl * (gv + delta)', j)}
}`).join('\n')
: ` for (var j = 0u; j < 8u; j = j + 1u) {
let gw = select(g0, g1, j >= 4u);
let gv = f32(get_byte_i32(gw, j & 3u));
${emit('obase + j', deqPlana ? 'f32(gw & 1u)' : 'dl * (gv + delta)')}
}`;
// ORACULO DE LA CADENA DE LA REJILLA (`__ELFFUSS_GI`) — solo medicion.
//
// La cadena real es LECTURA -> LECTURA: `load_byte` (y `qh`) producen `gi`,
// y `gi` es la DIRECCION de `tbl`. En una ejecucion en orden, la segunda carga no
// puede emitirse hasta que vuelve la primera: por bloque se pagan DOS
// latencias en serie en vez de una. Ningun oraculo anterior toca eso:
// W_FIJA cambia direcciones (trafico) y DEQ_PLANA quita aritmetica.
//
// Se sustituye `gi` por un hash de REGISTROS (nada de lecturas), de modo que
// la carga de `tbl` puede emitirse a la vez que la de los pesos. Tres modos,
// que separan tres cosas que la etiqueta «rejilla» confunde:
// hash — divergente y distinto por bloque: rompe SOLO el encadenamiento.
// unif — igual para los 32 carriles: hash-unif = coste de la DIVERGENCIA
// (32 lineas distintas por carril contra una sola difundida).
// inv — no depende de `b`, luego es INVARIANTE del bucle y el compilador
// puede izar las dos lecturas de `tbl` fuera. hash-inv = trafico de
// rejilla por bloque. ADEMAS es el DETECTOR DE IZADO: si inv sale
// igual que hash, o el compilador no iza o izar no vale nada.
//
// TRAMPA CERRADA: si se quita `load_byte` del camino, el compilador la borra
// entera y mediriamos «una carga menos», no «una cadena menos». Por eso su
// valor se conserva vivo por el lado del VALOR (no de la direccion), sumado
// a `dl` enmascarado con `params.pad0`, que vale 0 pero es un UNIFORME que el
// compilador no puede plegar. La carga sigue emitiendose y sigue trayendo los
// mismos bytes; lo unico que desaparece es que `tbl` la ESPERE.
// Cuesta dos operaciones por bloque (mascara y conversion), ~0,3% del ALU.
//
// Los indices salen de la MISMA rejilla de 2048 entradas y sus bytes siguen
// siendo {-1,0,1}, asi que no hay riesgo de desbordar ni de denormales: lo
// que sale es NUMERICAMENTE FALSO, pero acotado igual que lo verdadero.
const modoGi = globalThis.__ELFFUSS_GI;
const SEMILLAS = {
hash: 'lid.x * 2246822519u + b * 40503u + row * 2654435761u',
unif: 'b * 40503u + row * 2654435761u',
inv: 'lid.x * 2246822519u + row * 2654435761u',
};
// Sin este aviso, un modo mal escrito generaria el shader NORMAL bajo una
// clave de pipeline distinta: dos ramas identicas midiendo x1,00 y una
// conclusion («la cadena no pesa») que solo dice que hubo una errata.
if (modoGi !== undefined && !(modoGi in SEMILLAS)) {
throw new Error(`__ELFFUSS_GI desconocido: «${modoGi}» (hash|unif|inv)`);
}
// El orden de las tres lineas del control es el de SIEMPRE, byte a byte: en
// el oraculo `dl` consume `raw` y tiene que ir detras, pero en produccion no
// se mueve ni un espacio para no cambiar el reparto de registros.
const nucleo = modoGi === undefined
? ` let dl = d * f32(2u * ((qh >> 12u) & 7u) + 1u);
let delta = select(0.125, -0.125, (qh & 0x8000u) != 0u);
let gi = load_byte(blk + 2u + ib * 4u + l) | (((qh >> (3u * l)) & 7u) << 8u);`
: ` let raw = load_byte(blk + 2u + ib * 4u + l) | (((qh >> (3u * l)) & 7u) << 8u);
let gi = (((${SEMILLAS[modoGi]}) * 2654435761u) >> 13u) & 2047u;
let dl = d * f32(2u * ((qh >> 12u) & 7u) + 1u) + f32(raw & params.pad0);
let delta = select(0.125, -0.125, (qh & 0x8000u) != 0u);`;
// IZAR LAS CARGAS INDEPENDIENTES (`__ELFFUSS_IZA_CARGAS`).
//
// El orden de siempre emite las siete cargas del bloque asi:
// load_scale(blk) · load_u16_at(qh) · USA las dos -> PARADA
// load_byte(qs) · tbl[gi] x2 -> PARADA · y AL FINAL las dos vec4 de x.
//
// Cinco de esas siete cargas son INDEPENDIENTES entre si: `load_scale`,
// `load_u16_at`, `load_byte` (su direccion sale de blk/ib/l, NO del valor
// de qh) y las dos de activaciones (que no dependen de nada del cuerpo).
// Y aun asi las tres ultimas se emiten detras de dos esperas evitables,
// porque el fuente las escribe despues.
//
// POR QUE ESTO Y NO OTRA COSA. Las hipotesis anteriores miden trafico,
// ALU, registros, ocupancia y encadenamiento; ninguna mide el NUMERO DE
// CARGAS EXPUESTAS. Con la aritmetica del bloque, la latencia de esas
// siete cargas explicaria la mayor parte de la espera medida, que es el
// hueco que ningun oraculo explicaba.
//
// No cambia NI UNA operacion: mismos valores, mismo orden de acumulacion,
// bit a bit identico por construccion. Solo cambia en que orden pide las
// cosas. Si el compilador ya reordenaba, esto sale x1,00 y cierra el
// angulo — que tambien es un resultado.
//
// Se deja FUERA de los caminos de oraculo (modoGi definido) a proposito:
// esos bancos comparan contra un orden concreto y moverlo les cambiaria el
// reparto de registros bajo los pies.
const izaCargas = globalThis.__ELFFUSS_IZA_CARGAS === true
&& xv && modoGi === undefined;
// LECTURA COOPERATIVA DEL BLOQUE (`__ELFFUSS_BLOQUE_COOP`).
//
// El bloque son 50 bytes —escala, 32 de cuantizacion y 16 de qh— y es el
// MISMO para los 32 carriles: `blk` sale de la fila y del indice de bloque,
// no del carril. Aun asi cada carril hace TRES lecturas dentro de el. Entre
// los 32 sobra de largo para traerlo con UNA: 50 bytes son 13 palabras, las
// trae un carril cada una y luego se reparten con `subgroupShuffle`, que va
// a velocidad de ALU y no de memoria.
//
// POR QUE SE ESPERA QUE ESTO SI Y EL IZADO NO. Reordenar quito CERO cargas
// y no cambió nada medible: el planificador ya solapaba. Pero
// la rama `giinv` del oraculo de la cadena, que saca DOS cargas del bucle,
// vale -19,3%. Las dos medidas juntas dan un modelo simple: el orden es
// gratis y cada instruccion de carga cuesta ~10% del matmul. Aqui se pasa
// de tres lecturas de peso a una: -2 cargas, luego la prediccion es ~19%.
// Si sale muy por debajo, el modelo de «coste por carga» es falso y hay que
// tirarlo entero, no ajustarlo.
//
// El indice se CLAMPA a la ultima palabra del buffer. `blk` no esta alineado
// a 4 (50 no es multiplo de 4, asi que `blk & 3` alterna 0 y 2) y la palabra
// 12 del ultimo bloque roza dos bytes mas alla del final. Esos dos bytes no
// se usan, pero una lectura fuera de rango podria devolver cero y llevarse
// por delante los dos que SI se usan.
const bloqueCoop = globalThis.__ELFFUSS_BLOQUE_COOP === true
&& xv && modoGi === undefined;
const comentarioX = ` // Los 8 pesos del carril caen en DOS vec4 completos: obase = ib*32 + l*8 es
// multiplo de 8 y k0 = b*256 de 4, luego (k0 + obase) es multiplo de 4 y
// toda k del decode (5120, 6144, 17408) tambien. Dos cargas vectoriales en
// vez de ocho escalares con zancada de 32 bytes.`;
const dirX = `(base_t * params.k${globalThis.__ELFFUSS_X_FIJA === true ? '' : ' + k0 + obase'}) >> 2u`;
if (bloqueCoop) {
// `rel(r)` = palabra RELATIVA donde cae el byte `blk + r`, y `des(r, m)`
// el desplazamiento dentro de ella. Sale de que blk/4 es suelo:
// (blk + r)/4 = blk/4 + ((blk&3) + r)/4
const rel = (r) => `((off + ${r}) >> 2u)`;
const des = (r, m) => `(((off + ${r}) & ${m}u) * 8u)`;
return /* wgsl */`
let ib = sl >> 2u;
let l = sl & 3u;
let obase = ib * 32u + l * 8u;
${comentarioX}
let xb = ${dirX};
let xv0 = x[xb];
let xv1 = x[xb + 1u];
// UNA lectura de peso para todo el subgrupo: 13 carriles traen una palabra
// cada uno y el bloque entero queda repartido entre los registros.
let base = blk >> 2u;
let off = blk & 3u;
let tope = arrayLength(&w) - 1u;
let mio = select(0u, w[min(base + sl, tope)], sl < 13u);
let pqs = subgroupShuffle(mio, ${rel('2u + ib * 4u + l')});
let pqh = subgroupShuffle(mio, ${rel('34u + ib * 2u')});
let pd = subgroupShuffle(mio, ${rel('0u')});
let gb = (pqs >> ${des('2u + ib * 4u + l', 3)}) & 0xFFu;
let qh = (pqh >> ${des('34u + ib * 2u', 2)}) & 0xFFFFu;
let d = unpack2x16float((pd >> ${des('0u', 2)}) & 0xFFFFu)[0];
let gi = gb | (((qh >> (3u * l)) & 7u) << 8u);
let g0 = tbl[gi * 2u];
let g1 = tbl[gi * 2u + 1u];
let dl = d * f32(2u * ((qh >> 12u) & 7u) + 1u);
let delta = select(0.125, -0.125, (qh & 0x8000u) != 0u);
${lazo}`;
}
if (izaCargas) {
return /* wgsl */`
let ib = sl >> 2u;
let l = sl & 3u;
let obase = ib * 32u + l * 8u;
${comentarioX}
// Las CINCO cargas independientes primero, seguidas, sin que ninguna
// espere a la anterior. Solo despues empieza lo que depende de ellas.
let xb = ${dirX};
let xv0 = x[xb];
let xv1 = x[xb + 1u];
let d = load_scale(blk);
let qh = load_u16_at(blk + 34u + ib * 2u);
let gb = load_byte(blk + 2u + ib * 4u + l);
let gi = gb | (((qh >> (3u * l)) & 7u) << 8u);
let g0 = tbl[gi * 2u];
let g1 = tbl[gi * 2u + 1u];
let dl = d * f32(2u * ((qh >> 12u) & 7u) + 1u);
let delta = select(0.125, -0.125, (qh & 0x8000u) != 0u);
${lazo}`;
}
return /* wgsl */`
let d = load_scale(blk);
let ib = sl >> 2u;
let l = sl & 3u;
let qh = load_u16_at(blk + 34u + ib * 2u);
${nucleo}
let g0 = tbl[gi * 2u];
let g1 = tbl[gi * 2u + 1u];
let obase = ib * 32u + l * 8u;
${xv ? `${comentarioX}
let xb = ${dirX};
let xv0 = x[xb];
let xv1 = x[xb + 1u];` : ''}
${lazo}`;
},
decode: (emit) => /* wgsl */`
let d = load_scale(blk);
for (var ib = 0u; ib < 8u; ib = ib + 1u) {
let qh = load_u16_at(blk + 34u + ib * 2u);
let dl = d * f32(2u * ((qh >> 12u) & 7u) + 1u);
let delta = select(0.125, -0.125, (qh & 0x8000u) != 0u);
for (var l = 0u; l < 4u; l = l + 1u) {
let gi = load_byte(blk + 2u + ib * 4u + l) | (((qh >> (3u * l)) & 7u) << 8u);
let g0 = tbl[gi * 2u];
let g1 = tbl[gi * 2u + 1u];
let obase = ib * 32u + l * 8u;
for (var j = 0u; j < 8u; j = j + 1u) {
let gw = select(g0, g1, j >= 4u);
let gv = f32(get_byte_i32(gw, j & 3u));
${emit('obase + j', 'dl * (gv + delta)')}
}
}
}`,
},
// ── Q8_0 y Q4_0 REORDENADOS al cargar (`__ELFFUSS_REPACK`) ────────────────
// Tipos internos, nunca en un GGUF: el cargador los pone cuando reordena
// (repack.js) y el formato está en `kernels.bloques.wgsl.js`. Los mismos bytes
// que Q8_0/Q4_0 en otro orden: los cuantos de cada bloque alineados y las
// escalas todas juntas al final.
//
// Cada uno es una COPIA de su descodificador del GGUF con las dos lecturas
// cambiadas, y nada más: `load_scale(blk)` pasa a `bq_escala(bi)` y la palabra
// de cuantos que salía de `load_u32_at` (dos lecturas y un select, porque el
// bloque arranca a media palabra la mitad de las veces) pasa a `bq_palabra`,
// una lectura alineada. Son los mismos 32 bits y el mismo f32 de escala, y la
// expresión de cada peso y el orden en que se emiten son carácter por
// carácter los del original: el andamio acumula exactamente lo mismo y la
// salida tiene que ser idéntica BIT A BIT a la del tipo de origen. Así se
// valida, no con tolerancia.
//
// `blk` lo sigue calculando el andamio como si el formato fuera el del GGUF
// —(fila·bpr + b)·34—, así que aquí se divide por el tamaño del bloque para
// recuperar su índice. Es una división por constante por bloque de 32 pesos,
// y deja sin tocar el direccionamiento de los tres andamios de aquí (matmul,
// dequant y gather). El GEMM en teselas y la descuantización drift tienen su
// propia tabla por tipo (`TIRADAS`, `CUATRO`) y llevan allí su entrada R.
//
// `blockBytes` es lo que ocupa un bloque DE MEDIA (cuantos más su escala), no
// la zancada: los bloques R no van seguidos. Sirve para contar bytes de un
// tensor entero, NO para cortarlo por filas (fila·bpr·blockBytes cae en
// cuantos de otra fila y deja sus escalas atrás).
Q8_0R: {
blockElems: Q8_BLOCK,
blockBytes: Q8_BLOCK_BYTES, // 34 de media: los cuantos más su escala
helpers: bloquesWGSL('Q8_0R'),
decode: (emit) => /* wgsl */`
let bi = blk / ${Q8_BLOCK_BYTES}u;
let d = bq_escala(bi);
for (var i = 0u; i < 8u; i = i + 1u) {
let q = bq_palabra(bi, i);
for (var c = 0u; c < 4u; c = c + 1u) {
${emit('i * 4u + c', 'f32(get_byte_i32(q, c)) * d')}
}
}`,
},
Q4_0R: {
blockElems: 32,
blockBytes: 18, // de media, como en Q8_0R: no es una zancada
helpers: bloquesWGSL('Q4_0R'),
decode: (emit) => /* wgsl */`
let bi = blk / 18u;
let d = bq_escala(bi);
for (var i = 0u; i < 4u; i = i + 1u) {
let q = bq_palabra(bi, i);
for (var c = 0u; c < 4u; c = c + 1u) {
let by = (q >> (c * 8u)) & 0xFFu;
${emit('i * 4u + c', 'f32(i32(by & 0xFu) - 8) * d')}
${emit('i * 4u + c + 16u', 'f32(i32(by >> 4u) - 8) * d')}
}
}`,
},
};
// Metadatos por tipo, para quien tenga que reservar buffers o cortar shards.
export const QUANT_TYPES = Object.fromEntries(
Object.entries(DECODERS).map(([name, d]) => [name, {
name, blockElems: d.blockElems, blockBytes: d.blockBytes, table: d.table || null,
}]));
export function quantInfo(type) {
const d = DECODERS[type];
if (!d) throw new Error(`tipo de cuantización no soportado: «${type}»`);
return d;
}
// ── Andamios ────────────────────────────────────────────────────────────────
// Descuantiza un tensor entero a f32. Existe para el test: es el kernel que
// permite comparar contra una referencia de CPU peso a peso, que es donde se
// caza una descodificación mal hecha. En el forward no se usa — ahí descuantiza
// el matmul, sin materializar nada.
export function dequantShader(type, workgroupSize = 64) {
const d = quantInfo(type);
const emit = (idx, val) => ` out[dst + (${idx})] = ${val};`;
return /* wgsl */`
struct Params { nBlocks: u32, blocksPerRow: u32, rows: u32, k: u32 };
@group(0) @binding(0) var<storage, read> w : array<u32>;
@group(0) @binding(1) var<storage, read_write> out : array<f32>;
@group(0) @binding(2) var<uniform> params : Params;
${d.table ? '@group(0) @binding(3) var<storage, read> tbl : array<u32>;' : ''}
${HELPERS}${d.helpers}
@compute @workgroup_size(${workgroupSize})
fn main(@builtin(global_invocation_id) gid : vec3<u32>) {
let b = gid.x + gid.y * ${AXIS}u * ${workgroupSize}u;
if (b >= params.nBlocks) { return; }
let blk = b * ${d.blockBytes}u;
let dst = b * ${d.blockElems}u;
{${d.decode(emit)}
}
}`;
}
// y[fila] = Σ_k A[fila][k] · x[k], con A cuantizada y x/y en f32.
// Un workgroup por fila de salida: cada hilo recorre bloques a saltos y luego se
// reduce en árbol por memoria compartida. Es el kernel del bucle de decode, que
// es donde el modelo pasa el 99 % del tiempo.
//
// Con `tokens = 1` esto ES el matvec del decode. Con más, es el matmul del
// prefill: un workgroup por (fila de salida, GRUPO de TILE tokens). Las
// activaciones van token-major (k contiguo por token), igual que las consume
// RoPE, así que no hace falta transponer nada entre operaciones.
// Cuantos SUBGRUPOS por workgroup llevan cada uno SU fila. Vive aqui, junto al
// shader que lo aplica, y lo llama ops.js para el despacho: si el predicado se
// duplicara en los dos sitios y se desincronizaran, saldrian filas a cero sin un
// solo error. Ya paso una vez.
export function sgFilasPorGrupo(type, workgroupSize, tile, carrilSubbloque, rows, subgroup, sgSize = 32) {
if (!subgroup || tile !== 1) return 1;
const d = DECODERS[type];
const porCarril = carrilSubbloque && workgroupSize % sgSize === 0
&& d && typeof d.decodeCarril === 'function';
if (!porCarril) return 1;
const s = Math.max(1, Math.floor(workgroupSize / sgSize));
// `rows` multiplo de S: sin esto el ultimo grupo escribiria fuera de rango.
if (s === 1 || (Number.isFinite(rows) && rows % s !== 0)) return 1;
return s;
}
export function matmulShader(type, workgroupSize = 64, tile = 1, subgroup = false, sgSize = 32, carrilSubbloque = false) {
const d = quantInfo(type);
// Cuántos subgrupos hay en el workgroup. Con 1 (ancho = tamaño de subgrupo),
// `subgroupAdd` da la suma entera sin nada más. Con varios (p. ej. 64 hilos =
// 2 subgrupos de 32), cada subgrupo suma lo suyo y se combinan los pocos
// parciales por memoria compartida con UNA barrera — aun así muchísimo menos
// que la reducción en árbol. Más hilos por fila esconden mejor la latencia de
// las lecturas dependientes de la rejilla i-quant, que es lo que frena IQ1_S.
const numSg = subgroup ? Math.max(1, Math.floor(workgroupSize / sgSize)) : 1;
// Solo tiene sentido con un workgroup de 32 carriles (= las 32 unidades de 8
// pesos que tiene un bloque) y en los tipos que aportan `decodeCarril`.
const porCarril = carrilSubbloque && workgroupSize % sgSize === 0
&& typeof d.decodeCarril === 'function';
// Mismo predicado que usa ops.js. El shader NO conoce `rows`, asi que la
// comprobacion de «rows multiplo de S» la hace SOLO ops.js: aqui se pasa
// `Infinity` para no fingir que se comprueba algo que no se comprueba. Si
// ops.js decide 1 por ese motivo, usa wg=32 y aqui sgFilas sale 1 tambien.
const sgFilas = sgFilasPorGrupo(type, workgroupSize, tile, carrilSubbloque,
Infinity, subgroup, sgSize);
// La lectura vectorial de `x` exige TRES cosas: reparto por carril (los 8
// pesos del carril son contiguos y alineados), guarda izada (tile===1, o sea
// decode: en prefill haria falta un vec4 por token) y el interruptor.
const xv = globalThis.__ELFFUSS_X_VEC4 !== false && porCarril
&& tile === 1 && !globalThis.__ELFFUSS_GUARDA_POR_PESO;
// Reducción por SUBGRUPO en vez de en árbol. La versión de árbol reduce los
// acumuladores de los `workgroupSize` hilos con memoria compartida y una
// barrera por paso (6 con 64 hilos). Si el workgroup es EXACTAMENTE un subgrupo
// (ops.js lo garantiza fijando el ancho al tamaño de subgrupo del dispositivo,
// 32 en muchos adaptadores), `subgroupAdd` hace esa misma suma en una instrucción, sin
// barreras ni memoria compartida. En el matvec del decode la reducción pesa,
// así que esto va al grano. La numérica es la misma suma (mismo orden no está
// garantizado a nivel de bit, pero es una suma de flotantes dentro de la misma
// tolerancia que valida la prueba de cuantización).
// Un acumulador por token del grupo, en variables SUELTAS y no en un array.
// Con array<f32,N> e índice dinámico, el compilador no puede dejarlo en
// registros y lo baja a memoria: cada acumulación pasa a ser un acceso, y el
// teselado deja de compensar. Desenrollado, son registros de verdad.
// El valor se ata a un `let` ANTES de repartirlo entre los acumuladores. Si se
// interpolase la expresión dentro de cada línea, un tile de 8 descuantizaría
// el mismo peso ocho veces y el teselado costaría más de lo que ahorra.
// La guarda de token se IZA cuando no puede ser falsa. Con tile=1 el matmul se
// llama siempre con tokens=1 (ops.js: `tile = tokens > 1 ? TILE_PREFILL : 1`),
// el despacho lanza ceil(1/1)=1 grupo en z, luego base_t=0 y `0 < 1` es cierto
// SIEMPRE. Aun asi se evaluaba una vez POR PESO: 20.510 millones de sumas y
// comparaciones por token que no deciden nada.
//
// No es cosmetica: el perfil por forma dice que este kernel esta limitado por
// EMISION de instrucciones (el rendimiento sigue a la utilizacion de carriles,
// no es plano como seria si mandaran las transacciones de memoria). Con ~11
// operaciones-carril por peso, quitar una es ~9% del trabajo emitido, y ademas
// es el cambio mas limpio posible: no desenrolla, no toca registros, no cambia
// el orden de acumulacion. Bit a bit identico por construccion.
//
// En prefill (tile>1) la guarda SI puede ser falsa —el ultimo grupo de tokens
// va incompleto— y se conserva tal cual.
// AVISO para quien quiera izar la guarda tambien en prefill: la condicion
// natural seria `tokens % tile === 0`, y entonces la clave de pipeline de
// ops.js TENDRIA que llevarla. Hoy la clave lleva el `tile` pero no si la
// guarda se izo, y no hace falta porque `tile === 1` equivale a
// `tokens === 1` (ops.js: `tile = tokens > 1 ? TILE_PREFILL : 1`), donde
// base_t = 0 < 1 siempre. Si se relaja esa condicion sin tocar la clave, un
// shader compilado para un lote completo se reutilizaria en el ultimo lote
// incompleto y descartaria tokens EN SILENCIO.
const guardaIzable = tile === 1 && !globalThis.__ELFFUSS_GUARDA_POR_PESO;
// ORACULO DEL COSTE DE `x` — solo para medir, NUNCA en produccion.
//
// Una medida interna de patrones de acceso dice que nuestro acceso a `x` (cada
// carril con zancada de 8 flotantes) rinde x0,31 de un acceso coalescido en
// cache, y que vectorizarlo daria x4,11. Pero x4,11 sobre el termino de `x`
// solo importa si ese termino pesa: sobre el 10% del tiempo no es nada, sobre
// el 60% lo cambia todo. Eso no se puede estimar, hay que medirlo.
//
// Con el interruptor puesto, los 32 carriles leen la MISMA posicion de `x` en
// vez de 32 con zancada. El numero de FMA no cambia; lo que desaparece es la
// carga divergente (y ademas queda invariante del bucle, asi que el compilador
// la iza fuera). La diferencia de tiempo contra el kernel normal ES el coste
// del termino de `x`.
//
// Se lee una posicion FIJA en lugar de quitar la lectura a propósito: sin
// ninguna referencia a `x`, `layout:'auto'` deduciria un layout sin el binding
// 1 y el bind group dejaria de ser valido — sin lanzar, devolviendo ceros.
// Devuelve resultados NUMERICAMENTE FALSOS por diseño.
const xFija = globalThis.__ELFFUSS_X_FIJA === true;
// OJO CON LA ETIQUETA: esto NO mide «traer pesos» en el sentido de las
// instrucciones de carga — esas se siguen emitiendo igual. Al fijar la
// direccion, mide el coste del TRAFICO de pesos distintos: fallos de cache
// y DRAM. Y CONTIENE a DEQ_PLANA: al perder `blk` el `+ b`, todo lo que
// cuelga de `blk` queda invariante del bucle. Que DEQ_PLANA mida MAS que
// este (15,5% > 7,4%) es imposible => uno de los dos esta roto, y lo mas
// probable es que este salga deprimido porque `blk` constante Y CONOCIDO
// deja izar el lado del peso entero. NO sumar los dos: cuenta dos veces.
const wFija = globalThis.__ELFFUSS_W_FIJA === true;
const xVec4 = globalThis.__ELFFUSS_X_VEC4 === true;
const desp = xFija ? '' : ' + kk';
// Con `xv`, los 8 flotantes del carril ya estan en dos vec4 leidos fuera del
// bucle, asi que aqui solo queda el FMA. Se usa SWIZZLE (.x/.y/.z/.w) y no
// indice: indexar un vec4 declarado con `let` solo es legal con constante, y
// el swizzle no tiene esa ambiguedad. `j` solo llega del cuerpo desenrollado.
const COMP = ['x', 'y', 'z', 'w'];
// ORACULO DE LA CADENA DEL ACUMULADOR (`__ELFFUSS_ACUMS`) — mide, y ademas
// PODRIA quedarse si gana (no es bit a bit: cambia la particion de la suma).
//
// Hoy `acc0` encadena bpr*8 FMA en serie: 160 de profundidad con bpr=20. Cada
// FMA tiene que esperar al anterior. Con N acumuladores independientes son N
// cadenas de 160/N que pueden solaparse, y al final se refunden.
//
// Solo tiene sentido en el camino vec4 (decode, reparto por carril), que es
// donde `j` es constante de compilacion y hay un unico acumulador de token.
// Con N=1 el texto generado es IDENTICO al de produccion, byte a byte: es el
// control de la tanda y a la vez la garantia de que el interruptor apagado no
// toca nada.
// Lastre de registros: N acumuladores vivos de mas, plegados al final por
// `params.pad0` (=0 en ejecucion, desconocido para el compilador). Bit a bit
// exacto: suma cero. Solo para la escalera de ocupancia.
const nlastre = Math.min(32, Math.max(0, (globalThis.__ELFFUSS_LASTRE | 0) || 0));
const declLastre = nlastre > 0
? '\n' + Array.from({ length: nlastre }, (_, i) => ` var lastre${i} = f32(${i + 1}u);`).join('\n')
: '';
const fundeLastre = nlastre > 0
? `\n acc0 = acc0 + (${Array.from({ length: nlastre }, (_, i) => `lastre${i}`).join(' + ')}) * f32(params.pad0);`
: '';
const nacum = xv ? Math.min(8, Math.max(1, (globalThis.__ELFFUSS_ACUMS | 0) || 1)) : 1;
const AC = (j) => (nacum > 1 && (j % nacum) !== 0 ? `accb${j % nacum}` : 'acc0');
const declAcum = nacum > 1
? '\n' + Array.from({ length: nacum - 1 }, (_, i) => ` var accb${i + 1} = 0.0;`).join('\n')
: '';
// Refundido en ARBOL y no en cascada: en cascada volveria a crear una cadena
// serie de N-1 sumas justo donde se quiere demostrar que las cadenas cuestan.
const arbol = (ns) => (ns.length === 1 ? ns[0]
: `(${arbol(ns.slice(0, ns.length >> 1))} + ${arbol(ns.slice(ns.length >> 1))})`);
const fundeAcum = nacum > 1
? `\n acc0 = ${arbol(['acc0', ...Array.from({ length: nacum - 1 }, (_, i) => `accb${i + 1}`)])};`
: '';
const emit = (idx, val, j) => (xv && j !== undefined
? [
' {',
` let wv = ${val};`,
` ${AC(j)} = ${AC(j)} + wv * ${j < 4 ? 'xv0' : 'xv1'}.${COMP[j % 4]};`,
' }',
]
: [
' {',
` let wv = ${val};`,
` let kk = k0 + (${idx});`,
...(guardaIzable
? [` acc0 = acc0 + wv * x[base_t * params.k${desp}];`]
: Array.from({ length: tile }, (_, t) =>
` if (base_t + ${t}u < params.tokens) { acc${t} = acc${t} + wv * ` +
`x[(base_t + ${t}u) * params.k${desp}]; }`)),
' }',
]).join('\n');
return /* wgsl */`${subgroup ? 'enable subgroups;\n' : ''}
const TILE : u32 = ${tile}u;
struct Params { nBlocks: u32, blocksPerRow: u32, rows: u32, k: u32,
tokens: u32, pad0: u32, pad1: u32, pad2: u32 };
@group(0) @binding(0) var<storage, read> w : array<u32>;
${xv ? '@group(0) @binding(1) var<storage, read> x : array<vec4<f32>>;' : '@group(0) @binding(1) var<storage, read> x : array<f32>;'}
@group(0) @binding(2) var<storage, read_write> y : array<f32>;
@group(0) @binding(3) var<uniform> params : Params;
${d.table ? '@group(0) @binding(4) var<storage, read> tbl : array<u32>;' : ''}
${HELPERS}${d.helpers}
${subgroup ? (numSg > 1 && sgFilas === 1 ? `var<workgroup> sgpart : array<f32, ${numSg}u>;` : '') : `var<workgroup> partial : array<f32, ${workgroupSize}>;`}
@compute @workgroup_size(${workgroupSize})
fn main(@builtin(workgroup_id) wid : vec3<u32>,
@builtin(local_invocation_id) lid : vec3<u32>${subgroup && numSg > 1 ? ',\n @builtin(subgroup_invocation_id) sglane : u32' : ''}) {
// Las filas van en dos ejes porque uno solo topa en 65.535 y la cabeza de
// salida son 248.320 filas. El tercer eje son GRUPOS de TILE tokens.
// Carril LOCAL al subgrupo: con varios subgrupos por workgroup, lid.x pasa de
// 31 y el reparto por carril (ib, l) se saldria de rango. Con un subgrupo es
// exactamente lid.x.
${porCarril ? `let sl = lid.x & ${sgSize - 1}u;` : '// sin reparto por carril no hace falta el indice de carril (ver kernels.wgsl.js)'}
${sgFilas > 1
? `// Una fila por SUBGRUPO: cada punto de la rejilla son ${sgFilas} filas.
let row = (wid.x + wid.y * ${AXIS}u) * ${sgFilas}u + lid.x / ${sgSize}u;`
: `let row = wid.x + wid.y * ${AXIS}u;`}
let base_t = wid.z * TILE;
let bpr = params.blocksPerRow;
${Array.from({ length: tile }, (_, t) => ` var acc${t} = 0.0;`).join('\n')}${declAcum}${declLastre}
if (row < params.rows) {
${porCarril
? ` // Reparto por SUB-GRUPO: todos los carriles avanzan por el MISMO bloque y
// cada uno se ocupa de 8 pesos. Cero carriles ociosos sea cual sea bpr, y de
// paso los 32 carriles leen un tramo CONTIGUO de activaciones en vez de 32
// tramos dispersos. Ver decodeCarril.
for (var b = 0u; b < bpr; b = b + 1u) {`
: ` for (var b = lid.x; b < bpr; b = b + ${workgroupSize}u) {`}
let blk = (row * bpr${wFija ? '' : ' + b'}) * ${d.blockBytes}u;
let k0 = b * ${d.blockElems}u;
{${porCarril ? d.decodeCarril(emit, xv) : d.decode(emit)}
}
}
}${fundeAcum}${fundeLastre}
// Reducción por token del grupo. Con subgrupo, una instrucción por token; en
// árbol, memoria compartida y una barrera por paso. El recorrido del árbol es
// constante de compilación, así que las barreras quedan en flujo uniforme.
${subgroup
? (sgFilas > 1
? Array.from({ length: tile }, (_, t) => ` {
let tot${t} = subgroupAdd(acc${t});
if (sglane == 0u && row < params.rows && base_t + ${t}u < params.tokens) {
y[(base_t + ${t}u) * params.rows + row] = tot${t};
}
}`).join('\n')
: numSg === 1
? Array.from({ length: tile }, (_, t) => ` {
let tot${t} = subgroupAdd(acc${t});
if (lid.x == 0u && row < params.rows && base_t + ${t}u < params.tokens) {
y[(base_t + ${t}u) * params.rows + row] = tot${t};
}
}`).join('\n')
: Array.from({ length: tile }, (_, t) => ` {
let s${t} = subgroupAdd(acc${t});
if (sglane == 0u) { sgpart[lid.x / ${sgSize}u] = s${t}; }
workgroupBarrier();
if (lid.x == 0u && row < params.rows && base_t + ${t}u < params.tokens) {
var tot${t} = 0.0;
for (var q = 0u; q < ${numSg}u; q = q + 1u) { tot${t} = tot${t} + sgpart[q]; }
y[(base_t + ${t}u) * params.rows + row] = tot${t};
}
workgroupBarrier();
}`).join('\n'))
: Array.from({ length: tile }, (_, t) => ` partial[lid.x] = acc${t};
workgroupBarrier();
for (var s${t} = ${workgroupSize >> 1}u; s${t} > 0u; s${t} = s${t} >> 1u) {
if (lid.x < s${t}) { partial[lid.x] = partial[lid.x] + partial[lid.x + s${t}]; }
workgroupBarrier();
}
if (lid.x == 0u && row < params.rows && base_t + ${t}u < params.tokens) {
y[(base_t + ${t}u) * params.rows + row] = partial[0];
}
workgroupBarrier(); // WAR: el token siguiente reescribe partial`).join('\n')}
}`;
}
// Busca las filas `ids` de una tabla cuantizada y las deja en f32.
// La tabla de embeddings es de los tensores más grandes del modelo: descuantizarla
// entera para leer unas pocas filas costaría muchas veces lo que se lee.
//
// El grano es el BLOQUE, no el elemento. Sacar un peso suelto de un K-quant
// obligaría a escribir un segundo descodificador «de un solo elemento» por
// tipo, distinto del que usa el matmul — o sea, seis oportunidades más de
// equivocarse en el layout. Descodificando bloques enteros se reutiliza tal cual
// el descodificador ya verificado, y lo único que se paga es descartar los pesos
// del bloque que no hacían falta, que en un embedding es ninguno: se quiere la
// fila entera.
export function gatherShader(type, workgroupSize = 64) {
const d = quantInfo(type);
const emit = (idx, val) => ` dst[base + (${idx})] = ${val};`;
return /* wgsl */`
struct P { dim : u32, tokens : u32, blocksPerRow : u32, pad : u32 };
@group(0) @binding(0) var<storage, read> w : array<u32>;
@group(0) @binding(1) var<storage, read> ids : array<u32>;
@group(0) @binding(2) var<storage, read_write> dst : array<f32>;
@group(0) @binding(3) var<uniform> p : P;
${d.table ? '@group(0) @binding(4) var<storage, read> tbl : array<u32>;' : ''}
${HELPERS}${d.helpers}
@compute @workgroup_size(${workgroupSize})
fn main(@builtin(global_invocation_id) gid : vec3<u32>) {
let i = gid.x + gid.y * ${AXIS}u * ${workgroupSize}u;
if (i >= p.tokens * p.blocksPerRow) { return; }
let t = i / p.blocksPerRow;
let b = i % p.blocksPerRow;
let blk = (ids[t] * p.blocksPerRow + b) * ${d.blockBytes}u;
let base = t * p.dim + b * ${d.blockElems}u;
{${d.decode(emit)}
}
}`;
}
// Los alias `dequantQ8Shader`/`matmulQ8Shader`/`matvecQ8Shader` ya no existen:
// nadie los llamaba una vez que `ops.js` pasa el tipo, y dejarlos puestos habría
// sido una compatibilidad con nada.
|