Prefill vs Decode: por que a latência de LLM varia
Entenda a diferenca entre prefill limitado por computacao e decode limitado por banda de memoria. Aprenda a medir cada fase para otimizar o tempo de resposta do seu LLM.
Prefill versus decode, num parágrafo
A distinção entre prefill e decode explica a maioria das questões de latência num LLM (large language model) alojado localmente. O prefill lê todo o prompt numa única passagem e é limitado pela capacidade de computação. O decode escreve a resposta um token de cada vez e é limitado pela largura de banda da memória. O tempo até ao primeiro token é uma métrica do prefill. O número de tokens por segundo é uma métrica do decode.
Ambas as fases executam na mesma GPU (graphics processing unit), com os mesmos pesos e dentro do mesmo processo, pelo que é natural tratá-las como uma única carga de trabalho. Na prática, comportam-se como dois programas diferentes que partilham o mesmo dispositivo. Quando as separa, deixa de ser confusa uma longa lista de resultados aparentemente contraditórios.
Por que o prefill é limitado pelo processamento?
O prefill processa todo o prompt uma vez em cada camada. Um prompt com 2,000 tokens fornece 2,000 linhas de trabalho a cada multiplicação de matrizes. Assim, a GPU executa muitos cálculos para cada byte de pesos que carrega. Essa relação, que corresponde à quantidade de operações aritméticas por byte transferido, chama-se intensidade aritmética. O prefill tem intensidade aritmética elevada. O dispositivo funciona próximo do limite de processamento, enquanto o barramento de memória ainda tem capacidade disponível.
O prefill produz duas coisas: a cache KV (os tensores de chave e valor) para cada token do prompt e o primeiro token de saída. Nada chega ao leitor até essa passagem terminar. Por isso, num servidor sem carga, o prefill representa a maior parte do tempo até ao primeiro token (TTFT). A definição de TTFT no guia de benchmarking da NVIDIA também inclui o tempo de espera na fila e a latência de rede. Assim, num servidor ocupado, a espera na fila pode ser tão relevante como o prompt.
O custo do prefill aumenta com o comprimento do prompt. A parte linear corresponde ao trabalho de multiplicação de matrizes em cada camada. A parte quadrática corresponde à atenção, em que cada token presta atenção a todos os tokens anteriores. Essa parte começa a ser relevante com contextos longos. Por isso, duplicar o prompt duplica, no mínimo, a parte do TTFT correspondente ao prefill.
Pode observar isto num minuto. Envie ao servidor um prompt com 200 tokens e, depois, um prompt com 2,000 tokens. Peça o mesmo número de tokens de saída em ambos os casos. O TTFT aumenta acentuadamente. A velocidade de transmissão depois do primeiro token quase não se altera.
Por que o decode é limitado pela largura de banda da memória?
O decode produz um token por passo. Para produzir esse único token, a GPU tem de ler todos os pesos do modelo a partir da memória, usar cada peso em algumas operações e descartá-lo. A intensidade aritmética é próxima de 1, por isso as unidades de computação passam a maior parte do tempo à espera.
O decode é lento porque cada token exige ler todo o modelo a partir da memória. Por isso, o barramento de memória dita o ritmo e as unidades de computação ficam inativas.
Isso permite calcular no papel o limite superior da velocidade de decode de um único fluxo. Divida a largura de banda da memória pelo número de bytes ocupados pelos pesos.
Os dados por trás deste gráfico
[
{
"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
}
]A coluna de largura de banda contém o valor publicado nas especificações de cada fornecedor. A coluna de limite superior contém esse valor dividido por 16 GB, o tamanho de um modelo com 8 mil milhões de parâmetros armazenado com precisão de 16 bits. É um cálculo aritmético, não um resultado de benchmark. A taxa medida ficará abaixo desse valor. Saber quanto abaixo é útil, porque indica se deve corrigir a sua stack de serving ou o hardware.
Leia as 6 linhas pela ordem apresentada e o padrão fica claro. Uma CPU com DDR5 de dois canais move cerca de 90 GB/s, o que limita o decode a cerca de 6 tokens por segundo para esse modelo. Uma L40S chega perto de 54. Uma H100 SXM, com largura de banda publicada de 3350 GB/s, fica perto de 209.
É também por isso que a quantização é a alavanca individual mais forte para aumentar a velocidade de decode. Armazene os mesmos pesos a 8 bits em vez de 16 e reduzirá para metade os bytes de pesos lidos por token, fazendo aproximadamente duplicar o limite superior. No entanto, o limite superior não é o resultado medido. A KV cache continua a ser lida com o seu próprio tamanho, e alguns formatos de 8 bits acrescentam trabalho por token, como a quantização dinâmica das ativações por token documentada pelo vLLM para um dos seus esquemas FP8. Por isso, o ganho medido costuma ficar abaixo de 2x. A alavanca funciona pela mesma razão que o limite superior aumenta: são lidos menos dados da memória.
Como medir cada fase no meu próprio servidor?
Ollama devolve a divisão no corpo da resposta. Peça uma conclusão sem streaming e leia os contadores.
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}'Use uma tag de modelo que tenha efetivamente obtido, como ollama list lhe mostrará. prompt_eval_count e prompt_eval_duration correspondem ao prefill: a contagem de tokens do prompt e o tempo gasto nessa etapa. eval_count e eval_duration correspondem ao decode. As durações estão em nanossegundos, por isso a velocidade de decode é eval_count / eval_duration * 1e9 e a velocidade de prefill é prompt_eval_count / prompt_eval_duration * 1e9. A referência da API do Ollama indica que prompt_eval_duration abrange apenas tokens do prompt que não estavam em cache. Por isso, calcule a velocidade de prefill com um prompt que o servidor não tenha processado há pouco. Na mesma solicitação, espere que a velocidade de prefill seja muito superior à velocidade de decode. O restante deste conteúdo explica essa diferença.
Num servidor compatível com OpenAI, como o vLLM, o curl pode medir o tempo até ao primeiro 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 é o momento em que chegou o primeiro byte do corpo. Com "stream": true, corresponde ao TTFT mais a configuração da ligação. Subtraia time_pretransfer para remover o custo da configuração. Execute duas vezes e mantenha o segundo resultado, porque a primeira chamada pode incluir o carregamento a frio do modelo.
O vLLM também publica essa divisão como métricas Prometheus em /metrics. Execute curl -s http://localhost:8000/metrics | grep -E 'time_to_first_token|inter_token_latency' para obter os histogramas vllm:time_to_first_token_seconds e vllm:inter_token_latency_seconds. Acrescente vllm:num_requests_running e vllm:num_requests_waiting para a profundidade da fila e vllm:kv_cache_usage_perc para a pressão da cache. Esses cinco nomes formam todo o dashboard.
Sob carga, vllm bench serve --model <name> --num-prompts 200 --request-rate 4 conduz o servidor em execução e apresenta o tempo até ao primeiro token e a latência por token de saída com percentis. É a forma mais direta de ver as duas fases competirem na stack que já executa. NVIDIA's GenAI-Perf e LLMPerf medem as mesmas quantidades se preferir uma ferramenta separada. Antes de otimizar qualquer coisa, obtenha uma baseline limpa: o método em medir tokens por segundo num LLM local fornece uma baseline que permanece válida depois de um reboot.
Por que um system prompt longo atrasa o primeiro token, mas não a velocidade de streaming?
Porque o system prompt é trabalho de prefill, e nada mais. Ele é processado uma vez, na mesma passagem que o restante do prompt, antes de o primeiro token aparecer. Depois dessa passagem, ele existe apenas como entradas da KV cache, e o decode lê essas entradas juntamente com todo o resto. Portanto, sem caching de prefixo, um system prompt de 3,000 tokens aumenta o TTFT em todas as requisições, mas mantém os tokens por segundo praticamente inalterados.
Praticamente, não exatamente. Essas entradas adicionais da KV cache são lidas novamente em cada etapa de decode, por isso um prompt muito longo reduz um pouco a velocidade do decode. A próxima seção explica esse efeito.
A correção é deixar de recalcular o mesmo prefixo. Um servidor com caching de prefixo mantém a KV cache de um prefixo partilhado e reutiliza-a. Assim, a segunda requisição que contém o mesmo system prompt ignora completamente essa parte do prefill. O vLLM chama a funcionalidade de automatic prefix caching. Consulte vllm serve --help na sua versão, porque o valor predefinido mudou entre releases. Essa KV cache na GPU é diferente da prompt cache pela qual um fornecedor de API cobra. Vale a pena ler a diferença entre uma KV cache e uma prompt cache antes de configurar qualquer uma das duas.
Por que a decodificação fica mais lenta à medida que o contexto cresce?
Há dois motivos, ambos relacionados com a cache KV.
O primeiro é a largura de banda. A cada etapa de decodificação, o mecanismo de atenção lê as chaves e os valores de todos os tokens anteriores. Os pesos têm um custo fixo por token. A cache KV cresce. Pode calcular o respetivo tamanho a partir de config.json do modelo: os bytes por token equivalem a 2 multiplicado por num_hidden_layers, por num_key_value_heads, pela dimensão da cabeça e pelos bytes por elemento. Use head_dim quando a configuração o listar, e hidden_size dividido por num_attention_heads apenas quando não o listar, porque alguns modelos definem estes dois valores de forma independente. O Mistral NeMo, por exemplo, tem uma largura de 5,120 e 32 cabeças, mas a dimensão da cabeça é 128, não 160. O 2 inicial representa uma chave e um valor.
Num layout comum de 8 mil milhões de parâmetros, com 32 camadas, 8 cabeças de chave e valor em GQA (grouped query attention), dimensão da cabeça 128 e precisão de 16 bits, o cálculo é 2 x 32 x 8 x 128 x 2 = 131,072 bytes, ou aproximadamente 128 KiB por token. Uma conversa com 8,000 tokens contém, portanto, cerca de 1 GB de cache KV por pedido.
O segundo motivo é a capacidade. Esse 1 GB é memória que não pode armazenar pesos nem o contexto de outro utilizador. O servidor dimensiona o pool KV uma vez, no arranque, através de --gpu-memory-utilization no vLLM. Quando o pool fica cheio, os novos pedidos aguardam. O aumento de vllm:num_requests_waiting enquanto vllm:kv_cache_usage_perc permanece próximo de 1 é a assinatura exata desse estado. Algumas stacks preemptam um pedido em execução e recalculam a respetiva cache mais tarde, em vez de o colocar em fila. Para o utilizador, isto aparece como uma pausa a meio do fluxo.
Um contexto longo tem dois custos: mais trabalho de prefill no início e mais memória lida por token durante o restante da resposta.
Por que o batching aumenta o throughput e prejudica a latência de cauda?
Como o decode é limitado pela largura de banda, os pedidos adicionais têm um custo quase nulo no lado computacional. Uma leitura dos pesos pode produzir um token para cada sequência do batch, por isso o throughput total aumenta quase linearmente com o tamanho do batch, até o pool de KV esgotar ou o batch crescer o suficiente para voltar a ficar limitado pelo processamento. O batching contínuo reconstrói o batch a cada passo. Assim, um pedido concluído sai e outro pedido em fila entra sem esperar pelos restantes pedidos.
O custo aparece nos percentis. O próximo token de cada utilizador passa a esperar pela parte mais lenta de um passo partilhado. Assim, p50, a mediana, mantém-se aceitável, enquanto p99, o 1 pedido mais lento em 100, aumenta. É o p99 que as pessoas notam, porque corresponde à pausa no meio de uma frase.
O prefill torna este efeito mais acentuado. Quando um prompt grande chega durante o streaming, ocupa o dispositivo durante um passo longo, e todos os pedidos que estão a fazer streaming veem uma interrupção. O chunked prefill reduz a maior parte desse efeito ao dividir um prompt longo em partes e misturar cada parte nos batches de decode. Em outubro de 2026, o motor vLLM V1 faz isto por predefinição e expõe este equilíbrio através de --max-num-batched-tokens. A documentação de afinação do vLLM explica claramente o compromisso: valores menores, à volta de 2048, proporcionam uma melhor latência entre tokens (ITL), porque menos operações de prefill interrompem os decodes; valores maiores proporcionam um melhor TTFT, porque cabem mais tokens de prefill num único batch. Essa flag expõe o equilíbrio entre prefill e decode como um número que pode ajustar. O ponto em que o p99 deixa de ser aceitável é uma questão de capacidade, e quantos utilizadores concorrentes um LLM autoalojado consegue servir analisa essa questão com as mesmas métricas.
Por que uma GPU maior às vezes não muda nada?
Porque maior normalmente significa mais capacidade de computação, e o decode não precisa de mais computação.
Compare duas linhas do gráfico acima. A A100 80GB tem uma largura de banda publicada de 2039 GB/s, contra 864 GB/s da L40S, e o limite de decode acompanha exatamente esses valores: 127 tokens por segundo contra 54. A RTX 4090 é uma placa muito rápida na maioria dos critérios, e os seus 1008 GB/s colocam o seu limite em 63. Independentemente das outras diferenças entre duas placas, o decode de um único fluxo acompanha a largura de banda indicada na ficha técnica.
Por isso, há duas formas de tornar o decode mais rápido: ler menos bytes por token, quantizando os pesos ou executando um modelo menor, ou comprar mais largura de banda. O prefill é o caso oposto. Precisa de capacidade de computação, por isso uma placa mais rápida reduz efetivamente o TTFT em prompts longos. Se o problema é o primeiro token demorar quatro segundos, hardware melhor pode resolver a situação. Se o problema é o texto aparecer lentamente, provavelmente não resolverá.
Deve executar o prefill e o decode em workers separados?
As grandes plataformas de serving fazem exatamente isto, e a técnica chama-se desagregação de prefill e decode. Um pool de workers executa apenas o prefill, um segundo pool executa apenas o decode, e a KV cache criada pelo primeiro é transferida para o segundo através de uma interligação rápida. Isto funciona porque as fases exigem hardware e escalonamento diferentes. O prefill exige capacidade de computação e lotes grandes de tokens. O decode exige largura de banda e muitas sequências concorrentes. Separá-los permite que cada pool escale de forma independente e impede que um prompt muito grande bloqueie todos os streams ativos.
Num único VPS (virtual private server) com uma GPU, quase nunca compensa. Estaria a dividir um único dispositivo contra si próprio e transformaria um ponteiro numa transferência de rede de gigabytes de cache. A técnica compensa quando existem aceleradores suficientes para dedicar máquinas inteiras a cada fase e tráfego constante suficiente para manter ambos os pools ocupados. Abaixo desse nível, o prefill em blocos oferece praticamente o mesmo isolamento com uma única flag.
O que alterar quando o número é mau
Quando o TTFT é demasiado elevado:
- Encurte o prompt. O custo do prefill acompanha o número de tokens do prompt e, sem caching de prefixos, o system prompt é processado em cada pedido.
- Ative o caching de prefixos para que um prefixo repetido seja calculado uma vez, em vez de ser calculado sempre.
- Aumente
--max-num-batched-tokenspara que mais trabalho de prefill seja executado em cada passo. - Verifique a fila antes de culpar o modelo.
vllm:num_requests_waitingacima de zero significa que o pedido ainda não tinha começado, o que indica um problema de capacidade.
Quando os tokens por segundo são demasiado baixos:
- Quantize os pesos. Menos bytes por peso significam menos bytes lidos por token.
- Compare a largura de banda de memória publicada para a sua placa com o gráfico acima e verifique quão perto está do limite.
- Diminua
--max-num-batched-tokenspara que os prefills interrompam o decode com menos frequência. - Verifique o comprimento do contexto. Uma conversa que cresceu para milhares de tokens lê uma cache KV muito maior em cada passo.
O runtime também é importante, porque Ollama e vLLM agendam o prefill e o decode de forma diferente, e uma definição que ajuda num deles pode não ter qualquer efeito no outro. Meça primeiro, nas duas fases, e depois altere uma coisa de cada vez.
FAQ
Por que o primeiro token demora segundos, mas os restantes são transmitidos rapidamente?
A espera corresponde ao prefill e a transmissão corresponde ao decode. O prefill processa todo o prompt numa única passagem limitada pela capacidade de processamento, antes de existir qualquer saída. Por isso, o custo aumenta com o comprimento do prompt. O decode emite um token por passo, a uma velocidade definida pela largura de banda da memória, que é quase independente do comprimento do prompt. Um system prompt longo em todos os pedidos é a causa habitual. O prefix caching elimina a repetição dessa parte do custo.
Um prompt mais longo reduz os tokens por segundo?
Reduz um pouco, mas por uma razão diferente da TTFT. Cada passo de decode lê as keys e values de todos os tokens anteriores. Por isso, uma KV cache maior implica ler mais bytes por token. Numa configuração comum com 8 billion parameters, a cache ocupa cerca de 128 KiB por token. Assim, um contexto de 8,000 tokens corresponde a aproximadamente 1 GB lido em cada passo. O efeito mais significativo de um prompt longo continua a verificar-se na TTFT, não na velocidade de transmissão.
Qual é a especificação da GPU que prevê a velocidade de decode?
A largura de banda da memória. Divida a largura de banda publicada pelo tamanho dos weights na memória para obter o limite teórico de uma stream. Uma placa com mais capacidade de processamento, mas com a mesma largura de banda, não fará a transmissão mais rapidamente. É também por isso que quantizar os weights para 8 bits aproximadamente duplica o limite de decode: reduz para metade os bytes dos weights lidos por token. O ganho medido é normalmente inferior, porque a KV cache continua a ser lida com o seu próprio tamanho e alguns formatos de 8 bits acrescentam processamento por token, como a quantização das activations.
Por que o throughput aumenta quando adiciono utilizadores, mas cada utilizador sente um aumento da latência?
Uma leitura dos weights serve um token para cada sequência do batch. Por isso, o total de tokens por segundo aumenta com o tamanho do batch. Cada token individual passa a esperar por um passo partilhado, pelo que a latência por utilizador aumenta ao mesmo tempo. Monitorize a latência inter token p99, não o valor agregado de throughput, e verifique vllm:num_requests_waiting para confirmar se os pedidos estão em fila em vez de estarem a ser processados.