Saltar al contenido
Los mismos bits con 1 o 64 filas: un prompt alimentado con una fila por paso y con 64 filas por paso da el mismo hash de sus logits.

Optimización de los kernels de Inkling 2 Small en NVIDIA B300

, 11 min de lectura, By Jaber Jaber

Investigación

RightNow AI es un laboratorio de investigación de GPU respaldado por YC. Optimizamos los kernels de Inkling 2 Small, la mezcla de expertos de 594B parámetros de Thinking Machines, en 8 GPUs NVIDIA B300. Cada kernel, prueba, configuración y resultado es de código abierto en github.com/RightNow-AI/inkling-b300-kernels.

Thinking Machines preentrenó, entrenó en una etapa intermedia y post-entrenó este modelo en NVFP4, y su model card lo llama "la precisión nativa para el modelo". Ejecutamos esos números tal como fueron entrenados: los expertos NVFP4 de las capas 0 a 39 en los tensor cores FP4 con escalas de bloque de Blackwell, y los expertos MXFP8 de las capas 40 a 47 en sus tensor cores FP8 con escalas de bloque.

Medido en GPUs B300, 2026-11-21Resultado
Logits idénticos, 64 filas por paso contra 1 fila por paso, modelo completo en 8 GPUs0 de 599 filas difieren, bit a bit
Diferencia de log-probabilidad del siguiente token respecto a vLLM, mismo modelo y GPUs0.025 nats de media, 0.13 en p95
GEMM w13 de expertos, una GPU, un token, reconstruida contra nuestro primer kernel5.1x más rápida en NVFP4, 7.5x en MXFP8, mismos bits
Baterías de pruebas de kernels en un B300, 8 rangos emulados10 de 10 pasan
Referencia vLLM nightly con paralelismo de tensor 8, temperatura 0

Cada kernel aquí fue escrito por nuestro motor de kernels con IA: agentes de programación que escriben CUDA, ejecutan nuestro harness de pruebas y conservan o revierten cada cambio. Un kernel se conservaba solo después de pasar sus verificaciones.

Por qué esto necesita CUDA

NVFP4 guarda valores E2M1 de 4 bits con una escala E4M3 por cada bloque de 16. Los tensor cores de Blackwell leen esas escalas directamente: una instrucción tcgen05.mma, kind::mxf4nvf4.block_scale.block16, multiplica los propios bytes del modelo.

Las MI350X y MI355X de AMD no lo hacen. En palabras del propio AMD, su soporte de cómputo en FP4 se limita a MXFP4, cuyos bloques miden 32 de ancho y cuyas escalas son potencias de dos, así que un checkpoint NVFP4 debe convertirse primero a MXFP4 para usar esa vía. En Blackwell el modelo corre en los números en los que fue entrenado.

Los mismos bits con 1 o 64 filas

La mayoría de los motores de inferencia dan resultados cercanos, no exactos. El resultado de un token depende de qué más comparte su paso, porque el lote cambia cómo se reparten las sumas y la suma en punto flotante no es asociativa.

Thinking Machines llamó a la solución invariancia de lote: el resultado de una fila no puede depender del lote en absoluto. La mantenemos en los tensor cores NVFP4 y MXFP8 con escalas de bloque, expertos divididos entre 8 GPUs y cada intercambio entre ellas.

  • Toda reducción tiene una forma fija. Las sumas se ejecutan en trozos fijos y árboles equilibrados, las sumas entre GPUs se pliegan en orden de rango en FP32, y la compilación desactiva la contracción automática, así que cada multiply-add fusionado es uno que escribimos a propósito.

  • Toda propiedad tiene un gemelo roto. Cada propiedad de identidad de bits se empareja con una variante deliberadamente rota que debe ser detectada. Donde una ruptura no puede mover los bits, como reordenar sumas que son exactas, el registro lo dice en lugar de contarla.

  • La prueba se ejecuta en el modelo real. Alimentar cada prompt con 64 posiciones por paso y con 1 posición por paso da logits idénticos en las 599 filas que comparamos. Cada celda de abajo es una fila: pasa el cursor o navega con Tab por ella para ver ambos hashes.

Logit hash per row, 64 rows against 1 row per step

599 of 599same bits

essay143 of 143 same

code152 of 152 same

