Clusters d'inférence : vLLM Tensor Parallel, Pipeline Parallel et ce que chacun vous coûte vraiment

Un modèle de classe 70B ne tient pas sur un seul GPU, quelle que soit la quantification qui laisse encore un cache KV utile. Un modèle 405B ne tient pas sur un seul nœud. Dès lors, la question n'est plus « quel GPU » mais « comment découper le modèle sur les GPU dont je dispose, et que me coûte chaque découpe ? »

Cet article passe en revue les quatre manières dont vLLM vous laisse découper un modèle — parallélisme de tenseurs, parallélisme de pipeline, parallélisme d'experts, parallélisme de données —, ce que chacune fait à votre facture de bande passante et comment choisir entre elles sur la gamme Kentino (5090, RTX Pro 6000 Blackwell, L40, L4 en PCIe — pas de pièces SXM à fabric NVLink). Le lecteur a lu I01, sait ce qu'est vLLM et doit maintenant arbitrer sa configuration.

Les quatre dimensions du découpage d'un modèle

Tous les frameworks d'inférence distribuée — vLLM, SGLang, TensorRT-LLM, Triton — exposent une combinaison des mêmes quatre axes. Ce ne sont pas des alternatives : ils se composent.

Axe Ce qu'il découpe Communication par token Sensible à la bande passante ? Effet sur la latence
Parallélisme de tenseurs Chaque couche (fragments de matmul) All-reduce par couche (×2) Oui — fortement Réduit la latence
Parallélisme de pipeline Les couches réparties en étages Activations à chaque frontière d'étage Non — légère Ajoute de la latence, augmente le débit
Parallélisme d'experts Les experts MoE répartis sur les GPU All-to-all par couche MoE Oui — par rafales Dépend du modèle
Parallélisme de données Des répliques entières, indépendantes Aucune pendant l'inférence Non Latence identique, débit ×N

La troisième colonne, c'est tout le jeu. Le TP crie sur le bus à chaque couche. Le PP chuchote entre deux étages. Ce seul fait détermine si vous gardez le TP à l'intérieur d'une machine, si vous poussez le PP entre les nœuds, et où passe la frontière.

Parallélisme de tenseurs — comment cela fonctionne vraiment

En TP, chaque matrice de poids du transformeur (QKV d'attention, sortie d'attention, FFN montante, FFN descendante) est découpée sur tensor_parallel_size GPU. Chaque GPU stocke un fragment de chaque couche et calcule un fragment de chaque activation. Comme l'attention et la FFN contiennent des matmuls qui exigent que l'activation complète soit réassemblée avant l'opération suivante (softmax, SwiGLU), les résultats partiels doivent être recombinés. vLLM le fait par un all-reduce à la fin de l'attention et un autre à la fin de la FFN — deux par bloc de transformeur.

Llama 3.3 70B compte 80 couches et une dimension cachée de 8192. En décodage à batch 32, chaque all-reduce déplace environ 512 Ko, ×160 par token généré → ~80 Mo par token sur le bus. Le prefill est bien pire : un prefill de 4 K à batch 32 pousse de l'ordre de 300 Go dans l'anneau all-reduce en une seule passe avant.

C'est ce chiffre qui explique pourquoi le TP adore NVLink. Le NVLink des SXM H100/B200 atteint 900 Go/s. Le PCIe Gen 5 x16 plafonne à 64 Go/s en unidirectionnel, 128 Go/s en bidirectionnel au mieux — ce qui est rarement le cas sur une carte à 4 GPU (les lignes sont généralement partagées, voir W02). L'écart de 14×–28× se voit dans les benchmarks : l'efficacité de montée en charge de NVLink se situe autour de 0.92×/carte, celle du PCIe autour de 0.70–0.78×/carte sur des modèles de classe 70B.

Conséquence pratique : le TP passe bien à l'échelle jusqu'à 4 GPU dans un nœud PCIe Gen 5. Au-delà, l'all-reduce coûte plus que le parallélisme ne rapporte, et mieux vaut se tourner vers le parallélisme de pipeline.

