SSD Nodes Learn Hosting plans →
Guide Matt ConnorDi Matt Connor · Aggiornato 2026-10-26

Come misurare i token al secondo di un LLM locale

Misura il throughput reale del tuo LLM locale con un test a concorrenza variabile: scopri quando una GPU a noleggio supera il costo per token dell'API.

Perché i token al secondo determinano la convenienza di una GPU

I token al secondo indicano la velocità con cui il server genera il testo in output. Questo valore determina se il noleggio di una GPU costa meno del pagamento di un'API per token. Un'istanza GPU viene fatturata a ore, indipendentemente dal fatto che sia utilizzata o inattiva. Un'API gestita viene fatturata in base ai token. La GPU è quindi più conveniente soltanto se mantiene una velocità di output sufficientemente elevata per la maggior parte delle ore pagate.

Per questo serve una misurazione, non un valore trovato altrove. Questa pagina definisce i quattro numeri che conviene registrare, quindi fornisce i comandi per ottenerli e i calcoli necessari per trasformarli in una decisione.

Perché il numero pubblicato di token al secondo non è il tuo

DigitalOcean ha pubblicato nel luglio 2026 i dati di throughput per una singola NVIDIA H200 che esegue llama3.3-70b-instruct in FP8 (floating point a 8 bit) con vLLM. Questi dati sono utili, ma non corrispondono ai tuoi.

GraficoPublished DigitalOcean H200 figures, llama3.3-70b-instruct FP8, July 2026
I dati alla base di questo grafico
[
  {
    "config": "H200, one stream",
    "tok_s": "47"
  },
  {
    "config": "H100, saturated",
    "tok_s": "236"
  },
  {
    "config": "H200, saturated",
    "tok_s": "2,036"
  },
  {
    "config": "H200, saturated, in+out",
    "tok_s": "4,071.6"
  }
]

Ogni riga precedente è citata da quella pagina e due righe rappresentano il limite inferiore di un intervallo indicato nella fonte; considerale quindi come una soglia minima. Nessun dato di questa tabella è stato misurato da noi.

Inizia dalle ultime due righe. Il valore principale è 4,071.6 tok/s, mentre il throughput relativo soltanto all'output è 2,036 tok/s. Il valore principale comprende complessivamente token di input e di output. Il test ha usato 1,024 token di input e 1,024 token di output, quindi quasi esattamente metà del valore principale corrisponde all'output. Questa distinzione è importante perché l'output è la parte più lenta. Il prefill (la lettura del prompt) elabora tutti i token di input in un'unica passata. Il decode (la generazione della risposta) produce un token alla volta. Un valore di throughput complessivo fa quindi la media tra un'operazione poco costosa e una costosa.

Ora considera la prima riga. La stessa H200, quando gestisce una richiesta alla volta, produce 47 tok/s; il valore a saturazione è quindi più di quaranta volte superiore sullo stesso hardware. Questa differenza esiste perché, durante la maggior parte del tempo, un singolo passaggio di decode lascia la GPU in attesa dei dati in memoria; le richieste concorrenti sfruttano quel tempo altrimenti inattivo. La seconda riga, 236 tok/s, si riferisce a una singola H100 sullo stesso modello, limitata dalla KV cache (la cache di key e value, cioè la memoria per richiesta che una conversazione in esecuzione mantiene sulla scheda). Una scheda da 80 GB può contenere meno richieste concorrenti per un modello 70B, quindi raggiunge la saturazione a un valore inferiore.

Se cambi il modello o il rapporto tra input e output, cambiano tutti i numeri precedenti. I dati pubblicati servono a definire le aspettative, non il budget. La stessa regola vale per valutare onestamente le prestazioni di un VPS su disco e rete.