math157 of 157 same

explain147 of 147 same

essay, row 0same bits

64 rows a step
61984ec4553e0829
1 row a step
61984ec4553e0829

A hash of each row's FP32 logits, full model on 8 B300 GPUs fed 64 rows per step and 1 row per step, 599 rows over 4 prompts, measured 2026-11-21

Cada suma troceada en nuestras GEMM de expertos termina en este árbol equilibrado; cada suma es una suma explícita de redondeo al más cercano que el compilador nunca fusiona en un multiply-add, y el intercambio de arriba es el gemelo roto que nuestras pruebas deben detectar.

CUDA
// Balanced tree over the chunk lanes, (c0+c1)+(c2+c3) for 4; `swap` is the negative control.
template <int NC>
__device__ __forceinline__ float chunk_tree(float (&v)[NC], int inject) {
  if (NC >= 4 && (inject & 1)) {
    const float t = v[1];
    v[1] = v[2];
    v[2] = t;
  }
#pragma unroll
  for (int w = 1; w < NC; w *= 2)
#pragma unroll
    for (int i = 0; i + w < NC; i += 2 * w) v[i] = __fadd_rn(v[i], v[i + w]);
  return (inject & 8) ? __uint_as_float(__float_as_uint(v[0]) + 1u) : v[0];
}

Kernel 1: expertos NVFP4 divididos entre GPUs, exactamente

Las activaciones de un experto NVFP4 se cuantizan en tiempo de ejecución con una escala FP32 por token, calculada a partir del máximo de toda la fila. La receta de SGLang para este modelo dice que los expertos de NVFP4 no se pueden fragmentar con TP, "porque sus escalas de activación deben cubrir todo el ancho de entrada de cada experto", así que los motores los ejecutan con paralelismo de expertos, expertos completos por GPU.

Nosotros los fragmentamos de todos modos: una octava parte de las columnas de cada experto por GPU, y un intercambio del máximo de la fila. Un máximo no depende del orden en que se toma, así que el intercambio es exacto y el cuantizador coincide con la regla four over six de la referencia bit a bit.

Dos paneles con 8 recuadros de GPU. Izquierda, expertos completos por GPU: pilas desiguales, la GPU más ocupada fija el paso. Derecha, una octava parte de cada experto: pilas iguales, un máximo por fila intercambiado
Cómo se dividen los expertos NVFP4 de las capas 0 a 39 entre 8 GPUs, el intercambio de máximos probado el 2026-11-21

Cada GPU toma la mayor magnitud en sus propias 288 columnas de la fila, y cada GPU luego combina los 8 máximos que recibe con fmaxf, lo que da los mismos bits en cualquier orden; la línea del fma es el gemelo dependiente del orden que nuestra prueba de permutación debe detectar.

CUDA
__global__ void hmax_kernel(const uint16_t* __restrict__ h, long long h_rstride, int A, float* __restrict__ lmax,
                            long long zs, long long ts) {
  const int a = blockIdx.x, r = blockIdx.y, lane = threadIdx.x;
  const uint16_t* row = h + (long long)r * h_rstride + (long long)a * kInterRank;
  float m = 0.0f;
  for (int i = lane; i < kInterRank; i += 32) m = fmaxf(m, fabsf(__uint_as_float((uint32_t)row[i] << 16)));
#pragma unroll
  for (int s = 16; s >= 1; s /= 2) m = fmaxf(m, __shfl_xor_sync(0xFFFFFFFFu, m, s));
  if (lane == 0) lmax[(long long)r * zs + amax_off(a, ts)] = m;
}
// What every receiving rank computes from the 8 received maxima: amax = max over the 8 shards, in the order `order`
// (identity when null; any order gives the same bits, the test permutes it). Control bit 2: an order-dependent combine
// m = fma(m, 0.5, v) (must be caught by the permutation test).
__device__ __forceinline__ float amax_fold8(const float* lmax, long long zs, long long off, const int* order) {
  const bool ctl = (kInkInjectMoe & 4) != 0;
  float m = __ldcg(lmax + (long long)(order ? order[0] : 0) * zs + off);
  for (int i = 1; i < kTP; ++i) {
    const float v = __ldcg(lmax + (long long)(order ? order[i] : i) * zs + off);
    m = ctl ? __fmaf_rn(m, 0.5f, v) : fmaxf(m, v);
  }
  return m;
}
  • El intercambio da los mismos bits en los 8 órdenes de rango que probamos, con los 8 rangos emulados en un B300, y se detecta una combinación dependiente del orden.

  • Cada GPU lee una porción igual de cada experto activo, así que ninguna GPU lee más bytes de experto que las otras. El precio es un intercambio más por capa FP4.

