RTX 3060 12 GB sob carga sustentada: 60-68 tok/s até ao último token

Em 30 de outubro de 2026, executámos uma longa série de medições no B2003, o nosso computador experimental com um RTX 3060 12 GB. O resultado: com o raciocínio em (o padrão), Qwen3.8-Flash-Next IQ3_S em Strata detém 60-68 tok/s do primeiro token para o 8192nd em um prompt de 16K, sem quedas. Com o raciocínio fora, ele é executado em 79-96 tok/s. um contexto quase completo custa apenas cerca de 8%: de um prompt de 1K para um 30K, a mediana vai de 88 para 84 tok/s.

Nosso artigo anterior relatou até 68 Tok / s de decodificação neste cartão. As duas perguntas que mais nos são feitas no X São se essa velocidade se mantém através de uma resposta longa ou é apenas um pico de aquecimento, e se o desempenho se mantém na segunda metade de um contexto longo. Para respondê-las, cronometramos cada token transmitido em vez de calcular a média de toda a resposta.

Verificamos a velocidade em intervalos da mesma resposta, contexto de 1K a 30K tokens, um cache de alerta frio e quente, roteamento especializado rápido e preciso, três tipos de conteúdo (JSON, código C, prosa técnica russa), potência da GPU, Relógios e temperatura, e se a saída em si permaneceu correta.

Configuração