I quattro numeri che contano

  • Time to first token, TTFT. Il ritardo tra l'invio di una richiesta e l'arrivo del primo token in output. Comprende il tempo di prefill e il tempo trascorso in coda. È il parametro che l'utente percepisce direttamente.
  • Token di output al secondo, per stream. La velocità con cui viene generata una risposta dopo l'inizio dell'elaborazione. Oltre circa 20 tok/s, la generazione è già più rapida della velocità di lettura della maggior parte delle persone, quindi un'ulteriore accelerazione offre vantaggi limitati.
  • Throughput totale di output a carico saturo. La somma del throughput di tutti gli stream concorrenti quando il server è completamente sotto carico. È il valore che indica la capacità ed è quello che determina il costo della GPU.
  • p50 e p99 del TTFT in condizioni di concorrenza. p50 è il valore della richiesta centrale. p99 è il valore al di sotto del quale rientrano 99 richieste su 100. L'accodamento si manifesta sempre prima nel p99.

I primi due valori migliorano quando il server è poco utilizzato. Il terzo migliora quando il server è sotto carico. Sono quindi in parte contrapposti. Per questo nessun singolo valore descrive adeguatamente un server di serving.

Correggi le lunghezze di input e output prima di misurare

Il throughput dipende dalla struttura del traffico. Un prompt di 4,000 token con una risposta di 50 token rappresenta un carico concentrato sul prefill. Un prompt di 200 token con una risposta di 2,000 token rappresenta un carico concentrato sul decode. Lo stesso server restituisce valori molto diversi di token al secondo nei due casi. Scegli quindi un rapporto, riportalo accanto a ogni valore registrato e non confrontare mai rapporti diversi. 1,024 token in ingresso e 1,024 in uscita sono un'impostazione predefinita ragionevole, perché diversi vendor pubblicano risultati con questo rapporto. Se conosci il traffico reale, usa quello.

Imponi anche la lunghezza dell'output. Un modello che raggiunge il token di arresto dopo 60 token produce un'esecuzione più breve, che non può essere confrontata con un'esecuzione completa: il TTFT ne costituisce una parte maggiore e riduce il throughput dell'output calcolato dal benchmark, anche se ogni richiesta termina prima. Il flag --ignore-eos nel client di benchmark di vLLM fa generare a ogni richiesta esattamente il numero di token richiesto, mantenendo confrontabili le due esecuzioni. La scelta del modello incide su questi valori più di qualsiasi flag: adattare un modello Qwen 3 a una singola GPU VPS tratta l'aspetto relativo alla memoria di questa scelta.

Misurare prima un singolo stream

Inizia dal caso più semplice. È un controllo di coerenza e stabilisce un limite massimo. Ollama stampa direttamente i propri tempi.

ollama run llama3.1:8b --verbose "Write 200 words about disk scheduling."

La riga da leggere è eval rate, cioè il numero di token generati al secondo. prompt eval rate è la velocità di prefill, mentre load duration è il tempo impiegato per caricare il modello nella VRAM. Alla prima chiamata dopo un avvio a freddo load duration è elevato, quindi total duration è fuorviante. Esegui il comando due volte e leggi il secondo risultato. Per impostazione predefinita, Ollama scarica dalla memoria un modello inattivo dopo cinque minuti. Una pausa lunga tra le esecuzioni riporta quindi al caso di avvio a freddo.

Gli stessi campi sono disponibili tramite API, una modalità più semplice da automatizzare.

curl -s http://127.0.0.1:11434/api/generate -d '{
  "model": "llama3.1:8b",
  "prompt": "Write 200 words about disk scheduling.",
  "stream": false
}' | jq '{eval_count, eval_duration,
         tok_s: (.eval_count / (.eval_duration / 1000000000))}'

eval_duration è espresso in nanosecondi. Dividendo per 1,000,000,000 ottieni i secondi. Questa è esattamente la divisione prescritta dalla documentazione API di Ollama per calcolare i token al secondo. Se il server non è ancora attivo, configurare un LLM self-hosted con Ollama su un VPS descrive l'installazione e l'unità systemd.

Per misurare il TTFT serve una richiesta streaming. curl può misurarlo automaticamente.

curl -s -o /dev/null -N \
  -w 'ttfb=%{time_starttransfer}s  total=%{time_total}s\n' \
  http://127.0.0.1:8000/v1/chat/completions \
  -H 'Content-Type: application/json' \
  -d '{"model":"Qwen/Qwen3-8B",
       "messages":[{"role":"user","content":"Write 200 words about disk scheduling."}],
       "stream":true,"max_tokens":256}'

