RTX 3060 12 GB sotto carico prolungato: 60–68 tok/s fino all’ultimo token

Il 30 ottobre 2026 abbiamo eseguito una lunga serie di misurazioni su B2003, il nostro computer per gli esperimenti con una RTX 3060 12 GB. Il risultato: con il ragionamento attivo (impostazione predefinita), Qwen3.8-Flash-Next IQ3_S su Strata mantiene 60–68 tok/s dal primo all’8192° token con un prompt di 16K, senza cali. Senza ragionamento arriva a 79–96 tok/s. Un contesto quasi pieno costa solo l’8% circa: da un prompt di 1K a uno di 30K la mediana passa da 88 a 84 tok/s.

Nel nostro articolo precedente abbiamo riportato fino a 68 tok/s in decodifica su questa scheda. Le due domande che ci fanno più spesso su X sono se quella velocità regge per tutta una risposta lunga o è solo un picco iniziale, e se le prestazioni reggono nella seconda metà di un contesto lungo. Per rispondere abbiamo cronometrato ogni token in streaming invece di fare la media sull’intera risposta.

Abbiamo verificato la velocità su intervalli della stessa risposta, il contesto da 1K a 30K token, la cache del prompt fredda e calda, il routing degli esperti veloce e preciso, tre tipi di contenuto (JSON, codice C, prosa tecnica in russo), potenza, frequenze e temperatura della GPU, e se la risposta stessa restava corretta.

Configurazione

• Macchina 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, GPU unlock attivo, limite di potenza 170 W.
• Archiviazione: Lexar NM1090 PRO 2 TB NVMe (PCIe 5.0 ×4).
• Sistema: Ubuntu 24.04.5, kernel 7.0.0-38.
• Motore: Strata 0.1.52 (build f-027-rel).
• Modello: Qwen3.8-Flash-Next-GSQ-RCO-IQ3_S (78 GiB, 2 shard).

--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

• Il server non espone /tokenize, quindi i token sono stati contati dai timestamp dei chunk SSE in streaming (1 chunk ≈ 1 token; verifica: 5478 chunk contro 5479 token in usage.completion_tokens) e ancorati al numero esatto di token finale. Parole e righe non sono state usate.
• I prompt sono stati calibrati con richieste di calibrazione con max_tokens: 1 (20.2 token per frase di riempimento, 145 token di overhead fisso); la dimensione reale è stata confrontata con usage.prompt_tokens.
• La lunghezza della risposta era 32768 meno il prompt meno un margine, fino a 8192 token; a 30K sono 2048 token.
• Ogni scenario chiave è stato ripetuto almeno 3 volte; riportiamo la mediana, il minimo e il massimo. Il rumore di decodifica è ±20% e il rumore di prefill ±5%; differenze minori non sono state conteggiate come risultati.
• La telemetria hardware è stata registrata ogni 3 secondi (frequenze, potenza, temperatura, utilizzo, VRAM, RAM libera, swap, contatori di lettura NVMe). Prefill, accettazione delle bozze MTP, hit della cache degli esperti e letture dal livello file provengono dal log del motore.
• Due modalità di routing degli esperti: veloce (routing predefinito, prior 1.5) e precisa (STRATA_ROUTE_PRIOR=0). Le modalità sono state cambiate riavviando il motore.
• 4 righe nel file della modalità precisa sono state prodotte dal motore veloce perché lo script del blocco è stato riscritto durante l’esecuzione. Sono escluse dalle tabelle e conservate nell’archivio così come sono.
• In totale: 52 esecuzioni misurate in 13 file JSONL (14 in modalità veloce, 13 in modalità precisa e 25 varianti: ragionamento, cache calda, codice, prosa, limite di contesto, calibrazione), più le 4 righe escluse.

Risultati: velocità all'interno della risposta

Valori in tok/s, mediana (min–max). Il contesto è la dimensione del prompt in token; la risposta arriva fino a 8192 token (2048 a 30K).

Modalità veloce, ragionamento disattivato

Modalità veloce, ragionamento attivo (comportamento predefinito)

Modalità precisa, ragionamento disattivato