Una segunda forma intercambia la propia activación en vez de su máximo, y divide w2 por filas de salida en vez de por K.

Cada GPU entonces cuantiza la fila completa por su cuenta, el all-reduce final de los parciales FP32 se convierte en un all-gather de porciones BF16, y cada GPU envía 3.2 veces menos bytes por capa FP4: 40 KB contra 129 KB con una fila, 0.32 MB contra 1.03 MB en un paso de verificación de 8 filas.

Redondea donde SGLang redondea, la salida de cada experto a BF16 antes de la suma, y muestra cero error contra un modelo FP64 de esos puntos de redondeo en la capa FP4 que probamos.

Kernel 2: la GEMM con escalas de bloque, reconstruida para un token

Ambos kernels ejecutan tcgen05.mma con los pesos como M, 128 filas por tile y los tokens pasados a N, con acumuladores FP32 y las escalas de bloque en la memoria de tensores.

En el kernel reconstruido un solo hilo alimenta el tensor core: en cada paso de K copia las escalas de bloque de los pesos y del token a TMEM con tcgen05.cp, y luego emite un tcgen05.mma con escalas de bloque cuyo predicado de acumulación está apagado en el primer paso de K del trozo, así que cada trozo parte de un acumulador FP32 en cero.

CUDA
__device__ __forceinline__ void tc_cp_sf(uint32_t taddr, uint64_t desc) {
  asm volatile("tcgen05.cp.cta_group::1.32x128b.warpx4 [%0], %1;" ::"r"(taddr), "l"(desc) : "memory");
}
template <int F>
__device__ __forceinline__ void tc_mma(uint32_t d, uint64_t a, uint64_t b, uint32_t idesc, uint32_t sfa, uint32_t sfb,
                                       uint32_t accumulate) {
  if constexpr (F == kNVF4)
    asm volatile(
        "{\n .reg .pred p;\n setp.ne.b32 p, %4, 0;\n"
        " tcgen05.mma.cta_group::1.kind::mxf4nvf4.block_scale.block16 [%0], %1, %2, %3, [%5], [%6], p;\n}\n" ::"r"(d),
        "l"(a), "l"(b), "r"(idesc), "r"(accumulate), "r"(sfa), "r"(sfb)
        : "memory");
  // ...
}
// ...
for (int j = 0; j < ns; ++j) {
  const uint32_t ca = tm + N + 8 * (s * KS + j), cbk = ca + 4;  // the slot's own scale columns
  tc_cp_sf(ca, smem_desc(saddr(sl.sfa[j]), 128, 128));
  tc_cp_sf(cbk, smem_desc(saddr(sl.sfb[j]), 128, 128));
  tc_mma<F>(tm, smem_desc(saddr(sl.a[j]), 128, 256), smem_desc(saddr(sl.b[j]), 128, 256),
            instr_desc<F>(N, 0), ca, cbk, kl0 + j != 0 ? 1u : 0u);
}

Con un token, la GEMM w13 en cada GPU mueve 11.9 MB de pesos y escalas FP4 por capa. Nuestro primer kernel daba a cada tile de experto un CTA y recorría K en etapas que nunca solapaba: 40 CTAs en 148 SMs, a 114 GB/s.

El kernel reconstruido reparte los trozos K fijos entre CTAs y solapa las cargas de todas las etapas con las MMAs. Cada trozo sigue siendo la misma cadena de MMAs con escalas de bloque en el mismo orden de K desde un acumulador en cero, y el último CTA en llegar combina los trozos en el mismo árbol fijo, así que toda salida conserva sus bits.

Cada CTA escribe los parciales FP32 de su trozo, emite un fence y toma un ticket; el último en llegar reinicia el contador para el siguiente replay del CUDA graph, lee cada trozo a través de L2 en orden de trozos y los suma en el mismo árbol fijo.