Configuration vLLM : tensor_parallel_size

--tensor-parallel-size N indique au moteur de répartir chaque tenseur de poids sur N GPU du nœud local. Contraintes :

  • N doit diviser le nombre de têtes d'attention du modèle (Llama 70B a 64 têtes → N ∈ {1, 2, 4, 8, 16, 32, 64}).
  • vLLM place les rangs TP sur le même nœud et suppose un bus intra-nœud rapide.
  • Le cache KV est fragmenté selon la dimension des têtes : chaque GPU stocke l'équivalent de total_heads / N têtes. Plus le TP est élevé, plus la marge de KV par requête est grande.

Sur le matériel Kentino : TP=4 sur une machine à 4× RTX 5090 ou 4× RTX Pro 6000 Blackwell est le point d'équilibre. TP=8 fonctionne, mais le bus PCIe grince ; vous aurez généralement intérêt à faire TP=4 × PP=2 dans une machine à 8 GPU.

Parallélisme de pipeline — l'option à distance

Le PP découpe le modèle en profondeur. Avec pipeline_parallel_size=2, le GPU 0 détient les couches 0–39 d'un Llama 70B, le GPU 1 les couches 40–79. Une requête traverse le GPU 0, le tenseur d'activation est expédié au GPU 1, qui achève la passe avant.

La communication se résume à un tenseur de forme (batch, seq_len, hidden_size) par frontière d'étage. Pour batch 32, seq 4096, hidden 8192, en FP16, cela représente ~1 Go par prefill et ~0.5 Mo par token de décodage à batch 32 — deux ordres de grandeur de moins que l'all-reduce du TP. Le PP tourne confortablement sur du simple 25 GbE, voire du 10 GbE.

Le compromis porte sur la latence. Avec PP=2, chaque token saute d'un étage à l'autre — naïvement, 2× le temps par token. vLLM atténue cela par le micro-batching : l'étage 0 entame le micro-lot suivant pendant que l'étage 1 termine le courant. Avec assez de concurrence, la bulle se referme ; avec une seule requête et sans batching, le PP n'est qu'une taxe de latence sans contrepartie.

Configuration vLLM : pipeline_parallel_size