In modalità veloce la velocità resta piatta o sale verso la fine della risposta (16K: 79 → 93, coda 95). Un rallentamento verso la fine compare solo in modalità precisa: 29 → 22 su 8000 token (−24%). La modalità precisa con ragionamento a 16K dà 25 tok/s sull’intera risposta. Il routing veloce è 3.8× più rapido di quello preciso.

Tipo di contenuto (modalità veloce, contesto 16K)

Le differenze sono molto più grandi del rumore di decodifica: una struttura prevedibile accelera la generazione di 2–2.3×, la prosa libera la rallenta. È una proprietà del contenuto, non un rallentamento nel tempo.

Prefill, tempo al primo token e cache del prompt

Una cache del prompt calda elimina quasi tutto il prefill (17.4 s → 0.2 s a 16K, 33.6 s → 0.4 s a 30K) e non cambia la velocità di decodifica. Gli hit della cache degli esperti erano 98.7–98.8% in modalità veloce; le letture NVMe erano 1.1–3.3 GB/s mentre si caricavano gli esperti e quasi zero durante la decodifica stabile del JSON.

Con un prompt di 30 151 token e un limite di 32 768, il motore riduce da solo il budget della risposta e termina con stop o length, senza errori. Solo un prompt che da solo non entra nel limite restituisce l’errore 400.

L’hardware durante le esecuzioni

Intervalli tra i blocchi misurati; valori di picco tra parentesi. La modalità veloce è limitata dalla potenza della GPU: al limite di 170 W le frequenze scendono da 2160 MHz a 1815–1875 MHz a 75 °C, senza throttling termico, con 11.4 di 12.3 GiB di VRAM occupati e senza swap. In modalità precisa la GPU assorbe circa metà della potenza alle frequenze massime: aspetta gli esperti invece di lavorare, ed è per questo che la velocità cala.

Qualità della risposta

• Il formato JSON non si rompe: in tutte le 12 esecuzioni tagliate dal limite ogni record è rimasto valido; solo l'array stesso è stato lasciato non chiuso.
• Un’istruzione dall’inizio del prompt viene ancora rispettata a 30K (la regola dei tag ha tenuto nella coda, 50/50 e 22/22).
• Un marcatore dal centro del documento viene ricordato a 16K e 24K ma perso a 30K, in entrambe le modalità.
• Il principale punto debole della modalità veloce è la ripetizione di entità negli elenchi lunghi (26–28 codici unici su circa 190) e un ciclo di 122 righe duplicate a 30K. La modalità precisa a 16K ha mantenuto 168/168 e 193/193 unici, ma a 24K e 30K può anch’essa scendere a 26–33 codici unici in un’esecuzione.
• Il codice C in modalità veloce ha prodotto 255 righe ripetute su 681, quindi per il codice la modalità veloce non è affidabile.

Limiti di questo esperimento

Una macchina e una build: le conclusioni sul limite di potenza della GPU e sull’afflusso degli esperti valgono per questa scheda con un limite di 170 W e 12 GiB di VRAM. Le modalità sono state cambiate riavviando il motore, quindi le esecuzioni di una modalità erano consecutive e l’ordine non è stato del tutto randomizzato. La modalità precisa con cache calda è stata eseguita una volta, e a 1K e 8K la modalità precisa ha avuto 2 ripetizioni invece di 3.

Cosa significa per un cliente Box

• Una scheda accessibile da 12 GB mantiene 60–68 tok/s lungo le risposte lunghe, non solo all’inizio.
• I documenti lunghi nel contesto costano poca velocità, e su un contesto ripetuto la risposta parte quasi all’istante grazie alla cache del prompt.
• La modalità viene scelta per attività: veloce per i dati strutturati, precisa quando gli elenchi lunghi devono rimanere univoci; il codice generato deve essere rivisto.

Dati grezzi

Tutti i 145 file di questo esperimento sono disponibili per il download: 13 file di risultati JSONL, 102 testi di risposte e ragionamenti, telemetria hardware, log del motore, script, lo stato del sistema, il rapporto originale in russo e la bozza del post in inglese. Chiavi di accesso, indirizzi interni, nomi utente e percorsi interni sono stati rimossi prima della pubblicazione.

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

L’articolo sulla RTX 3060 · Tutte le notizie