time_starttransfer indica il momento in cui arriva il primo byte del corpo della risposta. In una chat completion in streaming, quel byte appartiene al primo server-sent event, che contiene il primo token del contenuto oppure un delta che contiene solo il ruolo e viene inviato subito prima. Considera quindi il valore come il TTFT con una tolleranza di un evento. È sufficientemente preciso per confrontare due esecuzioni sullo stesso server.

I valori ottenuti con un singolo stream fanno apparire la macchina migliore per due motivi. Il TTFT è il migliore risultato possibile, perché non ci sono richieste accodate davanti alla tua. Anche la velocità per stream è il massimo ottenibile, perché l'intera scheda gestisce una sola richiesta. Nessuno dei due valori indica quale carico la macchina sia in grado di sostenere.

Come eseguire una scansione della concorrenza?

Una scansione esegue lo stesso carico di lavoro fisso aumentando progressivamente la concorrenza e registra i risultati di ogni passaggio. vLLM include il client necessario e usa l'API OpenAI, quindi funziona anche con Ollama e con qualsiasi altro servizio compatibile con OpenAI.

vllm bench serve \
  --backend openai-chat \
  --base-url http://127.0.0.1:8000 \
  --endpoint /v1/chat/completions \
  --model Qwen/Qwen3-8B \
  --dataset-name random \
  --random-input-len 1024 \
  --random-output-len 1024 \
  --ignore-eos \
  --num-prompts 160 \
  --max-concurrency 16 \
  --percentile-metrics ttft,tpot,itl,e2el \
  --metric-percentiles 50,99

--max-concurrency limita il numero di richieste simultanee ed è la variabile che viene fatta variare. --num-prompts indica il numero totale di richieste inviate, quindi impostalo vicino a dieci volte la concorrenza per ottenere una media stabile. Il riepilogo stampa Output token throughput (tok/s): e Total token throughput (tok/s):, quindi Mean TTFT (ms):, Median TTFT (ms): e P99 TTFT (ms): sotto l'intestazione Time to First Token.

L'output non mostra la velocità per singolo stream, ma il valore si ottiene con una divisione. Mean TPOT (ms): è il tempo medio per token di output dopo il primo, quindi 25 ms per token corrispondono a 40 token al secondo per stream. Dividendo il throughput di output per la concorrenza si ottiene lo stesso risultato.

Esegui quindi il ciclo e salva ogni esecuzione.

for C in 1 4 16 32 64 128; do
  vllm bench serve \
    --backend openai-chat \
    --base-url http://127.0.0.1:8000 \
    --endpoint /v1/chat/completions \
    --model Qwen/Qwen3-8B \
    --dataset-name random \
    --random-input-len 1024 \
    --random-output-len 1024 \
    --ignore-eos \
    --num-prompts $(( C * 10 )) \
    --max-concurrency "$C" \
    --percentile-metrics ttft,tpot,itl,e2el \
    --metric-percentiles 50,99 \
    --save-result --result-filename "sweep-c$C.json"
done
Lettura dei file JSON salvati

Ogni esecuzione scrive un file, quindi estrai contemporaneamente i campi che ti interessano da tutti i file.

for f in sweep-c*.json; do
  jq -r --arg f "$f" \
    '[$f, .output_throughput, .total_token_throughput,
      .median_ttft_ms, .p99_ttft_ms] | @tsv' "$f"
done

output_throughput indica i token di output al secondo. total_token_throughput somma anche i token di input, quindi con un rapporto 1:1 il valore è quasi doppio. p99_ttft_ms sarebbe presente anche senza --metric-percentiles, perché quel flag ha come valore predefinito 99. Il valore 50 nel comando aggiunge p50_ttft_ms accanto a median_ttft_ms, che ogni metrica indicata in --percentile-metrics riceve. Se richiedi un percentile che non hai specificato, ad esempio .p90_ttft_ms, jq stampa null.

Che cosa mostra realmente uno sweep della concorrenza?

