Prefill vs decode: perché il primo token è lento
Il prefill limita il time to first token perché è compute bound; il decode limita i token al secondo perché è memory bandwidth bound. Misurali separatamente.
Prefill e decode, in un paragrafo
La distinzione tra prefill e decode spiega la maggior parte delle questioni relative alla latenza di un LLM (large language model) self-hosted. Il prefill legge l’intero prompt in un’unica passata ed è limitato dalla capacità di calcolo. Il decode genera la risposta un token alla volta ed è limitato dalla larghezza di banda della memoria. Il time to first token è un valore del prefill. I token al secondo sono un valore del decode.
Entrambe le fasi vengono eseguite sulla stessa GPU (graphics processing unit), con gli stessi pesi e all’interno dello stesso processo, quindi è naturale considerarle un unico carico di lavoro. Si comportano come due programmi diversi che condividono lo stesso dispositivo. Separando le due fasi, una lunga serie di risultati apparentemente confusi diventa comprensibile.
Perché il prefill è vincolato dal calcolo?
Il prefill fa passare l’intero prompt attraverso ogni livello una volta. Un prompt di 2,000 token fornisce a ogni moltiplicazione tra matrici 2,000 righe di lavoro. La GPU esegue quindi molti calcoli per ogni byte di pesi che carica. Questo rapporto, cioè il numero di operazioni aritmetiche per byte trasferito, si chiama intensità aritmetica. Nel prefill è elevata. Il dispositivo opera vicino al limite di calcolo, mentre il bus di memoria ha capacità inutilizzata.
Il prefill produce due elementi: la cache KV, cioè i tensori key e value, per ogni token del prompt, e il primo token generato. Il lettore non riceve nulla finché questa fase non è completata. Per questo, su un server non occupato, il prefill rappresenta gran parte del time to first token (TTFT). Nella definizione della guida di benchmarking di NVIDIA, il TTFT include anche l’accodamento della richiesta e la latenza di rete. Su un server occupato, quindi, l’attesa in coda può incidere quanto il prompt.
Il costo del prefill cresce con la lunghezza del prompt. La componente lineare è il lavoro delle moltiplicazioni tra matrici eseguito in ogni livello. La componente quadratica è l’attention: ogni token considera tutti i token precedenti. Questa componente diventa rilevante con contesti lunghi. Di conseguenza, raddoppiare il prompt raddoppia almeno la parte di TTFT dovuta al prefill.
Puoi verificarlo in un minuto. Invia al server prima un prompt di 200 token e poi uno di 2,000 token, chiedendo ogni volta lo stesso numero di token in output. Il TTFT aumenta sensibilmente. La velocità di streaming dopo il primo token cambia invece di poco.
Perché il decode è vincolato dalla larghezza di banda della memoria?
Il decode produce un token per ogni passaggio. Per produrre quel singolo token, la GPU deve leggere dalla memoria tutti i pesi del modello, usare ogni peso per un paio di operazioni e poi scartarlo. L'intensità aritmetica è prossima a 1, quindi le unità di calcolo trascorrono la maggior parte del tempo in attesa.
Il decode è lento perché ogni token richiede la lettura dell'intero modello dalla memoria. È quindi il bus di memoria a determinare il ritmo, mentre le unità di calcolo restano inattive.
Questo consente di calcolare su carta il limite superiore della velocità di decode su un singolo flusso. Dividi la larghezza di banda della memoria per il numero di byte occupati dai pesi.
I dati alla base di questo grafico
[
{
"device": "CPU, dual channel DDR5-5600",
"mem_bandwidth_gb_s": 90,
"decode_ceiling_tok_s": 6
},
{
"device": "NVIDIA A10G",
"mem_bandwidth_gb_s": 600,
"decode_ceiling_tok_s": 38
},
{
"device": "NVIDIA L40S",
"mem_bandwidth_gb_s": 864,
"decode_ceiling_tok_s": 54
},
{
"device": "NVIDIA RTX 4090",
"mem_bandwidth_gb_s": 1008,
"decode_ceiling_tok_s": 63
},
{
"device": "NVIDIA A100 80GB SXM",
"mem_bandwidth_gb_s": 2039,
"decode_ceiling_tok_s": 127
},
{
"device": "NVIDIA H100 SXM",
"mem_bandwidth_gb_s": 3350,
"decode_ceiling_tok_s": 209
}
]La colonna della larghezza di banda contiene il valore pubblicato nelle specifiche di ciascun produttore. La colonna del limite superiore contiene quel valore diviso per 16 GB, cioè la dimensione di un modello da 8 miliardi di parametri memorizzato con precisione a 16 bit. Si tratta di un calcolo aritmetico, non del risultato di un benchmark. La velocità misurata sarà inferiore. Sapere di quanto è utile, perché indica se devi intervenire sullo stack di serving o sull'hardware.
Leggi le 6 righe in ordine e il quadro è chiaro. Una CPU con DDR5 a doppio canale raggiunge circa 90 GB/s, limitando il decode a circa 6 token al secondo per quel modello. Una L40S si colloca intorno a 54. Una H100 SXM, con una larghezza di banda pubblicata di 3350 GB/s, si colloca intorno a 209.
È anche per questo che la quantizzazione è il singolo intervento più efficace sulla velocità di decode. Memorizza gli stessi pesi a 8 bit invece che a 16 bit e dimezzi i byte dei pesi letti per token, quindi il limite superiore raddoppia circa. Tuttavia, il limite superiore non coincide con il risultato effettivo. La KV cache viene comunque letta usando la propria dimensione e alcuni formati a 8 bit aggiungono lavoro per token, come la quantizzazione dinamica delle attivazioni per token documentata da vLLM per uno dei suoi schemi FP8. Per questo il guadagno misurato è generalmente inferiore a 2x. L'intervento è efficace per lo stesso motivo per cui aumenta il limite superiore: devi spostare meno dati in memoria.
Come misurare ogni fase sul proprio server?
Ollama restituisce la suddivisione nel corpo della risposta. Richiedi una completion non in streaming e leggi i contatori.
curl -s http://localhost:11434/api/generate -d '{
"model": "llama3.2",
"prompt": "Explain memory bandwidth in two sentences.",
"stream": false
}' | jq '{prompt_eval_count, prompt_eval_duration, eval_count, eval_duration}'Usa un tag del modello che hai effettivamente scaricato; ollama list mostra i modelli disponibili. prompt_eval_count e prompt_eval_duration riguardano il prefill: il numero di token del prompt e il tempo impiegato per elaborarli. eval_count e eval_duration riguardano il decode. Le durate sono espresse in nanosecondi, quindi la velocità di decode è eval_count / eval_duration * 1e9 e quella di prefill è prompt_eval_count / prompt_eval_duration * 1e9. La documentazione dell'API di Ollama specifica che prompt_eval_duration include soltanto i token del prompt non presenti nella cache. Calcola quindi la velocità di prefill usando un prompt che il server non ha appena elaborato. Nella stessa richiesta, la velocità di prefill dovrebbe essere molto più alta di quella di decode. Il resto di questa guida spiega il motivo di questa differenza.
Per un server compatibile con OpenAI, come vLLM, curl può misurare il tempo fino al primo byte.
curl -N -s -o /dev/null \
-w 'pretransfer %{time_pretransfer}s first_byte %{time_starttransfer}s\n' \
http://localhost:8000/v1/completions \
-H 'Content-Type: application/json' \
-d '{"model": "meta-llama/Llama-3.1-8B-Instruct", "prompt": "Explain memory bandwidth.", "max_tokens": 128, "stream": true}'time_starttransfer indica il momento in cui è arrivato il primo byte del corpo della risposta. Con "stream": true ottieni quindi il TTFT più il tempo di configurazione della connessione. Sottrai time_pretransfer per escludere il costo della configurazione. Esegui il test due volte e conserva il secondo risultato, perché la prima richiesta può includere il caricamento a freddo del modello.
vLLM pubblica inoltre la suddivisione come metriche Prometheus su /metrics. Esegui curl -s http://localhost:8000/metrics | grep -E 'time_to_first_token|inter_token_latency' per ottenere gli istogrammi vllm:time_to_first_token_seconds e vllm:inter_token_latency_seconds. Aggiungi vllm:num_requests_running e vllm:num_requests_waiting per la profondità della coda e vllm:kv_cache_usage_perc per la pressione della cache. Questi cinque nomi costituiscono l'intero dashboard.
Sotto carico, vllm bench serve --model <name> --num-prompts 200 --request-rate 4 genera traffico verso il server in esecuzione e restituisce il tempo fino al primo token e la latenza per token di output con i relativi percentili. È il modo più diretto per osservare come le due fasi si contendono le risorse dello stack già in uso. NVIDIA's GenAI-Perf e LLMPerf misurano le stesse grandezze se preferisci uno strumento separato. Prima di ottimizzare qualsiasi parametro, crea una baseline pulita: il metodo descritto in misurare i token al secondo su un LLM locale produce un risultato che resta valido anche dopo un riavvio.
Perché un system prompt lungo ritarda il primo token, ma non la velocità di streaming?
Perché il system prompt richiede lavoro di prefill, come il resto del prompt. Viene elaborato una sola volta, nello stesso passaggio del resto del prompt, prima che compaia il primo token. Dopo questo passaggio esiste soltanto come voci nella KV cache, che la fase di decode legge insieme a tutto il resto. Di conseguenza, senza prefix caching, un system prompt di 3,000 token aumenta il TTFT a ogni singola richiesta, lasciando quasi invariato il numero di token al secondo.
Quasi, non esattamente. Queste voci aggiuntive della KV cache vengono lette di nuovo a ogni passaggio di decode, quindi un prompt molto lungo rallenta leggermente anche il decode. La sezione successiva tratta questo aspetto.
La soluzione consiste nell'evitare di ricalcolare lo stesso prefisso. Un server con prefix caching conserva nella KV cache il prefisso condiviso e lo riutilizza, quindi la seconda richiesta che contiene lo stesso system prompt salta completamente quella parte del prefill. In vLLM questa funzione si chiama automatic prefix caching; controlla vllm serve --help nella tua versione, perché il valore predefinito è cambiato tra le release. Questa KV cache in GPU è diversa dalla prompt cache per la quale un provider API può addebitarti un costo, e vale la pena leggere la differenza tra una KV cache e una prompt cache prima di ottimizzare una delle due.
Perché il decode rallenta quando il contesto si riempie?
Le ragioni sono due e riguardano entrambe la cache KV.
La prima è la larghezza di banda. A ogni passaggio di decode, l’attenzione legge key e value di ogni token precedente. I pesi hanno un costo fisso per token. La cache KV invece cresce. La sua dimensione si può calcolare dalla config.json del modello: i byte per token sono 2 moltiplicato per num_hidden_layers, per num_key_value_heads, per la dimensione della testa e per i byte per elemento. Usa head_dim quando è presente nella configurazione e hidden_size diviso per num_attention_heads solo quando non lo è, perché alcuni modelli impostano i due valori in modo indipendente. Mistral NeMo, per esempio, ha una width di 5,120 e 32 teste, ma una dimensione della testa pari a 128, non 160. Il primo 2 conta una key e un value.
In una configurazione comune da 8 miliardi di parametri, con 32 layer, 8 teste key e value tramite GQA (grouped query attention), dimensione della testa 128 e precisione a 16 bit, il calcolo è 2 x 32 x 8 x 128 x 2 = 131,072 byte, circa 128 KiB per token. Una conversazione di 8,000 token contiene quindi circa 1 GB di cache KV per richiesta.
La seconda è la capacità. Quel GB di memoria non può contenere i pesi né il contesto di un altro utente. Il server dimensiona il pool KV una sola volta, all’avvio, in vLLM tramite --gpu-memory-utilization; quando il pool è pieno, le nuove richieste restano in attesa. L’aumento di vllm:num_requests_waiting mentre vllm:kv_cache_usage_perc resta vicino a 1 è il segnale caratteristico di questa situazione. Alcuni stack sospendono una richiesta in esecuzione e ricalcolano in seguito la relativa cache invece di accodarla. L’utente lo percepisce come un blocco a metà dello stream.
Un contesto lungo ha quindi un costo doppio: richiede più lavoro di prefill all’inizio e più letture dalla memoria per ogni token prodotto nel resto della risposta.
Perché il batching aumenta il throughput e peggiora la latenza di coda?
Poiché il decode è vincolato dalla larghezza di banda, le richieste aggiuntive hanno un costo computazionale ridotto. Una singola lettura dei pesi può produrre un token per ogni sequenza nel batch, quindi il throughput complessivo aumenta quasi linearmente con le dimensioni del batch, finché non si esaurisce il pool KV o il batch non diventa abbastanza grande da essere nuovamente vincolato dal calcolo. Il continuous batching ricrea il batch a ogni step, quindi una richiesta completata esce e una richiesta in coda entra senza attendere le richieste vicine.
Il costo si vede nei percentili. Il token successivo di ogni utente deve ora attendere la parte più lenta di uno step condiviso, quindi p50, la mediana, resta accettabile mentre p99, l'1% di richieste più lente, aumenta. È il valore p99 a essere percepito dagli utenti, perché corrisponde alla pausa nel mezzo di una frase.
Il prefill rende il problema più evidente. Un prompt di grandi dimensioni che arriva durante l'esecuzione occupa il dispositivo per un lungo step, e tutti gli stream attivi subiscono un'interruzione. Il chunked prefill riduce gran parte del problema dividendo un prompt lungo in più parti e inserendo ogni parte nei batch di decode. A ottobre 2026 il motore vLLM V1 lo esegue per impostazione predefinita ed espone il bilanciamento tramite --max-num-batched-tokens. La documentazione di tuning di vLLM descrive chiaramente il compromesso: valori più piccoli, intorno a 2048, offrono una latenza inter token (ITL) migliore perché un numero inferiore di prefill interrompe il decode; valori più grandi offrono un TTFT migliore perché più token di prefill entrano in un singolo batch. Quel flag espone il rapporto tra prefill e decode sotto forma di un numero regolabile. Il punto in cui p99 non è più accettabile dipende dalla capacità, e quanti utenti concorrenti può gestire un LLM self-hosted lo determina usando le stesse metriche.
Perché una GPU più grande a volte non cambia nulla?
Perché, di solito, una GPU più grande offre più capacità di calcolo, mentre il decode non richiede capacità di calcolo.
Confrontate due righe della tabella precedente. L'A100 80GB offre una larghezza di banda dichiarata di 2039 GB/s, contro i 864 GB/s della L40S, e il limite del decode segue esattamente questo rapporto: 127 token al secondo contro 54. La RTX 4090 è una scheda molto veloce sotto la maggior parte degli aspetti e i suoi 1008 GB/s portano il limite a 63. Indipendentemente dalle altre differenze tra due schede, il decode su un singolo stream segue il valore della larghezza di banda riportato nelle specifiche.
Esistono quindi due modi per accelerare il decode: leggere meno byte per token, quantizzando i pesi oppure eseguendo un modello più piccolo, o acquistare una scheda con maggiore larghezza di banda. Il prefill è il caso opposto. Richiede capacità di calcolo, quindi una scheda più veloce riduce effettivamente il TTFT sui prompt lunghi. Se il problema è che il primo token arriva dopo quattro secondi, un hardware migliore può risolverlo. Se il problema è che il testo viene generato lentamente, probabilmente non sarà così.
Eseguire prefill e decode su worker separati?
I grandi sistemi di serving fanno esattamente questo. La tecnica si chiama disaggregazione di prefill e decode. Un pool di worker esegue soltanto il prefill, mentre un secondo pool esegue soltanto il decode. La cache KV costruita dal primo pool viene trasferita al secondo tramite un'interconnessione veloce. Funziona perché le due fasi richiedono hardware e criteri di scheduling diversi. Il prefill richiede capacità di calcolo e batch di token grandi. Il decode richiede larghezza di banda e molte sequenze simultanee. Separare le due fasi consente di scalare ogni pool in modo indipendente e impedisce che un prompt molto grande blocchi tutti gli stream attivi.
Su un singolo VPS (virtual private server) con una sola GPU, quasi mai conviene. Divideresti un unico dispositivo rispetto a se stesso e trasformeresti un puntatore in un trasferimento di gigabyte di cache attraverso la rete. La tecnica diventa vantaggiosa quando hai abbastanza acceleratori per dedicare intere macchine a ciascuna fase e abbastanza traffico costante per mantenere attivi entrambi i pool. Al di sotto di questa soglia, il prefill segmentato offre quasi lo stesso isolamento usando un solo flag.
Cosa modificare quando il numero non è buono
Quando il TTFT è troppo alto:
- Accorcia il prompt. Il costo del prefill segue il numero di token del prompt e, senza il prefix caching, il system prompt viene elaborato a ogni richiesta.
- Attiva il prefix caching, in modo che un prefisso ripetuto venga calcolato una sola volta invece che a ogni richiesta.
- Aumenta
--max-num-batched-tokens, così una quantità maggiore di lavoro di prefill viene eseguita in ogni step. - Controlla la coda prima di attribuire la causa al modello. Un valore di
vllm:num_requests_waitingsuperiore a zero indica che la richiesta non era ancora iniziata: il problema riguarda la capacità.
Quando il numero di token al secondo è troppo basso:
- Quantizza i pesi. Un numero inferiore di byte per peso significa leggere meno byte per token.
- Confronta la larghezza di banda della memoria pubblicata per la tua scheda con il grafico precedente e verifica quanto ti avvicini al limite massimo.
- Riduci
--max-num-batched-tokens, così i prefill interrompono il decode meno frequentemente. - Controlla la lunghezza del contesto. Una conversazione che raggiunge migliaia di token legge una cache KV molto più grande a ogni step.
Anche il runtime è importante, perché Ollama e vLLM pianificano prefill e decode in modo diverso e un'impostazione utile per uno può non produrre alcun effetto sull'altro. Misura prima entrambe le fasi, quindi modifica una sola impostazione alla volta.
FAQ
Perché il primo token richiede alcuni secondi, mentre i successivi vengono trasmessi rapidamente?
L'attesa corrisponde alla fase di prefill, mentre la trasmissione dei token corrisponde alla fase di decode. Il prefill elabora l'intero prompt in un'unica fase, limitata dalla capacità di calcolo, prima che sia disponibile qualsiasi output. Il relativo costo cresce quindi con la lunghezza del prompt. Il decode emette poi un token per fase, a una velocità determinata dalla larghezza di banda della memoria, quasi indipendente dalla lunghezza del prompt. La causa più comune è un system prompt lungo incluso in ogni richiesta. Il prefix caching elimina il costo della parte ripetuta.
Un prompt più lungo riduce i token al secondo?
Riduce leggermente la velocità, ma per un motivo diverso rispetto al TTFT. Ogni fase di decode legge le chiavi e i valori di tutti i token precedenti. Una KV cache più grande comporta quindi più byte da leggere per ogni token. In una configurazione comune con 8 billion di parametri, la cache occupa circa 128 KiB per token. Un contesto di 8,000 token corrisponde quindi a circa 1 GB che viene letto a ogni fase. L'effetto principale di un prompt lungo riguarda comunque il TTFT, non la velocità di trasmissione.
Quale specifica della GPU consente di prevedere la velocità di decode?
La larghezza di banda della memoria. Dividendo la larghezza di banda dichiarata per la dimensione dei pesi in memoria si ottiene il limite teorico per un singolo stream. Una scheda con maggiore capacità di calcolo ma la stessa larghezza di banda non trasmetterà i token più rapidamente. Per lo stesso motivo, quantizzare i pesi a 8 bit raddoppia circa il limite della fase di decode: dimezza i byte dei pesi letti per token. Il guadagno misurato è generalmente inferiore, perché la KV cache continua a essere letta alla propria dimensione e alcuni formati a 8 bit richiedono elaborazioni aggiuntive per token, come la quantizzazione delle attivazioni.
Perché il throughput aumenta quando aggiungo utenti, mentre ogni utente percepisce una maggiore lentezza?
Una singola lettura dei pesi serve un token per ogni sequenza nel batch. Di conseguenza, il numero totale di token al secondo aumenta con la dimensione del batch. Ogni singolo token deve però attendere una fase condivisa, quindi la latenza per utente aumenta nello stesso momento. Monitorare la latenza inter-token p99, non il valore di throughput aggregato, e controllare vllm:num_requests_waiting per verificare se le richieste sono in coda invece di essere in esecuzione.