• Máquina B2003: ASUS Pro Q870I-C, Intel Core Ultra 7 265, 2 24 GiB DDR5-5600.
• GPU: RTX 3060 12 GB (GA106), driver 615.71.10, desbloqueio da GPU ligado, limite de potência 170 W.
• Armazenamento: Lexar NM1090 Pro 2 TB NVMe (PCIe 5.0 4).
• Sistema: Ubuntu 24.04.5, kernel 7.0.0-38.
• Motor: estrato 0.1.52 (construção 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

Metodologia

• O servidor não expõe / tokeniza, de modo que os tokens foram contados a partir dos carimbos de data / hora dos blocos SSE transmitidos (1 Bloco 1 token; verifique: 5478 blocos contra 5479 tokens em uso.completion_tokens) e ancorado à contagem exata do token final. Não foram utilizadas palavras e linhas.
• Os Prompts foram calibrados com sondas usando max_tokens: 1 (20,2 tokens por frase de preenchimento, 145 tokens de sobrecarga fixa); o tamanho real foi verificado em relação ao uso.prompt_tokens.
• O comprimento da resposta foi 32768 menos o prompt menos uma margem, até 8192 tokens; em 30K, são 2048 tokens.
• Cada cenário-chave foi repetido pelo menos 3 vezes; relatamos a mediana, o mínimo e o máximo. O ruído de descodificação é de 20% e o ruído de pré-enchimento de 5%; diferenças menores não foram contabilizadas como resultados.
• A telemetria de Hardware foi registada a cada 3 segundos (relógios, potência, temperatura, utilização, VRAM, RAM livre, swap, contadores de leitura NVMe). Pré-preenchimento, aceitação de rascunho MTP, ocorrências de cache de especialistas e leituras de nível de arquivo vieram do log do mecanismo.
• Dois modos de roteamento especializados: rápido (roteamento padrão, anterior 1.5) e preciso (STRATA_ROUTE_PRIOR=0). Os modos foram trocados reiniciando o motor.
• 4 linhas no arquivo de modo preciso foram produzidas pelo mecanismo rápido porque o script de bloco foi reescrito durante a execução. São excluídos dos quadros e mantidos no arquivo TAL COMO ESTÃO.
• No total: 52 execuções medidas em 13 ficheiros JSONL (14 no modo rápido, 13 no modo preciso e 25 variantes: raciocínio, Cache quente, código, prosa, limite de contexto, calibração), mais as 4 linhas excluídas.

Resultados: velocidade dentro da resposta

Valores em tok/s, mediana (min–max). O contexto é o tamanho do prompt em tokens; a resposta é de até 8192 tokens (2048 a 30K).

Modo rápido, raciocínio desligado

Modo rápido, raciocínio ativado (comportamento predefinido)

Modo preciso, raciocínio desligado

No modo rápido, a velocidade é plana ou aumenta no final da resposta (16K: 79933, cauda 95). Uma desaceleração no final aparece apenas no modo preciso: 29 22 sobre 8000 tokens (-24%). O modo preciso com raciocínio em 16K dá 25 tok/s para toda a resposta. O encaminhamento rápido é 3,8 mais rápido do que o encaminhamento preciso.

Tipo de conteúdo (modo rápido, contexto 16K)

As diferenças são várias vezes maiores do que o ruído de descodificação: a estrutura previsível acelera a geração de 2–2.3×, a prosa livre diminui a velocidade. Esta é uma propriedade do conteúdo, não uma desaceleração ao longo do tempo.

Pré-preenchimento, tempo para o primeiro token e cache de prompt

Um cache de alerta quente remove quase todo o pré-preenchimento (17,4 s 0,2 s a 16K, 33,6 s 0,4 s a 30K) e não altera a velocidade de descodificação. As ocorrências de cache de especialistas foram de 98,7 a 98,8% no modo rápido; as leituras de NVMe foram de 1,1 a 3,3 GB/s enquanto os especialistas estavam carregando e quase zero durante a decodificação JSON constante.

Em um prompt de 30.151 tokens com um limite de 32.768, o motor corta o próprio orçamento de resposta e termina com parada ou comprimento, sem erro. Apenas um prompt que não cabe por si só retorna o erro 400.

Hardware durante as execuções

Intervalos entre os blocos medidos; valores máximos entre parênteses. O modo rápido é limitado pela potência da GPU: no limite de 170 W, os relógios caem de 2160 MHz para 1815-1875 MHz a 75 C, sem estrangulamento térmico, 11,4 de 12,3 GiB VRAM em uso e sem troca. No modo preciso, a GPU consome cerca de metade da potência nos relógios máximos: está à espera de especialistas em vez de trabalhar, razão pela qual a velocidade cai.

Qualidade de saída

• O formato JSON não quebra: em todas as 12 execuções cortadas pelo limite, todos os registros permaneceram válidos; apenas a matriz em si não foi fechada.
• Uma instrução desde o início do prompt ainda é seguida em 30K (a regra da etiqueta mantida na cauda, 50/50 e 22/22).
• Um marcador do meio do documento é recolhido em 16K e 24K, mas perdido em 30K, em ambos os modos.
• A principal fraqueza do modo rápido é repetir entidades em listas longas (26-28 códigos únicos de cerca de 190) e um loop de 122 linhas duplicadas em 30K. o modo preciso em 16K manteve 168/168 e 193/193 únicos, mas em 24K e 30K também pode reduzir para 26-33 códigos únicos em uma corrida.
• O código C no modo rápido produziu 255 linhas repetidas de 681, pelo que as tarefas de código no modo rápido não são fiáveis.

Limites desta experiência

Uma máquina e uma construção: as conclusões sobre o limite de potência da GPU e o fornecimento especializado aplicam-se a esta placa com um limite de 170 W e 12 GiB de VRAM. Os modos foram comutados reiniciando o motor, pelo que o funcionamento dentro de um modo foi consecutivo e a ordem não foi totalmente aleatorizada. O modo preciso com um cache quente foi executado uma vez, e o modo preciso em 1K e 8K teve 2 repetições em vez de 3.

O que isto significa para um cliente Box

• Um cartão de 12 GB acessível mantém 60-68 tok/s através de respostas longas, não apenas no início.
• Documentos longos no contexto custam pouca velocidade, e um contexto repetido é respondido quase instantaneamente graças ao cache de prompt.
• O modo é escolhido por tarefa: rápido para dados estruturados, preciso quando as listas longas devem permanecer únicas; o código gerado precisa de revisão.

Dados brutos

Todos os 145 ficheiros desta experiência estão disponíveis para download: 13 ficheiros de resultados JSONL, 102 textos de resposta e raciocínio, telemetria de hardware, registos do motor, scripts, o estado do sistema, o relatório original em russo e o post draft em inglês. As chaves de acesso, os endereços internos, os nomes de utilizador e os caminhos internos foram removidos antes da publicação.

Baixar tar.gz (264 KB) · Baixar zip (298 KB)

O artigo RTX 3060 · Todas as notícias