SSD Nodes Learn Hosting plans →
Guides Matt ConnorPar Matt Connor · Mis à jour le 2026-10-18

Pourquoi le premier token est lent : prefill ou decode ?

Le prefill, limité par le calcul, détermine le time to first token. Le decode, limité par la mémoire, détermine les tokens/s. Mesurez-les séparément.

Prefill et decode, en un paragraphe

La distinction entre prefill et decode explique la plupart des questions de latence concernant un LLM (large language model) auto-hébergé. Le prefill lit l’intégralité du prompt en un seul passage et dépend des capacités de calcul. Le decode génère la réponse un token à la fois et dépend de la bande passante mémoire. Le time to first token est une mesure du prefill. Le nombre de tokens par seconde est une mesure du decode.

Les deux phases s’exécutent sur le même GPU (graphics processing unit), avec les mêmes poids, au sein du même processus. Il est donc naturel de les considérer comme une seule charge de travail. En pratique, elles se comportent comme deux programmes différents qui partagent le même périphérique. Si vous les séparez, une longue liste de résultats difficiles à interpréter devient beaucoup plus claire.

Pourquoi le prefill est-il limité par le calcul ?

Le prefill fait passer l’intégralité du prompt dans chaque couche, une seule fois. Un prompt de 2,000 tokens fournit 2,000 lignes de calcul à chaque multiplication matricielle. Le GPU effectue donc beaucoup de calculs pour chaque octet de poids chargé. Ce ratio, qui correspond au nombre d’opérations effectuées par octet transféré, s’appelle l’intensité arithmétique. Elle est élevée pendant le prefill. Le GPU fonctionne alors près de sa limite de calcul, tandis que le bus mémoire dispose encore de marge.

Le prefill produit deux éléments : le KV cache (les tenseurs key et value) pour chaque token du prompt, ainsi que le premier token généré. Rien n’est transmis au lecteur avant la fin de cette passe. C’est pourquoi, sur un serveur inactif, le prefill représente généralement l’essentiel du time to first token (TTFT). Selon la définition du guide de benchmarking de NVIDIA, le TTFT inclut aussi la mise en file d’attente de la requête et la latence réseau. Sur un serveur très sollicité, l’attente dans la file peut donc compter autant que la longueur du prompt.

Le coût du prefill augmente avec la longueur du prompt. La partie linéaire correspond aux calculs matriciels effectués dans chaque couche. La partie quadratique correspond à l’attention : chaque token porte son attention sur tous les tokens précédents. Cette partie devient importante avec un long contexte. Ainsi, doubler la longueur du prompt double au moins la contribution du prefill au TTFT.

Vous pouvez l’observer en une minute. Envoyez à votre serveur un prompt de 200 tokens, puis un prompt de 2,000 tokens, en demandant à chaque fois le même nombre de tokens générés. Le TTFT augmente fortement. La vitesse de streaming après le premier token change à peine.

Pourquoi la phase de décodage est-elle limitée par la bande passante mémoire ?

Le décodage produit un token par étape. Pour produire ce token unique, le GPU doit lire chaque poids du modèle depuis la mémoire, utiliser chaque poids pour quelques opérations, puis le rejeter. L'intensité arithmétique est proche de 1, donc les unités de calcul passent la majeure partie de leur temps à attendre.

Le décodage est lent car chaque token nécessite la lecture de l'intégralité du modèle depuis la mémoire ; le bus mémoire impose donc le rythme et les unités de calcul restent inactives.

Cela fait du plafond de vitesse de décodage en flux unique un calcul arithmétique réalisable sur papier. Divisez la bande passante mémoire par le nombre d'octets occupés par les poids.