GraficoIllustrative sweep shape: 8B model, one 24 GB GPU, 1024 in / 1024 out
I dati alla base di questo grafico
[
  {
    "label": "1 stream",
    "per_stream_tok_s": 92,
    "total_tok_s": 92,
    "ttft_p50_ms": 48,
    "ttft_p99_ms": 61
  },
  {
    "label": "4 streams",
    "per_stream_tok_s": 88,
    "total_tok_s": 352,
    "ttft_p50_ms": 71,
    "ttft_p99_ms": 96
  },
  {
    "label": "16 streams",
    "per_stream_tok_s": 71,
    "total_tok_s": 1136,
    "ttft_p50_ms": 152,
    "ttft_p99_ms": 244
  },
  {
    "label": "32 streams",
    "per_stream_tok_s": 54,
    "total_tok_s": 1728,
    "ttft_p50_ms": 287,
    "ttft_p99_ms": 498
  },
  {
    "label": "64 streams",
    "per_stream_tok_s": 34,
    "total_tok_s": 2176,
    "ttft_p50_ms": 611,
    "ttft_p99_ms": 1240
  },
  {
    "label": "128 streams",
    "per_stream_tok_s": 18,
    "total_tok_s": 2304,
    "ttft_p50_ms": 1490,
    "ttft_p99_ms": 3820
  }
]

Le 6 righe sono un esempio della forma che produce uno sweep su una piccola GPU disponibile a noleggio, con ordini di grandezza plausibili. Non sono una misurazione del tuo server e non sono un dato del fornitore. Esegui il loop precedente e sostituiscile con i tuoi valori.

Osserva la forma, perché è questo l'aspetto generalizzabile. Con un solo stream, l'intera macchina produce 92 token al secondo, con un TTFT p99 di 61 ms. A 128 streams, il totale raggiunge 2304 token al secondo, venticinque volte di più, mentre la velocità di ogni singolo stream scende a 18 token al secondo e il TTFT p99 raggiunge 3820 ms. Il throughput totale aumenta perché il batching trasforma i tempi di attesa della memoria in lavoro utile. La velocità per stream diminuisce perché la stessa capacità di calcolo viene condivisa.

L'ultimo raddoppio è indicativo. Passare da 64 a 128 stream aggiunge meno del sei percento al totale, mentre il TTFT p99 quasi triplica. Questo indica che le richieste sono in coda invece di essere elaborate, perché la cache KV è piena oppure perché il server ha raggiunto un limite di scheduling, ad esempio max_num_seqs di vLLM. Il punto operativo utile è precedente: con 32 stream, la macchina restituisce ancora 1728 token al secondo, pari al 75 percento del picco, a 54 token al secondo per stream e con un TTFT p99 di 498 ms. Riporta questo punto come capacità del sistema. Il picco della curva non è un valore al quale puoi servire gli utenti.

Ollama e vLLM non misurano la stessa cosa

Esegui quella scansione su un server Ollama con la configurazione predefinita: il totale cambierà appena. OLLAMA_NUM_PARALLEL ha valore predefinito 1, quindi viene eseguita una richiesta mentre le altre restano in attesa. È la coda a far aumentare il p99 del TTFT, mentre l'output totale resta stabile. Aumenta questo valore prima di eseguire qualsiasi misurazione.

sudo systemctl edit ollama.service
[Service]
Environment="OLLAMA_NUM_PARALLEL=8"

Riavvia con sudo systemctl restart ollama, quindi verifica che il modello rientri ancora nella memoria disponibile. Ogni slot parallelo riceve la propria parte della finestra di contesto. La documentazione di Ollama specifica quindi che un contesto di 2K con 4 richieste parallele alloca 8K. Se aumenti abbastanza il numero di slot, il modello esce dalla VRAM. Controlla ollama ps: se la colonna PROCESSOR mostra un valore simile a 48%/52% CPU/GPU, una parte del modello si trova sulla CPU e il throughput diminuirà all'aumentare della concorrenza, invece di aumentare. Oltre il numero di slot paralleli, le richieste vengono accodate fino a OLLAMA_MAX_QUEUE, che per impostazione predefinita è 512; in seguito il server risponde con 503.

