// SPDX-License-Identifier: Apache-2.0 // Copyright (c) 2026 UtopiaIA // Elffuss Runtime · kernels de fila FUSIONADOS: varias operaciones pequeñas en un despacho. // ───────────────────────────────────────────────────────────────────────────── // Un token de generación son cientos de despachos y la mayoría NO son // multiplicaciones de matrices: normas, sumas, cortes, copias. Cada uno lee y // escribe un vector diminuto y paga entero el coste fijo de un despacho // (grabarlo, su bind group, su uniforme, la barrera con el anterior). Aquí se // juntan las cadenas que siempre van seguidas: // // F1 post-norma + suma residual + norma siguiente (3 despachos → 1) // F2 embedding + norma de entrada de la primera capa (2 → 1) // F4 la convolución corta de lfm3 tras `in_proj` (8 → 1) // F6 QK-norm + RoPE + escritura de K y V en la caché (6 → 1, o 6 → 2 partido // cuando el dispositivo no da buffers para un solo despacho) // // EL CONTRATO ES BIT A BIT. No «parecido»: el mismo resultado que la cadena de // siempre hasta el último bit, y por eso se puede encender sin volver a validar // la numérica del modelo. Eso obliga a tres cosas, y las tres son a propósito: // 1. las MISMAS operaciones en el mismo orden: `(x·s)·w` y no `x·(s·w)`, // `res + y` con los mismos operandos, la suma de la conv de r=0 a r=K-1; // 2. el MISMO árbol de reducción que `rmsnormShader`: grupos de 128 hilos, // cada hilo suma EN SERIE sus columnas (c, c+128, c+256, …) y después el // árbol por memoria compartida. Otro reparto daría la misma suma con otra // partición, y los últimos bits cambiarían; // 3. los MISMOS redondeos intermedios. En la cadena, cada resultado pasa por // memoria como f32. Dentro de un kernel, un compilador con contracción // puede fundir `a + b·c` en una sola operación y saltarse el redondeo de // `b·c`, o reasociar un producto con el siguiente. `corta()` lo impide: un // XOR con un cero que el compilador no puede ver (viene del uniforme) // obliga a materializar el f32 justo donde la cadena lo guardaba. Es la // identidad en ejecución y cuesta una operación entera por elemento. // Una fusión que deje de ser exacta no avisa en el modelo: sale el mismo texto // casi siempre. La caza una prueba que compara bit a bit con la cadena de // siempre y dice el primer índice distinto. // // WG va por SUSTITUCIÓN DE TEXTO, igual que en `kernels.nn.wgsl.js`: el análisis // de uniformidad exige que el recorrido de un bucle con barreras sea constante. // // Licencia: código propio, Apache-2.0 (ver SPDX arriba y LICENSE). Sin dependencias externas. import { HELPERS, AXIS, quantInfo } from './kernels.wgsl.js'; import { ROPE_NEOX } from './kernels.nn.wgsl.js'; // El ancho del grupo de las normas. TIENE que ser el de `createNNOps` (su // `wgNorm`, 128 por defecto y nadie pasa otro): es lo que fija el árbol de la // suma de cuadrados. Con otro ancho la norma seguiría siendo correcta, pero // dejaría de ser bit a bit la de la cadena. export const WG_FILA = 128; // Barrera de contracción. Ver la cabecera, punto 3. const CORTA = /* wgsl */` // Identidad en ejecución (p.cero vale 0) y opaca para el compilador: obliga a // redondear a f32 AQUÍ, como cuando la cadena guardaba el valor en memoria. fn corta(v : f32) -> f32 { return bitcast(bitcast(v) ^ p.cero); } `; // La suma en árbol, copia literal de la de `kernels.nn.wgsl.js`. La barrera va // FUERA del if (uniformidad) y deja `scratch[0]` listo para todos los hilos. const ARBOL = /* wgsl */` scratch[lid.x] = acc; workgroupBarrier(); for (var off = WG >> 1u; off > 0u; off = off >> 1u) { if (lid.x < off) { scratch[lid.x] = scratch[lid.x] + scratch[lid.x + off]; } workgroupBarrier(); }`; // Declara los bindings en el orden de `nombres`, que es el MISMO array con el que // ops.fusion.js arma la lista de buffers. Un solo sitio para el orden: si el // shader y la llamada lo llevaran cada uno por su cuenta y se desincronizaran, // cada buffer caería en el binding del vecino sin un solo error. function enlaces(nombres, decl) { return nombres.map((n, i) => `@group(0) @binding(${i}) ${decl[n]}`).join('\n'); } // ── F1: post-norma + suma residual + norma siguiente ──────────────────────── // Sustituye, por fila de `ne0` (un token): // lo2 = rmsnorm(lo, wp) (la post-norma de lfm3; sin ella, lo2 = lo) // xo = res + lo2 (la suma residual, `nn.add(x, lo2)`) // nrm = rmsnorm(xo, ws) (la norma de lo que viene: la del FFN, la de // entrada de la capa siguiente o la final) // Un grupo por fila. `xo` se escribe entero porque es el residual que sigue // vivo; `nrm` es la entrada de la siguiente multiplicación. // // Sin `post` (qwen35, llama) es la misma cadena sin la primera norma. export function enlacesNormaResidual(post) { return post ? ['lo', 'res', 'wp', 'ws', 'xo', 'nrm', 'p'] : ['lo', 'res', 'ws', 'xo', 'nrm', 'p']; } export function normaResidualShader({ wg = WG_FILA, post = true } = {}) { const decl = { lo: 'var lo : array; // salida del bloque o del FFN', res: 'var res : array; // residual que entra', wp: 'var wp : array; // peso de la post-norma [ne0]', ws: 'var ws : array; // peso de la norma siguiente [ne0]', xo: 'var xo : array; // residual que sale', nrm: 'var nrm : array; // entrada normalizada de lo siguiente', p: 'var p : P;', }; return /* wgsl */` const WG : u32 = ${wg}u; struct P { ne0 : u32, rows : u32, eps : f32, cero : u32 }; ${enlaces(enlacesNormaResidual(post), decl)} var scratch : array; ${CORTA} @compute @workgroup_size(${wg}) fn main(@builtin(workgroup_id) wid : vec3, @builtin(local_invocation_id) lid : vec3) { let row = wid.x + wid.y * ${AXIS}u; // dos ejes: uno solo topa en 65535 if (row >= p.rows) { return; } // uniforme en el grupo let base = row * p.ne0; var acc : f32 = 0.0; ${post ? /* wgsl */` // 1) La post-norma: suma de cuadrados de la salida del bloque, con el reparto // y el árbol de rmsnormShader. for (var c = lid.x; c < p.ne0; c = c + WG) { let v = lo[base + c]; acc = acc + v * v; } ${ARBOL} let s1 = inverseSqrt(scratch[0] / f32(p.ne0) + p.eps); workgroupBarrier(); // WAR: el árbol de abajo reescribe scratch acc = 0.0; ` : ''} // 2) La suma residual, y de paso la suma de cuadrados del residual nuevo (el // mismo reparto: cada hilo vuelve a recorrer SUS columnas, en el mismo orden). for (var c = lid.x; c < p.ne0; c = c + WG) { let v = res[base + c] + ${post ? 'corta(lo[base + c] * s1 * wp[c])' : 'lo[base + c]'}; xo[base + c] = v; acc = acc + v * v; } ${ARBOL} let s2 = inverseSqrt(scratch[0] / f32(p.ne0) + p.eps); // 3) La norma siguiente. Cada hilo relee lo que ÉL MISMO escribió en el paso 2 // (las mismas columnas), así que no hace falta barrera de memoria. for (var c = lid.x; c < p.ne0; c = c + WG) { nrm[base + c] = xo[base + c] * s2 * ws[c]; } }`; } // ── F2: embedding + norma de entrada de la primera capa ───────────────────── // Los tipos cuyo lector de bloques es el de `gatherShader`: bloque `i` en el // byte `i·blockBytes`, sin rejilla aparte. Es una lista CERRADA a propósito, y // no «todo lo que hay en QUANT_TYPES»: un tipo nuevo entra cuando se ha mirado // que su lector vale aquí, no por estar en la tabla. // Los reordenados al cargar (Q8_0R/Q4_0R, `__ELFFUSS_REPACK`) entran: su // descodificador respeta el mismo contrato de `decode(emit)` con el `blk` de // este andamio (de `blk` saca el índice de bloque y lee cuantos y escala de sus // regiones) y es el MISMO texto que usa `gatherShader`, así que F2 da los mismos // bits que su gather. Lo que no basta es la lista: sus lectores sacan del // tamaño del buffer dónde empiezan las escalas, y `gatherNorma` hace antes la // misma comprobación de la marca que `quant.gather` (`compruebaBufferR`). export const TIPOS_GATHER_NORMA = new Set([ 'F32', 'F16', 'BF16', 'Q8_0', 'Q4_0', 'Q2_K', 'Q4_K', 'Q5_K', 'Q6_K', 'PQ2_0', 'PTQ1_0', 'Q8_0R', 'Q4_0R', ]); // Un grupo por token. Fase 1: el gather de siempre (mismo descodificador de // bloque, mismo `emit`), pero los bloques de la fila los reparten los 128 hilos // del grupo. Fase 2, tras una barrera de memoria de almacenamiento: la rmsnorm // de esa fila, idéntica a `rmsnormShader`. `xo` es el residual (hace falta // entero para la primera suma) y `nrm` la entrada de la capa 0. export function gatherNormaShader(type, wg = WG_FILA) { if (!TIPOS_GATHER_NORMA.has(type)) throw new Error(`gather+norma: «${type}» no tiene lector de bloque aquí`); const d = quantInfo(type); if (d.table) throw new Error(`gather+norma: «${type}» necesita rejilla y aquí no se enlaza`); const emit = (idx, val) => ` xo[bxo + (${idx})] = ${val};`; return /* wgsl */` const WG : u32 = ${wg}u; struct P { dim : u32, tokens : u32, blocksPerRow : u32, eps : f32 }; @group(0) @binding(0) var w : array; @group(0) @binding(1) var ids : array; @group(0) @binding(2) var wn : array; // peso de la norma [dim] @group(0) @binding(3) var xo : array; // embedding [tokens][dim] @group(0) @binding(4) var nrm : array; // normalizado [tokens][dim] @group(0) @binding(5) var p : P; ${HELPERS}${d.helpers} var scratch : array; @compute @workgroup_size(${wg}) fn main(@builtin(workgroup_id) wid : vec3, @builtin(local_invocation_id) lid : vec3) { let t = wid.x + wid.y * ${AXIS}u; // un grupo por token if (t >= p.tokens) { return; } for (var b = lid.x; b < p.blocksPerRow; b = b + WG) { let blk = (ids[t] * p.blocksPerRow + b) * ${d.blockBytes}u; let bxo = t * p.dim + b * ${d.blockElems}u; {${d.decode(emit)} } } // Lo escrito por los otros hilos del grupo tiene que verse antes de leerlo. storageBarrier(); let base = t * p.dim; var acc : f32 = 0.0; for (var c = lid.x; c < p.dim; c = c + WG) { let v = xo[base + c]; acc = acc + v * v; } ${ARBOL} let scale = inverseSqrt(scratch[0] / f32(p.dim) + p.eps); for (var c = lid.x; c < p.dim; c = c + WG) { nrm[base + c] = xo[base + c] * scale * wn[c]; } }`; } // ── F4: la convolución corta de lfm3, entera, tras `in_proj` ──────────────── // Sustituye los ocho despachos de `convBlock` entre `in_proj` y `out_proj`: // tres cortes (B, C, x), B·x, la ventana (estado ‖ B·x), la conv depthwise // causal de K, guardar el estado y C·y. Por canal e y token t: // bx[t] = B[t]·x[t] // win[τ] = estado[τ] si τ < K-1 // = bx[τ-(K-1)] si no // y[t] = C[t] · Σ_{r=0..K-1} win[t+r]·w[r] (en ese orden, desde 0) // estado'[τ] = win[T+τ] (τ < K-1) // // Un hilo por (canal, tesela de TT tokens), con la ventana deslizante en // registros. El reparto no es capricho: el estado VIEJO solo lo lee la tesela // 0 (las demás empiezan en τ ≥ TT ≥ K-1, todo B·x), y el estado NUEVO lo escribe // ese mismo hilo al final, después de haber leído. Si lo escribiera otro hilo // —el de la última tesela, que tiene esos valores a mano— habría una carrera // entre grupos que ninguna barrera de WGSL puede ordenar. // // En generación (T=1) es un hilo por canal, el mismo paralelismo que la conv de // siempre; en prompt, T/TT teselas por canal. Con TT = 8 cubre kernels de 2 a 9 // (el de lfm3 es de 7); uno más largo va por la cadena de siempre (ver // `puedeConvCorta` en ops.fusion.js). export const CONV_TT = 8; export function convCortaShader({ K = 7, wg = 64, tt = CONV_TT } = {}) { if (!(K >= 2) || tt < K - 1) throw new Error(`conv corta: hace falta TT ≥ K-1 (K=${K}, TT=${tt})`); const R = Array.from({ length: K }, (_, r) => r); const R1 = R.slice(0, K - 1); return /* wgsl */` const K : u32 = ${K}u; const TT : u32 = ${tt}u; struct P { E : u32, T : u32, tiles : u32, cero : u32 }; @group(0) @binding(0) var bcx : array; // [T][3E]: B | C | x (orden de llama.cpp) @group(0) @binding(1) var wc : array; // [E][K], r=0 el más antiguo @group(0) @binding(2) var st : array; // estado [K-1][E] @group(0) @binding(3) var y : array; // C·conv [T][E] @group(0) @binding(4) var p : P; ${CORTA} // B·x del token t en el canal e: el MISMO producto que guardaba \`attn.mul(b, xs)\`. fn bx(t : u32, e : u32) -> f32 { let f = t * 3u * p.E; return corta(bcx[f + e] * bcx[f + 2u * p.E + e]); } // La ventana en la posición τ: el estado de los tokens anteriores o B·x. fn ventana(tau : u32, e : u32) -> f32 { if (tau < K - 1u) { return st[tau * p.E + e]; } return bx(tau - (K - 1u), e); } @compute @workgroup_size(${wg}) fn main(@builtin(global_invocation_id) gid : vec3) { let i = gid.x + gid.y * ${AXIS}u * ${wg}u; // dos ejes: uno solo topa en 65535 grupos if (i >= p.E * p.tiles) { return; } let e = i % p.E; // hilos contiguos → canales contiguos let tile = i / p.E; let t0 = tile * TT; let t1 = min(t0 + TT, p.T); ${R.map((r) => ` let k${r} = wc[e * K + ${r}u];`).join('\n')} // La ventana deslizante: v0 es la posición t0 (la más antigua). ${R1.map((r) => ` var v${r} = ventana(t0 + ${r}u, e);`).join('\n')} var v${K - 1} = 0.0; for (var t = t0; t < t1; t = t + 1u) { v${K - 1} = bx(t, e); var acc = 0.0; ${R.map((r) => ` acc = acc + v${r} * k${r};`).join('\n')} y[t * p.E + e] = bcx[t * 3u * p.E + p.E + e] * corta(acc); ${R1.map((r) => ` v${r} = v${r + 1};`).join('\n')} } // El estado nuevo, las últimas K-1 posiciones de la ventana. Se LEE todo antes // de escribir nada: con T < K-1 parte de lo nuevo sale del estado viejo. if (tile == 0u) { ${R1.map((r) => ` let n${r} = ventana(p.T + ${r}u, e);`).join('\n')} ${R1.map((r) => ` st[${r}u * p.E + e] = n${r};`).join('\n')} } }`; } // ── F6: QK-norm + RoPE + escritura de K y V en la caché ───────────────────── // Sustituye, en el bloque de atención: rmsnorm de q por cabeza, RoPE de q, // rmsnorm de k, RoPE de k, y las dos copias a la caché (`copyInto`, con la // conversión a f16 si la caché va en media precisión). // // Un grupo de 128 hilos por (token, cabeza): primero las H de consulta, luego // las KVH de clave y luego las KVH de valor. Las de consulta y clave hacen la // norma con el árbol de siempre, dejan la fila normalizada en memoria de grupo // (el RoPE mezcla dimensiones de hilos distintos) y rotan como `ropeShader`: un // hilo por par, `theta` con la MISMA expresión. Las de valor solo copian. // // q, k y v se leen con zancada y desplazamiento por token: hoy son tres // buffers sueltos (zancada = su anchura, desplazamiento 0), pero si un GEMV // fusionado los deja en un solo buffer [T][q|k|v], basta con pasar ese buffer // con otros números. En ese caso (`unBuffer`) se ata UNA vez y no tres: cada // binding cuenta contra el tope de buffers por etapa, y así la capa global de // lfm3 (QK-norm y rope_freqs) queda en ocho, el mínimo que garantiza WebGPU. // // PARTIDO EN DOS (`partes`). Con tres buffers sueltos, QK-norm y `rope_freqs`, // el despacho único ata diez buffers de almacenamiento (nueve sin rope_freqs), // y en un dispositivo que solo dé el mínimo de WebGPU ese pipeline ni se puede // crear. Para eso hay dos despachos con el MISMO código: 'q', las cabezas de // consulta (q, pos, wq, qo y rope_freqs), y 'kv', las de clave y valor (k, v, // pos, wk, las dos cachés y rope_freqs): siete como mucho. Cada grupo hace // exactamente lo que hacía su cabeza en el despacho único; cambia solo qué // grupos van en cada despacho, y eso lo dice el uniforme: la primera ranura // (`s0`) y cuántas hay por token (`nRanuras`), en el orden de siempre // [consulta | clave | valor]. Las ramas de las cabezas que un despacho no lleva // no se generan, porque sus buffers no están atados. // // La caché se escribe con la disposición de `copyInto`: el token t de la cabeza // h en ((nPast+t)·KVH + h)·D. Si esa disposición cambiara, cambia aquí también. export const PARTES_QKV = ['qkv', 'q', 'kv']; export function enlacesQKV({ norma = true, factores = false, unBuffer = false, partes = 'qkv' } = {}) { const conQ = partes !== 'kv', conK = partes !== 'q'; const entradas = unBuffer ? ['qkv'] : [...(conQ ? ['q'] : []), ...(conK ? ['k', 'v'] : [])]; const pesos = norma ? [...(conQ ? ['wq'] : []), ...(conK ? ['wk'] : [])] : []; return [...entradas, 'pos', ...pesos, ...(conQ ? ['qo'] : []), ...(conK ? ['kc', 'vc'] : []), 'p', ...(factores ? ['ff'] : [])]; } export function qkvShader({ D, norma = true, factores = false, kvF16 = true, wg = WG_FILA, unBuffer = false, partes = 'qkv' } = {}) { if (!(D > 0) || D % 2) throw new Error(`QK-norm+RoPE: head_dim ${D} tiene que ser par`); if (!PARTES_QKV.includes(partes)) throw new Error(`QK-norm+RoPE: partes «${partes}» desconocidas`); const conQ = partes !== 'kv', conK = partes !== 'q'; // Sin cabezas de clave no se toca la caché: su precisión no entra en el texto // (y la variante 'q' es la misma con caché f16 o f32). const KV = kvF16 && conK ? 'f16' : 'f32'; // Lo que depende de si la cabeza es de consulta o de clave: con las dos en el // despacho, la rama de siempre; con una sola, solo su lado. Las expresiones // son las MISMAS en las tres variantes. // Un bloque de varias líneas llega con su sangría de bloque (seis espacios); // suelto, sube un nivel. const rama = (enQ, enK) => { if (conQ && conK) return enQ.includes('\n') ? `if (esQ) {${enQ}} else {${enK}}` : `if (esQ) { ${enQ} } else { ${enK} }`; const solo = conQ ? enQ : enK; return solo.includes('\n') ? solo.trim().replace(/\n {6}/g, '\n ') : solo; }; const decl = { q: 'var q : array;', k: 'var k : array;', v: 'var v : array;', qkv: 'var qkv : array; // [T][q | k | v], con zancadas', pos: 'var pos : array;', wq: 'var wq : array; // attn_q_norm [D]', wk: 'var wk : array; // attn_k_norm [D]', qo: 'var qo : array; // q rotada [T][H][D]', kc: `var kc : array<${KV}>; // caché K [ctx][KVH][D]`, vc: `var vc : array<${KV}>; // caché V [ctx][KVH][D]`, p: 'var p : P;', ff: 'var ff : array; // rope_freqs [nDims/2]', }; // Las lecturas de la fila de entrada. Con UN buffer, los desplazamientos ya // distinguen q de k; con tres, cada cabeza lee el suyo. const lee = unBuffer ? 'fn lee(esQ : bool, i : u32) -> f32 { return qkv[i]; } // los desplazamientos ya distinguen q de k' : conQ && conK ? `fn lee(esQ : bool, i : u32) -> f32 { if (esQ) { return q[i]; } return k[i]; }` : `fn lee(esQ : bool, i : u32) -> f32 { return ${conQ ? 'q' : 'k'}[i]; }`; const leeV = !conK ? '' : `fn leeV(i : u32) -> f32 { return ${unBuffer ? 'qkv' : 'v'}[i]; }`; return /* wgsl */`${KV === 'f16' ? 'enable f16;\n' : ''} const WG : u32 = ${wg}u; struct P { heads : u32, kvHeads : u32, tokens : u32, dim : u32, nDims : u32, mode : u32, nPast : u32, cero : u32, qStride : u32, qOff : u32, kStride : u32, kOff : u32, vStride : u32, vOff : u32, eps : f32, thetaScale : f32, freqScale : f32, s0 : u32, nRanuras : u32, pad0 : u32, }; ${enlaces(enlacesQKV({ norma, factores, unBuffer, partes }), decl)} var scratch : array; var fila : array; ${CORTA} ${lee} ${leeV} @compute @workgroup_size(${wg}) fn main(@builtin(workgroup_id) wid : vec3, @builtin(local_invocation_id) lid : vec3) { let g = wid.x + wid.y * ${AXIS}u; // un grupo por (token, ranura) if (g >= p.tokens * p.nRanuras) { return; } let t = g / p.nRanuras; // La ranura en el orden del despacho único: [consulta | clave | valor]. let s = p.s0 + g % p.nRanuras; ${conK ? /* wgsl */` let fc = (p.nPast + t) * p.kvHeads * p.dim; // el token en la caché: a partir de nPast // Cabezas de VALOR: la copia de \`copyInto\`, sin nada más. if (s >= p.heads + p.kvHeads) { let h = s - p.heads - p.kvHeads; let src = t * p.vStride + p.vOff + h * p.dim; for (var c = lid.x; c < p.dim; c = c + WG) { vc[fc + h * p.dim + c] = ${KV}(leeV(src + c)); } return; // uniforme: \`s\` sale del índice del grupo } ` : ''} let esQ = ${conQ && conK ? 's < p.heads' : conQ ? 'true' : 'false'}; let h = ${conQ && conK ? 'select(s - p.heads, s, esQ)' : conQ ? 's' : 's - p.heads'}; let src = ${conQ && conK ? 'select(t * p.kStride + p.kOff + h * p.dim, t * p.qStride + p.qOff + h * p.dim, esQ)' : conQ ? 't * p.qStride + p.qOff + h * p.dim' : 't * p.kStride + p.kOff + h * p.dim'}; ${norma ? /* wgsl */` // 1) La rmsnorm de la cabeza (filas de D), con el reparto y el árbol de // rmsnormShader. El ancho sale del uniforme y no de la constante D, igual // que allí: una división por una constante la puede reescribir el // compilador, y la de la cadena no. var acc : f32 = 0.0; for (var c = lid.x; c < p.dim; c = c + WG) { let x = lee(esQ, src + c); acc = acc + x * x; } ${ARBOL} let scale = inverseSqrt(scratch[0] / f32(p.dim) + p.eps); for (var c = lid.x; c < p.dim; c = c + WG) { var wv : f32; ${rama('wv = wq[c];', 'wv = wk[c];')} fila[c] = corta(lee(esQ, src + c) * scale * wv); }` : /* wgsl */` // Sin QK-norm (llama): el RoPE va directo sobre la proyección. for (var c = lid.x; c < p.dim; c = c + WG) { fila[c] = lee(esQ, src + c); }`} workgroupBarrier(); // la fila entera, visible para todos // 2) RoPE como \`ropeShader\`: un hilo por par y la MISMA expresión de theta. let pairs = p.nDims / 2u; let tok = f32(pos[t]); ${conQ ? ' let bq = (t * p.heads + h) * p.dim; // q: [T][H][D]' : ''} ${conK ? ' let bk = fc + h * p.dim; // k: la caché' : ''} for (var pr = lid.x; pr < pairs; pr = pr + WG) { let theta = tok * p.freqScale * pow(p.thetaScale, f32(pr))${factores ? ' / ff[pr]' : ''}; let cs = cos(theta); let sn = sin(theta); // La única diferencia entre los dos modos: qué dos posiciones forman el par. var i0 : u32; var i1 : u32; if (p.mode == ${ROPE_NEOX}u) { i0 = pr; i1 = pr + pairs; } else { i0 = pr * 2u; i1 = pr * 2u + 1u; } let x0 = fila[i0]; let x1 = fila[i1]; ${rama(/* wgsl */` qo[bq + i0] = x0 * cs - x1 * sn; qo[bq + i1] = x0 * sn + x1 * cs; `, /* wgsl */` // En la cadena el resultado del RoPE se guardaba en f32 y la copia lo // convertía: \`corta\` fija ese redondeo antes de la conversión. kc[bk + i0] = ${KV}(corta(x0 * cs - x1 * sn)); kc[bk + i1] = ${KV}(corta(x0 * sn + x1 * cs)); `)} } // Las dimensiones no rotadas (RoPE parcial) se copian tal cual. for (var c = p.nDims + lid.x; c < p.dim; c = c + WG) { ${rama('qo[bq + c] = fila[c];', `kc[bk + c] = ${KV}(fila[c]);`)} } }`; }