Știri
RTX 3060 12 GB sub sarcină susținută: 60–68 tok/s până la ultimul tok
Am măsurat viteza în interiorul fiecărui răspuns lung, jeton cu jeton, în loc să facem o medie: 60–68 de jetoane cu raționament pe un răspuns de 8192 de jetoane la contextul 16K, 79-96 de jetoane fără raționament și doar aproximativ 8% pierdute de la 1K la 30K prompt. Toate cele 145 de fișiere RAW sunt disponibile pentru descărcare.
La 30 octombrie 2026 am efectuat o serie lungă de măsurători pe B2003, computerul nostru experimental cu un RTX 3060 de 12 GB. Rezultatul: cu raționamentul (implicit), Qwen3.8-Flash-Next IQ3_S pe Strata deține 60–68 tok/s de la primul token până la 8192nd la un prompt de 16K, fără căderi. Fără raționament, se execută la 79–96 tok/s. Un context aproape complet costă doar aproximativ 8%: de la 1K la 30K prompt, mediana merge de la 88 la 84 tok/s.
Articolul nostru anterior a raportat o decodare de până la 68 de tok/s pe acest card. Cele două întrebări care ni se pun cel mai des pe X sunt dacă această viteză rezistă la un răspuns lung sau este doar un vârf de încălzire și dacă performanța rezistă în a doua jumătate a unui context lung. Pentru a le răspunde, am cronometrat fiecare jeton transmis în flux, în loc să facem o medie a întregului răspuns.
Am verificat viteza în intervale de același răspuns, contextul de la 1K la 30K token-uri, un cache prompt rece și cald, rutare rapidă și precisă a experților, trei tipuri de conținut (JSON, cod C, proză tehnică rusă), putere GPU, ceasuri și temperatură și dacă ieșirea în sine a rămas corectă.
Configurare
- Utilaj 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, deblocare GPU activată, limită de putere 170 W.
- Depozitare: Lexar NM1090 PRO 2 TB NVMe (PCIe 5.0 ×4).
- Sistem: Ubuntu 24.04.5, kernel 7.0.0-38.
- Motor: Straturi 0.1.52 (build f-027-rel).
- Model: Qwen3.8-Flash-Next-GSQ-RCO-IQ3_S (78 GiB, 2 cioburi).
--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=10Metodologie
- Serverul nu expune /tokenizează, astfel încât jetoanele au fost numărate de la marcajele de timp ale bucăților SSE redate în flux (1 bucată ≈ 1 jeton; verificați: 5478 bucăți față de 5479 de jetoane din use.completion_tokens) și ancorate la numărul final exact de jetoane. Cuvintele și liniile nu au fost folosite.
- Solicitările au fost calibrate cu sonde folosind max_token: 1 (20,2 token-uri per propoziție de umplere, 145 de token-uri de deasupra capului fix); dimensiunea reală a fost verificată în raport cu use.prompt_tokens.
- Lungimea răspunsului a fost de 32768 minus solicitarea minus o marjă, până la 8192 de jetoane; la 30K, aceasta este de 2048 de jetoane.
- Fiecare scenariu cheie a fost repetat de cel puțin 3 ori; raportăm mediana, minimul și maximul. Zgomotul de decodificare este de ±20% și zgomotul de preumplere de ±5%; diferențele mai mici nu au fost luate în considerare ca rezultate.
- Telemetria hardware a fost înregistrată la fiecare 3 secunde (ceasuri, putere, temperatură, utilizare, VRAM, RAM liber, swap, contoare de citire NVMe). Precompletarea, acceptarea proiectului MTP, accesările expert-cache și citirile la nivel de fișier au provenit din jurnalul motorului.
- Două moduri de rutare expert: rapidă (rutare implicită, anterioară 1.5) și precisă (STRATA_ROUTE_PRIOR=0). Modurile au fost comutate prin repornirea motorului.
- Motorul rapid a produs 4 rânduri în fișierul modului precis, deoarece scriptul de blocare a fost rescris în timpul rulării. Acestea sunt excluse din tabele și păstrate în arhivă ca atare.
- În total: 52 de rulări măsurate în 13 fișiere JSONL (14 în modul rapid, 13 în modul precis și 25 de variante: raționament, cache cald, cod, proză, limită contextuală, calibrare), plus cele 4 rânduri excluse.
Rezultate: viteza în interiorul răspunsului
Valori în tok/s, mediană (min–max). Contextul este dimensiunea promptă în jetoane; răspunsul este de până la 8192 de jetoane (2048 la 30K).
Mod rapid, raționament dezactivat
| Context | Execută | 0–0.5K | 0.5K–1K | 1K–2K | 2K–4K | 4K–6K | 6K–8K | Coadă | Răspuns complet |
|---|---|---|---|---|---|---|---|---|---|
| 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) |
Mod rapid, raționament activat (comportament implicit)
| Context | Execută | 0–0.5K | 0.5K–1K | 1K–2K | 2K–4K | 4K–6K | 6K–8K | Coadă | Răspuns complet |
|---|---|---|---|---|---|---|---|---|---|
| 15854 | 1 | 61 | 68 | 61 | 59 | 58 | 60 | 85 | 60 |
| 30191 | 1 | 66 | 56 | 65 | — | — | — | 96 | 63 |
Mod precis, raționament dezactivat
| Context | Execută | 0–0.5K | 0.5K–1K | 1K–2K | 2K–4K | 4K–6K | 6K–8K | Coadă | Răspuns complet |
|---|---|---|---|---|---|---|---|---|---|
| 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 |
În modul rapid, viteza este plană sau se ridică spre sfârșitul răspunsului (16K: 79 → 93, coada 95). O încetinire spre sfârșit apare numai în modul precis: 29 → 22 peste 8000 de jetoane (−24%). Modul precis cu raționament la 16K oferă 25 de jetoane/s pentru întregul răspuns. Rutarea rapidă este de 3,8× mai rapidă decât rutarea precisă.
Tip de conținut (mod rapid, context 16K)
| Sarcină | Răspuns, jetoane | Răspuns complet, tok/s | Schițe MTP acceptate |
|---|---|---|---|
| Matrice JSON de înregistrări | 8192 | 91 (90–96) | 92% (90–98%) |
| Cod C | 7332 | 59 | 74% |
| Proză tehnică rusă | 4730 | 40 (40–43) | 38% (1327/3485) |
Diferențele sunt de câteva ori mai mari decât zgomotul de decodare: structura previzibilă accelerează generarea cu2–2.3×, proza liberă o încetinește. Aceasta este o proprietate a conținutului, nu o încetinire în timp.
Precompletați, timpul până la primul jeton și solicitați memoria cache
| Caz | Prompt, token-uri | Preumplere la rece, tok/s | Cold TTFT | TTFT cald | Jetoane reutilizate |
|---|---|---|---|---|---|
| 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 |
O memorie cache caldă elimină aproape toată umplutura (17,4 s → 0,2 s la 16K, 33,6 s → 0,4 s la 30K) și nu modifică viteza de decodare. Accesările expert-cache au fost de 98,7-98,8% în modul rapid; citirile NVMe au fost de 1,1-3,3 GB/s în timp ce experții se încărcau și aproape zero în timpul decodificării JSON constante.
La un prompt de 30.151 de jetoane, cu o limită de 32.768, motorul decupează bugetul de răspuns în sine și se termină cu oprire sau lungime, fără nicio eroare. Numai o solicitare care nu se potrivește pe cont propriu returnează eroarea 400.
Hardware în timpul rulării
| Blochează | Putere | Temperatură | Ceas SM | VRAM | Swap | NVMe citit |
|---|---|---|---|---|---|---|
| Mod rapid | 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) |
| Mod precis | 88–105 W (max 167) | 62–71 °C | 1965–1972 MHz | 11 425 MiB | 0 | 1.6–2.3 GB/s (6.1) |
Intervale de-a lungul blocurilor măsurate; valori de vârf între paranteze. Modul rapid este limitat de puterea GPU-ului: la limita de 170 W, ceasurile scad de la 2160 MHz la 1815-1875 MHz la 75 °C, fără limitare termică, 11,4 din 12,3 GiB VRAM în uz și fără comutare. În modul precis, GPU-ul consumă aproximativ jumătate din putere la ceasurile maxime: așteaptă experți, mai degrabă decât să funcționeze, motiv pentru care viteza scade.
Calitate ieșire
- Formatul JSON nu se rupe: în toate cele 12 rulări întrerupte de limită, fiecare înregistrare a rămas valabilă; numai matricea în sine a fost lăsată neînchisă.
- O instrucțiune de la începutul solicitării este încă urmată la 30K (regula etichetei ținută în coadă, 50/50 și 22/22).
- Un marcator din mijlocul documentului este rechemat la 16K și 24K, dar pierdut la 30K, în ambele moduri.
- Principala slăbiciune a modului rapid este repetarea entităților în liste lungi (26–28 de coduri unice din aproximativ 190) și o buclă de 122 de linii duplicate la 30K. Modul precis la 16K a menținut 168/168 și 193/193 unice, dar la 24K și 30K poate, de asemenea, să se prăbușească la 26–33 de coduri unice într-un ciclu.
- Codul C în modul rapid a produs 255 de linii repetate din 681, astfel încât sarcinile de cod în modul rapid nu sunt fiabile.
Limitele acestui experiment
O mașină și o construcție: concluziile despre limita de putere a GPU-ului și alimentarea expertă se aplică acestui card cu o limită de 170 W și 12 GiO de VRAM. Modurile au fost comutate prin repornirea motorului, astfel încât rulările într-un mod au fost consecutive, iar ordinea nu a fost complet randomizată. Modul precis cu o memorie cache caldă a fost rulat o singură dată, iar modul precis la 1K și 8K a avut 2 repetări în loc de 3.
Ce înseamnă pentru un client Box
- Un card accesibil de 12 GB păstrează 60–68 de tok/s prin răspunsuri lungi, nu numai la început.
- Documentele lungi în context costă o viteză mică, iar un context repetat primește răspuns aproape instantaneu datorită cache-ului prompt.
- Modul este ales pentru fiecare sarcină: rapid pentru date structurate, precis atunci când listele lungi trebuie să rămână unice; codul generat trebuie revizuit.
Date brute
Toate cele 145 de fișiere ale acestui experiment sunt disponibile pentru descărcare: 13 fișiere cu rezultate JSONL, 102 texte de răspuns și raționament, telemetrie hardware, jurnale de motor, scripturi, starea sistemului, raportul original în limba rusă și post-proiectul în limba engleză. Cheile de acces, adresele interne, numele de utilizator și căile interne au fost eliminate înainte de publicare.