vLLM usa il continuous batching. Ammette quindi nuove richieste nel batch in esecuzione quando gli slot si liberano. La curva continua a crescere finché una risorsa non si esaurisce: di solito la cache KV, anche se un limite configurato come max_num_seqs o l'overhead della pianificazione sulla CPU può appiattirla prima. Ollama è ottimizzato per un modello, una macchina e costi di configurazione ridotti. I due motori forniscono quindi risposte diverse alla stessa scansione. Questo è il vero argomento di Confronto tra Ollama e vLLM come motori di serving. Registra il motore e la versione che hanno prodotto ogni valore.

Cinque modi per misurare la cosa sbagliata

  • Il client è lontano. Eseguire il benchmark dal laptop tramite Internet aggiunge il tuo round trip a ogni TTFT, quindi stai misurando la tua connessione domestica. Esegui il client nella stessa regione del server.
  • Il modello era a freddo. La prima richiesta deve caricare i pesi e, con vLLM, può anche eseguire la graph capture. Invia un batch di riscaldamento e scarta il risultato.
  • La prefix caching ha risposto al posto tuo. vLLM abilita la prefix caching automatica per impostazione predefinita. Se invii ripetutamente lo stesso prompt, misuri la cache invece del prefill e il TTFT crolla a una frazione del valore reale. --dataset-name random evita questo problema perché ogni prompt è diverso. Per esserne certo, avvia il server con --no-enable-prefix-caching.
  • Gli output erano brevi. Con risposte di 32 token, il TTFT domina ogni richiesta e i token al secondo descrivono in realtà il prefill. Usa --ignore-eos con una lunghezza dell'output realistica.
  • Hai riportato solo la concorrenza 1. Fornisce il TTFT più favorevole nella tabella ed è l'input corretto per i costi solo se le richieste reali non si sovrappongono mai. Se invece si sovrappongono, il costo dipende dal throughput sostenuto alla concorrenza generata effettivamente dal traffico. Esegui quindi la misurazione anche a quel livello.

Trasformare il valore misurato in una decisione

Prendi il throughput di output indicato dalla scansione alla concorrenza raggiunta dal traffico reale e confrontalo con il prezzo per token. Quel valore rappresenta il throughput a saturazione solo se un numero sufficiente di richieste si sovrappone da mantenere pieno il batch; un carico di lavoro che invia una richiesta alla volta deve usare la velocità del singolo stream. Il punto di pareggio si calcola con una divisione, dopo aver considerato il prezzo dei token di input associati a ogni token di output:

cost_per_million_output = price_out + price_in * (input_tokens / output_tokens)
break_even_tok_s = (price_per_hour / cost_per_million_output) * 1000000 / 3600

Applica il calcolo ai prezzi di DigitalOcean di luglio 2026. Il loro endpoint di inferenza dedicato H200 costava $4.47 all'ora, mentre Llama 3.3 70B serverless costava $0.65 per milione di token di input e $0.65 per milione di token di output. Con il rapporto 1:1 usato sopra, ogni milione di token di output include un milione di token di input, quindi il prezzo effettivo è $1.30 per milione di token di output. Di conseguenza, 4.47 diviso 1.30 equivale a circa 3.44 milioni di token di output all'ora. Dividendo per 3,600 secondi si ottengono circa 955 token di output al secondo, oppure circa 1,910 token al secondo considerando insieme input e output. I prezzi sono quelli pubblicati da DigitalOcean. La divisione è nostra. Quando abbiamo verificato il 25 ottobre 2026, l'endpoint H200 costava ancora $4.47 all'ora, ma DigitalOcean aveva dichiarato obsoleto Llama 3.3 70B serverless il 18 agosto 2026 e indirizzava gli utenti a Llama 4 Maverick, indicato a $0.25 per milione di token di input e $0.87 per milione di token di output. Si tratta di un modello diverso, quindi serve una scansione dedicata prima che il confronto abbia valore.

