Noticias
RTX 3060 12 GB bajo carga sostenida: 60-68 kb / s hasta el último token
Medimos la velocidad dentro de cada respuesta larga, token por token, en lugar de promediar: 60-68 tok/s con razonamiento en una respuesta de 8192 tokens en un contexto de 16K, 79-96 tok/s sin razonamiento, y solo alrededor del 8% perdió de un mensaje de 1K a 30K. Los 145 archivos RAW están disponibles para descargar.
El 30 de octubre de 2026 realizamos una larga serie de mediciones en B2003, nuestra computadora experimental con un RTX 3060 de 12 GB. El resultado: con el razonamiento activado (el valor predeterminado), Qwen3.8-Flash-Next IQ3_S en Strata mantiene 60-68 tok/s desde el primer token hasta el 8192 en un indicador de 16K, sin caídas. Con el razonamiento desactivado, funciona a 79-96 tok/s. Un contexto casi completo cuesta solo alrededor del 8%: de un mensaje de 1K a 30K, la mediana va de 88 a 84 tok/s.
Nuestro artículo anterior informó una decodificación de hasta 68 tok/s en esta tarjeta. Las dos preguntas que más nos hacen en X son si esa velocidad se mantiene a través de una respuesta larga o es solo un pico de calentamiento, y si el rendimiento se mantiene en la segunda mitad de un contexto largo. Para responderlas, cronometramos cada token transmitido en lugar de promediar toda la respuesta.
Verificamos la velocidad en intervalos de la misma respuesta, el contexto de 1K a 30K tokens, un caché de avisos fríos y cálidos, enrutamiento experto rápido y preciso, tres tipos de contenido (JSON, código C, prosa técnica rusa), potencia de la GPU, relojes y temperatura, y si la salida en sí misma se mantuvo correcta.
Configuración
- Máquina B2003: ASUS Pro Q870I-C, Intel Core Ultra 7 265, 2×24 GiB DDR5-5600.
- GPU: RTX 3060 12 GB (GA106), controlador 615.71.10, desbloqueo de GPU activado, límite de potencia 170 W.
- Almacenamiento: NVMe Lexar NM1090 PRO de 2 TB (PCIe 5.0 ×4).
- Sistema: Ubuntu 24.04.5, kernel 7.0.0-38.
- Motor: Strata 0.1.52 (compilación f-027-rel).
- Modelo: Qwen3.8-Flash-Next-GSQ-RCO-IQ3_S (78 GiB, 2 fragmentos).
--max-context 32768 --prefill 4096 --pool-workers 12 --spec 4 --spec-min-p 0.5
--kv int8 --kv-resident 32768 --conversation-cache-mib 1536
--resident-experts --resident-budget-gib 24
STRATA_UNBUFFERED_LOAD=1 STRATA_RESIDENT_HEADROOM_GIB=10
Metodología
- El servidor no expone / tokeniza, por lo que los tokens se contaron a partir de las marcas de tiempo de los fragmentos SSE transmitidos (1 fragmento ≈ 1 token; verifique: 5478 fragmentos contra 5479 tokens en uso.completion_tokens) y anclado al recuento final exacto de tokens. No se usaron palabras ni líneas.
- Los avisos se calibraron con sondas usando max_tokens: 1 (20,2 tokens por oración de relleno, 145 tokens de sobrecarga fija); el tamaño real se comparó con el uso.prompt_tokens.
- La longitud de la respuesta fue de 32768 menos el mensaje menos un margen, hasta 8192 tokens; a 30K, esto es 2048 tokens.
- Cada escenario clave se repitió al menos 3 veces; informamos la mediana, el mínimo y el máximo. El ruido de decodificación es ±20% y el ruido de llenado previo ±5%; las diferencias más pequeñas no se contaron como resultados.
- La telemetría del hardware se registró cada 3 segundos (relojes, potencia, temperatura, utilización, VRAM, RAM libre, intercambio, contadores de lectura NVMe). El llenado previo, la aceptación del borrador de MTP, las visitas de caché de expertos y las lecturas de nivel de archivo provienen del registro del motor.
- Dos modos de enrutamiento expertos: rápido (enrutamiento predeterminado, anterior a 1.5) y preciso (STRATA_ROUTE_PRIOR = 0). Los modos se cambiaron reiniciando el motor.
- el motor rápido produjo 4 filas en el archivo de modo preciso porque el script de bloque se reescribió durante la ejecución. Se excluyen de las tablas y se mantienen en el archivo tal como están.
- En total: 52 ejecuciones medidas en 13 archivos JSONL (14 en modo rápido, 13 en modo preciso y 25 variantes: razonamiento, caché cálido, código, prosa, límite de contexto, calibración), más las 4 filas excluidas.
Resultados: velocidad dentro de la respuesta
Valores en tok/s, mediana (min-max–. El contexto es el tamaño del mensaje en tokens; la respuesta es de hasta 8192 tokens (2048 a 30K).
Modo rápido, razonamiento desactivado
| Contexto | Carreras | 0–0.5K | 0.5K–1K | 1K–2K | 2K–4K | 4K–6K | 6K–8K | Cola | Respuesta completa |
|---|---|---|---|---|---|---|---|---|---|
| 983–1516 | 3 | 86 (56–86) | 87 (87–88) | 86 (85–88) | 88 (88–90) | — | — | 92 | 88 (55–89) |
| 7865 | 2 | 84 (81–87) | 96 (93–99) | 94 | 95 (94–96) | — | — | 94 | 93 (93–94) |
| 15816 | 3 | 79 (77–88) | 86 (86–96) | 90 (90–96) | 92 (90–98) | 93 (93–96) | 93 (92–96) | 95 | 91 (90–96) |
| 23917 | 3 | 81 (77–85) | 86 (83–91) | 83 (81–92) | 90 (80–90) | 96 | — | 83 | 86 (80–92) |
| 30153 | 3 | 78 (77–78) | 86 (86–87) | 86 (85–88) | — | — | — | 86 | 84 (84–85) |
Modo rápido, razonamiento activado (comportamiento predeterminado)
| Contexto | Carreras | 0–0.5K | 0.5K–1K | 1K–2K | 2K–4K | 4K–6K | 6K–8K | Cola | Respuesta completa |
|---|---|---|---|---|---|---|---|---|---|
| 15854 | 1 | 61 | 68 | 61 | 59 | 58 | 60 | 85 | 60 |
| 30191 | 1 | 66 | 56 | 65 | — | — | — | 96 | 63 |
Modo preciso, razonamiento desactivado
| Contexto | Carreras | 0–0.5K | 0.5K–1K | 1K–2K | 2K–4K | 4K–6K | 6K–8K | Cola | Respuesta completa |
|---|---|---|---|---|---|---|---|---|---|
| 1011 | 2 | 27 (26–29) | 28 (26–29) | 27 (26–28) | 25 (24–26) | 25 (24–25) | 23 | 26 | 25 (25–26) |
| 7893 | 2 | 29 (29–30) | 30 (29–31) | 28 (24–31) | 27 (22–31) | 26 (21–31) | 27 | 24 | 26 (23–30) |
| 15814 | 3 | 29 (26–32) | 27 (25–32) | 26 (22–28) | 23 (20–24) | 23 (20–23) | 22 | 21 | 24 (21–24) |
| 23915 | 3 | 31 (30–32) | 32 (31–34) | 29 (26–31) | 25 (25–28) | 24 | — | 24 | 26 (26–29) |
| 30151 | 3 | 32 (28–32) | 32 (30–33) | 29 (29–30) | — | — | — | 29 | 30 |
En el modo rápido, la velocidad es plana o aumenta hacia el final de la respuesta (16K: 79 → 93, cola 95). Una desaceleración hacia el final aparece solo en modo preciso: 29 → 22 sobre 8000 tokens (-24%). El modo preciso con razonamiento activado a 16K da 25 tok/s para toda la respuesta. El enrutamiento rápido es 3.8× más rápido que el enrutamiento preciso.
Tipo de contenido (modo rápido, contexto de 16K)
| Tarea | Respuesta, fichas | Respuesta completa, tok/s | Borradores de MTP aceptados |
|---|---|---|---|
| Matriz JSON de registros | 8192 | 91 (90–96) | 92% (90–98%) |
| Código C | 7332 | 59 | 74% |
| Prosa técnica rusa | 4730 | 40 (40–43) | 38% (1327/3485) |
Las diferencias son varias veces mayores que el ruido de decodificación: la estructura predecible acelera la generación entre 2 y 2,3×, la prosa libre la ralentiza. Esta es una propiedad del contenido, no una desaceleración con el tiempo.
Rellenado previo, tiempo hasta el primer token y solicitud de caché
| Caso | Aviso, fichas | Llenado previo en frío, tok/s | TTFT frío | TTFT cálido | Tokens reutilizados |
|---|---|---|---|---|---|
| 1K | 983–1516 | 293 | 3.4–3.8 s | — | 0 |
| 8K | 7865 | 865 | 9.1–9.2 s | — | 0 |
| 16K | 15816 | 908 | 17.3–17.6 s | 0.2 s | 15 803 |
| 24K | 23917 | 914 | 25.4–26.3 s | — | 0 |
| 30K | 30153 | 892 | 33.6–34.5 s | 0.4 s | 30 141 |
Una caché de aviso cálido elimina casi todo el llenado previo (17,4 s → 0,2 s a 16K, 33,6 s → 0,4 s a 30K) y no cambia la velocidad de decodificación. Las visitas a la caché de expertos fueron del 98,7 al 98,8% en modo rápido; las lecturas de NVMe fueron de 1,1 a 3,3 GB / s mientras los expertos se cargaban y casi nulas durante la decodificación JSON estable.
En una solicitud de 30,151 tokens con un límite de 32,768, el motor ajusta el presupuesto de respuesta por sí mismo y termina con stop o length, sin error. Solo un mensaje que no encaja por sí solo devuelve el error 400.
Hardware durante las carreras
| Bloque | Potencia | Temperatura | Reloj SM | VRAM | Intercambio | Lectura NVMe |
|---|---|---|---|---|---|---|
| Modo rápido | 162–169 W (max 170.2) | 74–76 °C | 1815–1875 MHz | 11 409–11 423 MiB | 0 | 0.2–4.7 GB/s (6.6) |
| Modo preciso | 88–105 W (max 167) | 62–71 °C | 1965–1972 MHz | 11 425 MiB | 0 | 1.6–2.3 GB/s (6.1) |
Rangos a través de los bloques medidos; valores máximos entre paréntesis. El modo rápido está limitado por la potencia de la GPU: en el límite de 170 W, los relojes caen de 2160 MHz a 1815-1875 MHz a 75 °C, sin limitación térmica, 11.4 de 12.3 GiB de VRAM en uso y sin intercambio. En el modo preciso, la GPU consume aproximadamente la mitad de la energía a los relojes máximos: está esperando a los expertos en lugar de trabajar, por lo que la velocidad disminuye.
Calidad de salida
- El formato JSON no se rompe: en las 12 ejecuciones cortadas por el límite, todos los registros permanecieron válidos; solo la matriz en sí quedó sin cerrar.
- Una instrucción desde el principio del mensaje todavía se sigue a 30K (la regla de la etiqueta se mantiene en la cola, 50/50 y 22/22).
- Un marcador del centro del documento se recupera a 16K y 24K, pero se pierde a 30K, en ambos modos.
- La principal debilidad del modo rápido es repetir entidades en listas largas (26-28 códigos únicos de aproximadamente 190) y un bucle de 122 líneas duplicadas a 30K. El modo preciso a 16K mantuvo 168/168 y 193/193 únicos, pero a 24K y 30K también puede colapsar a 26-33 códigos únicos en una ejecución.
- El código C en modo rápido produjo 255 líneas repetidas de 681, por lo que las tareas de código en modo rápido no son confiables.
Límites de este experimento
Una máquina y una compilación: las conclusiones sobre el límite de potencia de la GPU y el suministro experto se aplican a esta tarjeta con un límite de 170 W y 12 GiB de VRAM. Los modos se cambiaron reiniciando el motor, por lo que las ejecuciones dentro de un modo fueron consecutivas y el orden no se aleatorizó por completo. El modo preciso con caché en caliente se ejecutó una vez, y el modo preciso a 1K y 8K tuvo 2 repeticiones en lugar de 3.
Qué significa para un cliente de Box
- Una tarjeta asequible de 12 GB mantiene de 60 a 68 kb / s en respuestas largas, no solo al principio.
- Los documentos largos en contexto cuestan poca velocidad, y un contexto repetido se responde casi instantáneamente gracias a la caché de solicitud.
- El modo se elige por tarea: rápido para datos estructurados, preciso cuando las listas largas deben permanecer únicas; el código generado necesita revisión.
Datos sin procesar
Los 145 archivos de este experimento están disponibles para descargar: 13 archivos de resultados JSONL, 102 textos de respuesta y razonamiento, telemetría de hardware, registros del motor, scripts, el estado del sistema, el informe original en ruso y el borrador posterior en inglés. Las claves de acceso, las direcciones internas, los nombres de usuario y las rutas internas se eliminaron antes de la publicación.