CUDA
__threadfence();  // this thread's partials, gpu scope
__syncthreads();
if (tid == 0) {
  int* cnt = p.split_cnt + ((long long)rank * kSplitCols + u) * kSplitTiles + tile;
  const int last = atomicAdd(cnt, 1) == NC - 1;
  if (last) {
    *reinterpret_cast<volatile int*>(cnt) = 0;  // every chunk of this tile arrived: 0 for the next launch (graphs)
    __threadfence();
  }
  sm.last = last;
}
__syncthreads();
if (!sm.last) return;
// ...
    float vg[NC], vu[NC];
#pragma unroll
    for (int k = 0; k < NC; ++k) {
      vg[k] = __ldcg(pc + k * CS);
      vu[k] = __ldcg(pc + k * CS + 1);
    }
    // ...
    const float ag = chunk_tree<NC>(vg, inject), au = chunk_tree<NC>(vu, inject);

Microseconds per launch

  • w13 · NVFP45.1x
    First kernel 104.4 microseconds, rebuilt 20.5.
  • w13 · MXFP87.5x
    First kernel 184.3 microseconds, rebuilt 24.6.
  • w2, first form · NVFP41.0x
    First kernel 14.3 microseconds, rebuilt 14.3.
  • w2, first form · MXFP81.3x
    First kernel 20.5 microseconds, rebuilt 16.3.
  • w2, second form · NVFP43.3x
    First kernel 55.8 microseconds, rebuilt 16.9.
  • w2, second form · MXFP84.6x
    First kernel 88.0 microseconds, rebuilt 19.1.

w13, NVFP4, layer 0

first kernel
104.4
114 GB/s
rebuilt
20.5
583 GB/s
weights
11.94 MB
8 experts

One GPU's expert GEMM launch on a B300, first kernel against rebuilt, layer 0 for NVFP4 and 40 for MXFP8, L2 flushed, median of 9, measured 2026-11-21

Con 8 tokens por paso y 40 expertos distintos por capa, la w13 reconstruida lee 1.39 TB/s en NVFP4 y 1.84 TB/s en MXFP8, contra los 6.85 TB/s que medimos para la memoria de un B300, así que este kernel aún tiene margen.

Contra el primer kernel, en las capas 0 y 40 con 1 a 64 filas y a lo largo de tres replays del CUDA graph, cada intermedio es igual bit a bit: 0 de 512 filas difieren.

Kernel 3: una mezcla de profundidad en una ronda

Inkling mezcla las salidas de capas anteriores antes de cada atención y de cada bloque de expertos: un softmax sobre hasta nueve salidas anteriores y luego una normalización. Hecha directamente, cada mezcla necesita dos reducciones en toda la GPU.

Guardamos la matriz de Gram de las salidas anteriores, calculada una vez cuando cada bloque cierra, así que la norma de la mezcla sale de esa matriz y de una columna nueva: una reducción en lugar de dos, 2 rondas por capa en lugar de 4, contadas.

La norma queda dentro de 1.6e-7 en términos relativos respecto de la directa en nuestras pruebas, con una suma compensada y un respaldo a la segunda ronda directa para toda fila donde la cancelación pudiera superar el umbral.

Plegar el router de expertos en la misma reducción cambió los 8 expertos principales en el 1.1% y el 1.6% de los tokens en los routers reales de las capas 0 y 40, así que se queda fuera: un cambio que mueve el enrutamiento no es un cambio sin pérdida.

Qué tan cerca de vLLM

El modelo completo en 8 GPUs, con teacher forcing sobre las propias continuaciones de vLLM de 4 prompts, contra las log-probabilidades de vLLM en 595 posiciones. vLLM ejecutado dos veces coincide consigo mismo exactamente, así que cada diferencia de abajo es entre la aritmética de los dos motores, no ruido.

Distance from vLLM, nats

mean
0.0249
median
0.0016
p95
0.1285
max
0.7269
vLLM run twice
0.0000

Next-token log-probability distance from vLLM at 595 teacher-forced rows over 4 prompts, same model and GPUs, temperature 0, measured 2026-11-21

En qué se va el paso hoy