La parola decisiva è continuativo. Raggiungere 955 token di output al secondo a saturazione per due ore al giorno non significa mantenere 955 token di output al secondo, perché paghi anche le altre ventidue ore. Noleggiare la scheda come GPU Droplet non riduce la soglia: il 25 ottobre 2026 i prezzi dei Droplet di DigitalOcean indicavano l'H200 a $4.47 all'ora on demand, lo stesso prezzo dell'endpoint. Inoltre, i Droplet NVIDIA più economici, RTX 4000 a $0.76 all'ora e L40S o RTX 6000 a $1.57 all'ora, sono troppo piccoli per contenere un modello 70B in FP8. In base ai valori precedenti, un H200 che raggiunge la saturazione a 2,036 token di output al secondo deve mantenere in media circa il 47 percento del picco per ogni ora pagata solo per pareggiare il costo di $0.65 per milione di token di input e output. Al di sotto di tale valore, conviene il prezzo per token. Di solito sono le ore di GPU inattiva, non i token elaborati lentamente, a rendere antieconomico il self-hosting.

La decisione dipende quindi da due valori. La scansione indica il limite massimo. Il profilo del traffico indica quale frazione di quel limite riesci effettivamente a utilizzare. Moltiplicali, quindi porta il risultato a confronto tra GPU VPS e API a token al punto di pareggio e individua la risposta per il tuo volume.

FAQ

Qual è un buon numero di token al secondo per un LLM self-hosted?

Ci sono due risposte, perché questa metrica svolge due funzioni. Per una persona che legge l'output, qualsiasi valore superiore a circa 20 token generati al secondo per stream è già più veloce della velocità di lettura, quindi un valore maggiore non offre vantaggi. Per i costi, conta il throughput totale dell'output che puoi sostenere con il carico reale; un valore è buono se consente di superare il punto di pareggio. Rispetto a un costo di $0.65 per milione di token, sia in input sia in output, su un server dal costo di $4.47 all'ora, questa soglia è di circa 955 token generati al secondo sostenuti con un rapporto 1:1 e con i prezzi di luglio 2026. Un singolo stream su un modello di grandi dimensioni non la raggiunge mai. È questo il motivo per cui esiste il batching.

Perché il throughput di Ollama rimane invariato quando aggiungo richieste simultanee?

OLLAMA_NUM_PARALLEL ha come valore predefinito 1. Di conseguenza, il server elabora una richiesta alla volta per ogni modello e accoda le altre, fino a OLLAMA_MAX_QUEUE (512 per impostazione predefinita), prima di restituire 503. L'output totale rimane invariato mentre il p99 TTFT aumenta. Questo indica la presenza di una coda, non di una GPU satura. Imposta la variabile in un drop-in di systemd e riavvia il servizio. Controlla quindi ollama ps, perché ogni slot parallelo moltiplica il contesto allocato e può spostare parte del modello sulla CPU.

Devo misurare il tempo al primo token o i token al secondo?

Entrambi, perché aumentano in direzioni opposte quando il carico cresce. Il TTFT è ciò che percepisce l'utente, mentre il throughput dell'output a saturazione è ciò che incide sulla fattura. Registra il TTFT p50 e p99 a ogni livello di concorrenza. Scegli quindi il livello più alto per cui il p99 TTFT è ancora accettabile. Considera il throughput a quel livello come la tua capacità, non il valore massimo all'estremità superiore della curva.

Un valore più alto di token al secondo indica sempre un costo inferiore per token?

No. Il costo per token è il prezzo orario diviso per il numero di token effettivamente generati dal server durante quell'ora. Un server veloce che rimane inattivo per gran parte della giornata ha quindi comunque un costo per token elevato. A determinare il costo è il livello di utilizzo, non la velocità di picco. Controlla anche le unità: un throughput totale dei token dichiarato include i token di input, quindi con un rapporto 1:1 tra input e output è vicino al doppio della velocità dell'output. Se l'API con cui effettui il confronto addebita sia i token di input sia quelli di output, calcola il costo di entrambe le componenti prima del confronto.

Questo articolo ti è stato utile?

#benchmarking#tokens-per-second#vllm#ollama#gpu-vps