GraphiquePublished memory bandwidth and the decode ceiling it implies for a 16 GB model
Les données de ce graphique
[
  {
    "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 colonne de bande passante contient la valeur publiée par chaque fabricant. La colonne du plafond correspond à cette valeur divisée par 16 Go, la taille d'un modèle de 8 milliards de paramètres stocké en précision 16 bits. Il s'agit d'un calcul, pas d'un résultat de benchmark. Votre débit mesuré sera inférieur à cette valeur, et savoir dans quelle mesure est utile, car cela vous indique s'il faut corriger votre pile de service ou votre matériel.

Lisez les 6 lignes dans l'ordre et le modèle est clair. Un CPU sur de la DDR5 double canal déplace environ 90 Go/s, ce qui limite le décodage à environ 6 tokens par seconde pour ce modèle. Une L40S se situe près de 54. Une H100 SXM, avec une bande passante publiée de 3350 Go/s, se situe près de 209.

C'est aussi pourquoi la quantification est le levier le plus puissant sur la vitesse de décodage. Stockez les mêmes poids en 8 bits au lieu de 16 et vous divisez par deux le nombre d'octets de poids lus par token, donc le plafond double approximativement. Le plafond n'est cependant pas le résultat final. Le cache KV est toujours lu selon sa propre taille, et certains formats 8 bits ajoutent du travail par token, comme la quantification dynamique d'activation par token que vLLM documente pour l'un de ses schémas FP8, donc le gain mesuré est généralement inférieur à 2x. Le levier fonctionne pour la même raison que le plafond se déplace : vous avez déplacé moins de données en mémoire.

Comment mesurer chaque phase sur votre propre serveur ?

Ollama renvoie cette séparation dans le corps de la réponse. Demandez une complétion sans streaming et lisez les compteurs.

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

Utilisez un tag de modèle que vous avez réellement téléchargé, ce que ollama list vous indiquera. prompt_eval_count et prompt_eval_duration correspondent au prefill : le nombre de tokens du prompt et le temps qui lui est consacré. eval_count et eval_duration correspondent au decode. Les durées sont exprimées en nanosecondes. La vitesse de decode est donc eval_count / eval_duration * 1e9 et la vitesse de prefill prompt_eval_count / prompt_eval_duration * 1e9. La documentation de référence de l’API Ollama indique que prompt_eval_duration ne couvre que les tokens du prompt qui ne sont pas en cache. Mesurez donc la vitesse de prefill avec un prompt que le serveur n’a pas utilisé récemment. Sur une même requête, la vitesse de prefill devrait être nettement supérieure à la vitesse de decode. Tout le reste de ce guide explique cet écart.

Pour un serveur compatible avec OpenAI, comme vLLM, curl peut mesurer le délai avant le premier octet.

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 correspond au moment où le premier octet du corps est arrivé. Avec "stream": true, cela donne le TTFT plus l’établissement de la connexion. Soustrayez time_pretransfer pour exclure le coût de l’établissement de la connexion. Exécutez la commande deux fois et conservez le deuxième résultat, car le premier appel peut inclure le chargement initial du modèle.

vLLM publie également cette séparation sous forme de métriques Prometheus sur /metrics. Exécutez curl -s http://localhost:8000/metrics | grep -E 'time_to_first_token|inter_token_latency' pour obtenir les histogrammes vllm:time_to_first_token_seconds et vllm:inter_token_latency_seconds. Ajoutez vllm:num_requests_running et vllm:num_requests_waiting pour la profondeur de la file d’attente, ainsi que vllm:kv_cache_usage_perc pour la pression sur le cache. Ces cinq noms suffisent pour constituer le dashboard.

Sous charge, vllm bench serve --model <name> --num-prompts 200 --request-rate 4 pilote le serveur en fonctionnement et indique le délai avant le premier token ainsi que la latence par token de sortie avec des percentiles. C’est la méthode la plus directe pour observer l’interaction entre les deux phases sur la stack que vous utilisez déjà. NVIDIA GenAI-Perf et LLMPerf mesurent les mêmes valeurs si vous préférez utiliser un outil distinct. Avant toute optimisation, établissez une baseline propre : la méthode décrite dans mesurer les tokens par seconde sur un LLM local vous en fournit une qui reste valable après un redémarrage.

Pourquoi un long prompt système retarde-t-il le premier token, mais pas la vitesse de streaming ?

Parce que le prompt système correspond au travail de prefill, et rien de plus. Il est traité une seule fois, lors du même passage que le reste du prompt, avant l’apparition du premier token. Après ce passage, il n’existe plus que sous forme d’entrées dans le KV cache, que le décodage lit avec le reste. Sans prefix caching, un prompt système de 3,000 tokens augmente donc le TTFT à chaque requête, tout en laissant le nombre de tokens par seconde presque inchangé.

Presque, mais pas exactement. Ces entrées supplémentaires du KV cache sont relues à chaque étape du décodage. Un prompt très long ralentit donc légèrement le décodage. La section suivante explique ce point.

La solution consiste à ne plus recalculer le même préfixe. Un serveur qui utilise le prefix caching conserve le KV cache d’un préfixe partagé et le réutilise. La deuxième requête contenant le même prompt système ignore ainsi entièrement cette partie du prefill. vLLM appelle cela l’automatic prefix caching ; vérifiez vllm serve --help pour votre version, car la valeur par défaut a changé au fil des releases. Ce KV cache conservé dans le GPU est différent du prompt cache facturé par un fournisseur d’API. La différence entre un KV cache et un prompt cache mérite d’être lue avant de régler l’un ou l’autre.

Pourquoi le décodage ralentit-il à mesure que le contexte se remplit ?

Deux raisons, toutes deux liées au cache KV.

La première est la bande passante. À chaque étape de décodage, l'attention lit les clés et les valeurs de chaque token précédent. Les poids représentent un coût fixe par token. Le cache KV est un coût croissant. Vous pouvez calculer sa taille à partir de la config.json du modèle : le nombre d'octets par token est égal à 2 multiplié par num_hidden_layers, par num_key_value_heads, par la dimension de tête, par le nombre d'octets par élément. Utilisez head_dim lorsque la configuration l'indique, et hidden_size divisé par num_attention_heads uniquement lorsqu'elle ne le fait pas, car certains modèles définissent les deux indépendamment. Mistral NeMo, par exemple, a une largeur de 5 120 et 32 têtes mais une dimension de tête de 128, et non 160. Le 2 initial compte une clé et une valeur.

Pour une architecture courante de 8 milliards de paramètres, 32 couches, 8 têtes de clé et de valeur sous GQA (grouped query attention), une dimension de tête de 128, en précision 16 bits, cela donne 2 x 32 x 8 x 128 x 2 = 131 072 octets, soit environ 128 KiB par token. Une conversation de 8 000 tokens transporte donc environ 1 Go de cache KV, par requête.

La seconde est la capacité. Ce Go de mémoire ne peut pas contenir de poids ou le contexte d'un autre utilisateur. Le serveur dimensionne son pool KV une fois au démarrage, sur vLLM via --gpu-memory-utilization, et lorsque le pool est plein, les nouvelles requêtes attendent. Une vllm:num_requests_waiting qui grimpe alors que vllm:kv_cache_usage_perc reste proche de 1 est la signature exacte de cet état. Certaines piles préemptent une requête en cours et recalculent son cache plus tard au lieu de la mettre en file d'attente, ce que l'utilisateur perçoit comme une interruption au milieu d'un flux.

Un contexte long entraîne deux coûts : davantage de travail de prefill au début, et davantage de mémoire à lire par token pour le reste de la réponse.

Pourquoi le batching améliore-t-il le débit tout en dégradant la latence de fin de distribution ?

Comme le décodage est limité par la bande passante, les requêtes supplémentaires coûtent presque rien du côté du calcul. Une seule lecture des poids peut produire un token pour chaque séquence du batch. Le débit total augmente donc presque linéairement avec la taille du batch, jusqu’à ce que le pool KV soit épuisé ou que le batch devienne de nouveau limité par le calcul. Le batching continu reconstruit le batch à chaque étape. Une requête terminée sort et une requête en attente entre sans attendre les autres séquences.

Le coût apparaît dans les percentiles. Le token suivant de chaque utilisateur attend désormais la partie la plus lente d’une étape partagée. La p50, c’est-à-dire la médiane, reste acceptable, tandis que la p99, qui correspond à la requête la plus lente sur 100, augmente. C’est la p99 que les utilisateurs remarquent, car elle correspond à la pause au milieu d’une phrase.

Le prefill accentue ce phénomène. Lorsqu’un prompt volumineux arrive pendant le flux, il occupe le GPU pendant une longue étape. Toutes les séquences en cours de génération subissent alors une interruption. Le prefill par morceaux réduit fortement ce problème en découpant le prompt volumineux et en mélangeant chaque morceau aux batches de décodage. En octobre 2026, le moteur vLLM V1 applique ce comportement par défaut et expose cet équilibre via --max-num-batched-tokens. La documentation de réglage de vLLM indique clairement ce compromis : des valeurs plus faibles, autour de 2048, réduisent la latence inter-token (ITL), car moins de prefills interrompent les décodages ; des valeurs plus élevées améliorent le TTFT, car davantage de tokens de prefill tiennent dans un même batch. Ce flag unique règle le compromis entre prefill et décodage sous la forme d’une valeur numérique. Le seuil à partir duquel la p99 n’est plus acceptable dépend de la capacité. La page combien d’utilisateurs simultanés un LLM auto-hébergé peut servir l’analyse avec les mêmes métriques.

Pourquoi un GPU plus puissant ne change-t-il parfois rien ?

Parce que « plus puissant » signifie généralement plus de capacité de calcul, alors que le décodage n’est pas limité par le calcul.

Comparez deux lignes du tableau ci-dessus. L’A100 80GB offre une bande passante publiée de 2039 GB/s, contre 864 GB/s pour la L40S. Le plafond de décodage suit exactement cette différence : 127 tokens par seconde contre 54. La RTX 4090 est une carte très rapide selon la plupart des critères, mais ses 1008 GB/s limitent son plafond à 63. Quelles que soient les autres différences entre deux cartes, le décodage d’un flux unique suit la bande passante indiquée dans la fiche technique.

Il existe donc deux façons d’accélérer le décodage : lire moins d’octets par token, en quantifiant les poids ou en utilisant un modèle plus petit, ou acheter davantage de bande passante. Le prefill est le cas inverse. Il dépend de la capacité de calcul. Une carte plus rapide réduit donc réellement le TTFT avec les prompts longs. Si le problème est que le premier token met quatre secondes à apparaître, un meilleur matériel peut le résoudre. Si le problème est que le texte s’affiche lentement, ce ne sera probablement pas le cas.

Faut-il exécuter le prefill et le decode sur des workers distincts ?

Les grandes stacks de serving font exactement cela. Cette technique s’appelle la désagrégation du prefill et du decode. Un pool de workers exécute uniquement le prefill. Un second pool exécute uniquement le decode. Le KV cache construit par le premier est transféré au second via une interconnexion rapide. Cela fonctionne parce que ces phases nécessitent du matériel et une planification différents. Le prefill nécessite de la puissance de calcul et de gros lots de tokens. Le decode nécessite de la bande passante et de nombreuses séquences concurrentes. Leur séparation permet à chaque pool d’évoluer indépendamment. Elle évite aussi qu’un prompt très volumineux ne bloque tous les flux actifs.

Sur un seul VPS (virtual private server) équipé d’un seul GPU, cela ne vaut presque jamais le coût. Vous répartiriez un même périphérique contre lui-même et transformeriez un pointeur en transfert réseau de plusieurs gigaoctets de cache. Cette technique devient utile lorsque vous disposez de suffisamment d’accélérateurs pour consacrer des machines entières à chaque phase, et d’un trafic suffisamment régulier pour maintenir les deux pools actifs. En dessous de ce seuil, le prefill par blocs offre presque la même isolation avec un seul flag.

Que modifier lorsque le chiffre est mauvais

Lorsque le TTFT est trop élevé :

  • Raccourcissez le prompt. Le coût du prefill suit le nombre de tokens du prompt. Sans prefix caching, le system prompt est facturé à chaque requête.
  • Activez le prefix caching afin qu’un préfixe répété soit calculé une seule fois au lieu de l’être à chaque requête.
  • Augmentez --max-num-batched-tokens afin qu’une plus grande quantité de travail de prefill soit effectuée à chaque étape.
  • Vérifiez la file d’attente avant d’incriminer le modèle. Une valeur de vllm:num_requests_waiting supérieure à zéro signifie que la requête n’avait pas encore démarré. Le problème vient alors de la capacité.

Lorsque le nombre de tokens par seconde est trop faible :

  • Quantifiez les poids. Moins d’octets par poids signifie moins d’octets lus pour chaque token.
  • Comparez la bande passante mémoire publiée de votre carte avec le graphique ci-dessus et vérifiez votre distance par rapport au plafond.
  • Diminuez --max-num-batched-tokens afin que les prefills interrompent moins souvent le decode.
  • Vérifiez la longueur du contexte. Une conversation qui atteint plusieurs milliers de tokens lit un KV cache beaucoup plus volumineux à chaque étape.

Le runtime joue également un rôle, car Ollama et vLLM planifient différemment le prefill et le decode, et un réglage utile pour l’un peut ne rien changer pour l’autre. Mesurez d’abord les deux phases, puis ne modifiez qu’un seul paramètre à la fois.

FAQ

Pourquoi mon premier token prend-il plusieurs secondes alors que le reste est généré rapidement ?

L’attente correspond au prefill, tandis que la génération en streaming correspond au decode. Le prefill traite l’intégralité du prompt en une seule passe limitée par le calcul, avant qu’une sortie ne soit disponible. Son coût augmente donc avec la longueur du prompt. Le decode émet ensuite un token par étape, à un débit déterminé par la bande passante mémoire, qui dépend presque pas de la longueur du prompt. La cause habituelle est un long system prompt envoyé à chaque requête. Le prefix caching supprime le coût de la partie répétée.

Un prompt plus long réduit-il le nombre de tokens par seconde ?

Un peu, mais pour une raison différente du TTFT. À chaque étape de decode, le système lit les keys et values de tous les tokens précédents. Un KV cache plus volumineux implique donc davantage d’octets lus par token. Avec une configuration courante de 8 milliards de paramètres, le cache représente environ 128 KiB par token. Un contexte de 8,000 tokens correspond donc à environ 1 GB relu à chaque étape. L’effet principal d’un long prompt concerne toutefois le TTFT, et non la vitesse de streaming.

Quelle caractéristique du GPU permet de prévoir la vitesse de decode ?

La bande passante mémoire. Divisez la bande passante publiée par la taille des weights en mémoire pour obtenir la limite théorique d’un flux. Une carte disposant de davantage de puissance de calcul, mais de la même bande passante, ne générera pas les tokens plus rapidement. C’est aussi pourquoi quantifier les weights sur 8 bits double approximativement la limite de decode : le nombre d’octets lus par token est divisé par deux. Le gain mesuré est généralement inférieur, car le KV cache est toujours lu selon sa propre taille et certains formats 8 bits ajoutent du travail à chaque token, par exemple la quantification des activations.

Pourquoi le throughput augmente-t-il lorsque j’ajoute des utilisateurs, alors que chaque utilisateur a l’impression que le service ralentit ?

Une seule lecture des weights permet de traiter un token pour chaque séquence du batch. Le nombre total de tokens par seconde augmente donc avec la taille du batch. En revanche, chaque token individuel doit attendre une étape partagée, ce qui augmente simultanément la latence par utilisateur. Surveillez la latence inter-token p99 plutôt que la valeur de throughput agrégée, et vérifiez vllm:num_requests_waiting pour déterminer si les requêtes sont en attente dans une file plutôt qu’en cours d’exécution.

Cet article vous a-t-il été utile ?