Nuestro motor todavía ejecuta un paso de decodificación como lanzamientos separados bajo CUDA graphs: unos 16 ms por paso con una fila sin el borrador, en 8 GPUs B300. El mayor costo es la GEMM de expertos de nuestro primer kernel, que el kernel reconstruido reduce unas cinco veces de forma aislada pero que aún no está en el motor.

Kernel time per step, one GPU, ms

16.76 in all

  • Expert GEMMs5.94
  • Exchanges and waits4.93
  • Depth mix and conv2.45
  • Attention1.39
  • Router and work list0.88
  • Dense BF16 GEMMs0.63
  • Quantize and combine0.48
  • Embed and sample0.03

Expert GEMMs35.4%

  • 4.03w13 GEMM, NVFP4expert_gemm_tc05_kernel<0,1,4,0>
  • 1.42w13 GEMM, MXFP8expert_gemm_tc05_kernel<1,1,4,0>
  • 0.36w2 GEMM, NVFP4expert_gemm_tc05_kernel<0,1,1,1>
  • 0.12w2 GEMM, MXFP8expert_gemm_tc05_kernel<1,1,1,1>

Kernel time per decode step on one of 8 B300 GPUs under Nsight Systems, one row and no draft; a step took 16.35 ms without the profiler, measured 2026-11-21

La siguiente pieza es un programa de decodificación persistente por GPU: cada capa en un kernel residente, con los intercambios dentro de él.

Nuestro presupuesto de bytes y latencia para un paso de verificación da unos 7.8 GB por GPU en 154 intercambios, con el propio borrador especulativo de Inkling a 3.35 tokens por paso y un supuesto de 45 expertos distintos por capa, algo que aún no hemos medido.

Con ese presupuesto el programa apunta a unos 1,900 tokens por segundo por usuario, una proyección con un rango de unos 1,630 a 2,160. Como referencia de escala, vLLM con el mismo borrador corre este modelo a 666 tokens por segundo por usuario en nuestro propio nodo de 8 B300. El siguiente artículo reporta nuestro número medido, bit a bit.

Las configuraciones

El código fuente completo, las baterías de pruebas y el runner en la nube que produjo cada resultado están en github.com/RightNow-AI/inkling-b300-kernels, bajo la licencia Apache 2.0.

Cada kernel se compila para la arquitectura objetivo específica del B300, con la contracción desactivada:

Shell
nvcc -O3 -std=c++17 -fmad=false -lineinfo \
  -gencode arch=compute_103a,code=[sm_103a,compute_103a] \
  -Xcompiler -ffp-contract=off -Isrc -o build/engine_ink src/inkling/engine_ink.cu

El modelo completo en 8 GPUs, con teacher forcing a 64 filas por paso y a 1, y la línea de velocidad:

Shell
engine_ink --model Inkling-2-Small --ranks 8 --devices 8 --attn i1 --moe i2 \
  --prompts-file seqs.txt --n 1 --ctx 4096 --chunk 64 --dump ours.jsonl
engine_ink --model Inkling-2-Small --ranks 8 --devices 8 --attn i1 --moe i2 \
  --prompts-file seqs.txt --n 1 --ctx 4096 --chunk 1 --dump ours_c1.jsonl
engine_ink --model Inkling-2-Small --ranks 8 --devices 8 --attn i1 --moe i2 \
  --prompt 1000,2000,3000,4000 --n 257 --ctx 4096

La referencia:

Shell
vllm serve Inkling-2-Small --served-model-name thinkingmachines/Inkling-2-Small \
  --tensor-parallel-size 8 --max-model-len 32768 --max-num-seqs 8 --max-logprobs 20

Condiciones

Nuestro motor y la referencia vLLM corrieron en un nodo de la nube de 8 GPUs NVIDIA B300 SXM6, driver 620.70.06, con acceso peer to peer entre las 8 GPUs; las baterías de pruebas de kernels y los tiempos de GEMM corrieron en una de sus GPUs.

Checkpoint thinkingmachines/Inkling-2-Small en la revisión 885d78bf. Referencia: imagen nightly de vLLM sha256:c17e9d88. La velocidad de vLLM con el borrador (2026-11-21) y el ancho de banda de memoria de 6.85 TB/s (2026-11-20) se midieron en nuestro propio nodo de 8 B300; todo lo demás se midió el 2026-11-21.