--pipeline-parallel-size M répartit le modèle par couches sur M groupes. Nombre total de GPU = tensor_parallel_size × pipeline_parallel_size. Ce que recommande la documentation :

  • Nœud unique, ≤ 8 GPU, le modèle tient : TP pur, pipeline_parallel_size=1.
  • Multi-nœuds : TP à l'intérieur du nœud, PP entre les nœuds. Un cluster de deux nœuds et 8 GPU tourne en TP=4, PP=2.
  • Le nombre de GPU ne divise pas proprement le nombre de têtes : réglez TP=1, PP=nombre de GPU. Le PP se moque du nombre de têtes. (Une machine à 5 GPU — un emplacement sacrifié à une carte réseau — ne peut faire tourner Llama qu'en PP=5.)

Parallélisme d'experts — pour le MoE uniquement

Les modèles MoE (DeepSeek-V3, Mixtral, les variantes Qwen-MoE) n'activent pas tous les paramètres à chaque token. Ils comportent des couches FFN routées où seul un petit sous-ensemble d'« experts » se déclenche par token ; les couches d'attention denses, elles, restent denses.

Le parallélisme d'experts (EP) répartit les experts sur les GPU tout en gardant les couches denses sous TP ou DP. Avec --enable-expert-parallel, les couches d'experts passent de répliquées à partitionnées, à raison d'un ou de quelques experts par GPU. Le schéma de communication est un all-to-all par couche MoE : les tokens sont routés vers le GPU qui détient l'expert visé, le calcul se fait, le résultat revient.

L'EP consomme la bande passante par rafales. C'est lui qui rend les gros modèles MoE simplement exploitables sur des clusters PCIe — un TP complet sur un modèle à 671B actifs est sans espoir. Pour les déploiements Kentino, l'EP n'est pertinent que pour les modèles de classe DeepSeek-V3 ; un Llama 70B dense n'en tire aucun bénéfice. L'EP intégré de vLLM, avec une version récente, est le point d'entrée par défaut.

Parallélisme de données — l'axe ennuyeux et génial

Le DP est l'axe de montée en charge le plus simple, et celui que la plupart des installations sous-exploitent. Vous lancez N copies identiques du modèle, chacune sur son propre jeu de GPU (chaque jeu pouvant lui-même utiliser TP et/ou PP). Un répartiteur de charge envoie les requêtes vers la réplique qui a de la capacité.

Ce que le DP apporte :

  • Une montée en débit linéaire (×N requêtes/s).
  • Zéro communication entre répliques pendant l'inférence.
  • Des caches KV indépendants par réplique (le cache de préfixes est propre à chaque réplique).
  • Une isolation triviale des pannes.

Ce que le DP coûte :

  • ×N la mémoire GPU — chaque réplique détient le modèle complet.
  • Aucune réduction de latence. Une requête isolée prend le temps qu'elle prend sur une réplique.

Si vous disposez d'une machine à 4× RTX Pro 6000 et que Llama 70B tient en TP=4, une seconde machine à 4 GPU donne DP=2 × TP=4 : débit doublé, latence par requête inchangée. Pour des charges de chat, d'agents et de RAG, c'est le bon arbitrage. L'option --data-parallel-size de vLLM (et le mode plus récent data_parallel_deployment) lance et gère les répliques. Le DP est la façon la plus propre de dépasser une seule machine.

Combiner les axes — la règle empirique

Tient sur un seul GPU
TP=1, montée en charge via des répliques DP
↓
Tient dans un nœud (≤4 GPU PCIe)
TP dans le nœud, DP entre les nœuds
↓
Ne tient pas dans un nœud
TP dans chaque nœud, PP entre les nœuds, DP par-dessus

Choix de l'axe : partez du plus petit parallélisme qui tient, puis ajoutez du DP avant du PP.

Exemple concret. Servir Llama 3.3 70B (FP8 ≈ 75 Go de poids, plus le KV) en forte concurrence :

  • Une machine à 4× RTX Pro 6000 Blackwell (4 × 96 Go = 384 Go) le fait tourner confortablement en TP=4, avec environ 250 Go restants pour le KV, le cache de préfixes et les graphes CUDA.
  • Ajoutez une seconde machine à 4× Pro 6000. DP=2 × TP=4. Deux répliques derrière un routeur. Débit doublé, latence identique.
  • Llama 3.1 405B en FP8 (~400 Go de poids) ? Une seule machine à 4× Pro 6000 ne suffit pas. Deux machines en PP=2 × TP=4, si — et le lien inter-nœuds transporte des activations, pas des all-reduce. Le 25 GbE suffit ; le 100 GbE est confortable.

Le cache KV : la partie que tout le monde sous-estime

Le cache KV, ce sont les tenseurs clé/valeur d'attention cumulés pour chaque token de prompt, chaque token généré, chaque requête simultanée et chaque couche. Il croît linéairement avec la longueur de contexte et la concurrence. Llama 70B sur 8 K de contexte demande environ 2.5 Go de cache KV par requête en FP16. À 32 requêtes simultanées, cela fait 80 Go — davantage que toute la VRAM d'un 5090.

Comment le parallélisme interagit avec le KV :

  • En TP, le KV est fragmenté par tête d'attention sur le groupe TP. KV par GPU = total / tensor_parallel_size. Plus le TP est élevé, plus la marge en requêtes simultanées est grande.
  • En PP, le KV reste sur le GPU qui détient la couche l'ayant produit. Chaque étage possède son propre KV.
  • En DP, le KV est totalement indépendant par réplique.
  • En parallélisme de contexte (un mode vLLM plus récent), le KV est fragmenté selon la dimension séquence — utile pour des contextes très longs sur une seule requête.

Au moment de dimensionner une machine, ne vérifiez pas seulement que les poids tiennent. Faites le calcul du KV à votre concurrence et à votre fenêtre de contexte cibles. La panne silencieuse la plus fréquente en production vLLM, c'est le moteur qui préempte des requêtes sous pression de KV.

Routage des requêtes — ce qui se place devant le cluster

Une instance vLLM unique gère son propre batching interne (batching continu, cache de préfixes, ordonnancement). Elle ne route pas entre les répliques. C'est le travail du routeur.

Routeur Ce qu'il sait Quand l'utiliser
NGINX simple Rien (tourniquet) Déploiements à un seul modèle, la simplicité l'emporte
HAProxy Rien + contrôle de santé Multi-modèles, routage par en-tête
vLLM Router (Rust) KV / préfixe / file d'attente ≥4 répliques, quand le routage tenant compte des préfixes compte
llm-d (Kubernetes) Tout ce qui précède + EP Parcs K8s, MoE, désagrégation prefill/décodage

NGINX est le bon choix par défaut pour une installation à 2 répliques — tourniquet, contrôles de santé sur /health, et c'est tout. Le vLLM Router (Rust, sorti fin 2025) s'impose dès lors que le taux de succès du cache de préfixes domine votre latence de queue : il route par hachage cohérent du préfixe de prompt, de sorte que les répliques au cache chaud continuent de recevoir les mêmes conversations. Pour une charge d'agents avec de longs prompts système partagés, cela peut doubler le débit effectif par rapport au tourniquet.

Le calcul de bande passante

Références croisées : N02, N06.

Charge de travail Bande passante nécessaire Lien réaliste chez Kentino
TP=4 dans une seule machine (PCIe Gen 5) 50–200 Go/s par paire PCIe intra-nœud
PP sur deux nœuds, batch 32, décodage 0.05–0.2 Go/s 10 GbE — confortable
PP sur deux nœuds, batch 32, prefill 1–4 Go/s en rafale 25 GbE confortable, 10 GbE juste
DP sur deux nœuds ~0 (routeur seulement) 1 GbE d'administration suffit
EP sur 8 GPU dans une seule machine (MoE) 20–80 Go/s par rafales Intra-nœud uniquement
EP étendu sur 2 nœuds (classe DeepSeek-V3) 10–40 Go/s en continu 100 GbE RoCE ou InfiniBand

La lecture honnête : le TP et l'EP veulent rester dans une seule machine. Le PP et le DP s'en moquent. Avec un lien inter-nœuds de 10–25 GbE, le PP et le DP se portent très bien. Dès que vous voulez du TP entre nœuds, vous payez de l'InfiniBand HDR ou du RoCE 200 GbE — et vous devriez d'abord vous demander si du DP entre des groupes TP d'un seul nœud ne donne pas le même résultat pour le dixième du budget. Pour la plupart des déploiements de taille Kentino, c'est le cas.

Deux recettes de configuration concrètes

Recette A — Un nœud, 4× RTX 5090, Llama 70B Q4 / FP8

Matériel : Kentino AI 256 Turin Dual ou toute machine à 4 GPU 5090. PCIe Gen 5, pas de NVLink, hôte AMD EPYC.

vllm serve meta-llama/Llama-3.3-70B-Instruct-FP8 \
  --tensor-parallel-size 4 \
  --pipeline-parallel-size 1 \
  --max-model-len 8192 \
  --gpu-memory-utilization 0.92 \
  --enable-prefix-caching \
  --max-num-seqs 64 \
  --dtype auto \
  --port 8000

Attendu : environ 30–40 tok/s par requête à faible concurrence, et un agrégat de ~400–600 tok/s à 32 requêtes simultanées (variable selon le mélange de prompts, le taux de succès du cache de préfixes et la quantification exacte — à prendre comme une enveloppe de départ). L'all-reduce en PCIe Gen 5 est le goulet d'étranglement au décodage ; le prefill monte presque linéairement.

Recette B — Deux nœuds, 8× RTX Pro 6000 Blackwell au total, Llama 405B FP8

Deux machines Kentino AI, chacune avec 4× Pro 6000 (96 Go). Lien 100 GbE RoCE entre elles, ou 25 GbE si le budget est serré (cela fonctionnera, avec un prefill un peu plus lent).

# Nœud 0 (principal) :
vllm serve meta-llama/Llama-3.1-405B-Instruct-FP8 \
  --tensor-parallel-size 4 \
  --pipeline-parallel-size 2 \
  --distributed-executor-backend ray \
  --max-model-len 8192 \
  --gpu-memory-utilization 0.90 \
  --enable-prefix-caching \
  --max-num-seqs 32

# Nœud 1 (worker, rattaché via Ray) :
ray start --address=<head-ip>:6379

Le TP=4 à l'intérieur de chaque nœud utilise le PCIe Gen 5 pour les all-reduce. Le PP=2 entre les nœuds expédie les activations sur du 25/100 GbE. Avec Ray comme backend distribué (le choix par défaut de vLLM en multi-nœuds), le nœud principal coordonne l'ordonnancement et l'état du KV.

Verdict honnête sur les performances : un 405B en FP8 réparti sur 8× Pro 6000 en PCIe + Ethernet se situe autour de 6–12 tok/s par requête — bien en deçà d'un châssis 8× SXM B200, mais pour une fraction de l'investissement et sans le problème d'approvisionnement des SXM. Si votre SLA dit « répondre en 30 s pour une complétion de 500 tokens », cela fonctionne. S'il dit « répondre en 2 s », n'utilisez pas un 405B — prenez un 70B.

Ce que nous ne proposons pas

NVLink, NVSwitch, SXM B200, cartes HGX complètes : absents de la gamme Kentino. Ce sont les bonnes réponses si vous avez le budget et la charge de travail correspondante. Ce ne sont pas les bonnes réponses pour la plupart de nos clients, qui dimensionnent pour 1 à 4 workflows d'agents simultanés ou une seule plateforme robotique, pas pour de l'inférence SaaS à 1 000 utilisateurs. La voie PCIe est honnête sur ce qu'elle peut et ne peut pas faire. Du TP sous les 10 ms par token sur 16 GPU, c'est une autre conversation — ce n'est pas le cluster dont parle cet article.

Que faire ensuite

Si vous montez un cluster vLLM, traitez ces points dans l'ordre :

  1. Notez le modèle et le SLA. Nombre de paramètres, quantification, tok/s visés par requête, requêtes simultanées visées, fenêtre de contexte visée. Sans ces chiffres, le choix du parallélisme n'est qu'une supposition.
  2. Calculez les poids + le KV à la concurrence visée. Si le KV seul dépasse la VRAM disponible d'un GPU, il vous faut du TP. Si les poids dépassent un nœud, il vous faut du PP.
  3. Commencez par le plus petit TP qui tient. TP=2 avant TP=4, et TP=4 avant TP=8. Chaque palier perd de l'efficacité de montée en charge sur PCIe.
  4. Ajoutez du DP pour le débit avant d'ajouter du PP. Deux nœuds en DP battent presque toujours un nœud découpé en PP pour les charges sensibles à la latence.
  5. Réservez le PP au cas où le modèle ne tient pas ou pour couvrir un nombre de nœuds que le TP ne peut pas diviser proprement.
  6. Placez un routeur devant, même avec deux répliques. Un NGINX en tourniquet suffit pour démarrer ; passez au vLLM Router quand le taux de succès du cache de préfixes compte.
  7. Surveillez l'utilisation du KV, pas seulement celle du GPU. Un cluster à 95 % de GPU et 100 % de KV préempte des requêtes. Le tableau de bord qu'il vous faut, c'est vllm_kv_cache_usage_perc dans le temps.

Suites dans cette série : stockage de cluster (K04), ordonnancement (K05), gestion des pannes (K06), et le plafond du PCIe comme interconnexion (K07). Le calcul réseau est détaillé dans N02 et N06.


Cet article fait partie du Kentino Wiki, une série de référence sur le calcul IA, la robotique et les systèmes qui les relient. Commentaires et corrections bienvenus à info@kentino.com.