08 000x0800

DeepSeek-V4-Flash-0731 sur deux DGX Spark : la recette complète

96/100 de code juste jugé par exécution, 78,55 tok/s en mono-flux et 188,9 tok/s à seize flux avec DeepSeek-V4-Flash-0731 sur deux DGX Spark.

date
tags
dgx-spark · deepseek-v4 · vllm · tp2 · inference-locale
type
0x0800
lecture
34 min
sources
5
Deux rameurs dans le même bateau, avirons dans l'eau au même instant, une pale vermillon.
Code juste
96/100
jugé par exécution, config livrée
Débit mono-flux
78,55 tok/s
code, 512 tokens, hors TTFT
Débit agrégé
188,9 tok/s
à seize flux, TTFT sous 0,8 s
Cache KV
1,79 M
tokens, lus dans le journal de démarrage
Puissance
41 W
puissance GPU par boîtier en pointe, aucun bridage
Latence RDMA
1,86 µs
typique en charge, messages de 8 octets

Ce document raconte ce qu’on a fait pour servir DeepSeek-V4-Flash-0731 en TP=2 sur deux DGX Spark (GB10, SM121), et ce qu’on a mesuré. Il inclut les pièges qui nous ont coûté du temps, parce que ce sont eux qui manquent partout ailleurs.

Il s’adresse à qui doit décider si un modèle de cette taille peut tourner sur site, dans son propre réseau, sans envoyer une ligne de code chez un tiers. Deux boîtiers, environ 8 000 € de matériel, 41 W de puissance GPU en pointe par boîtier. Tout ce qui suit se rejoue avec les commandes données ; les scripts de mesure sont dans codebench/, à côté de ce fichier.

Dates des mesures : 1er au 3 août 2026. Chaque tableau porte la sienne quand elle importe. Machines : spark-1 et spark-2, 121 Go de mémoire unifiée chacune, reliées en direct par un lien 200 Gb/s (enp1s0f0np0). Latence RDMA mesurée entre les deux : 1,86 µs en typique (voir plus bas).

Résultat

Configuration finale, mono-flux, décodage hors TTFT, mesuré côté client sur le flux SSE. Mesures du 2 août 2026, trois tirages par charge :

chargedécodage
code, 512 tokens de sortie78,55 tok/s
code, 1024 tokens75,33
prose, 512 tokens47,16
code, 512 tokens de sortie78,55 tok/scode, 1024 tokens75,33 tok/sprose, 512 tokens47,16 tok/s
La prose est plus lente que le code, et non l’inverse : le drafter suit mieux la génération de code. C’est contre-intuitif et c’est reproductible.

La prose est plus lente que le code, et non l’inverse : le drafter suit mieux la génération de code. C’est contre-intuitif et c’est reproductible.

Le débit ne dépend pas de la longueur du contexte. De 4 k à 131 k tokens d’entrée, le décodage reste dans un couloir de 1,5 % en pas par seconde. Le préremplissage, lui, décroît : 1 846 tok/s à 4 k, 1 503 à 131 k. Détail et explication plus bas.

En concurrence : 100,4 tok/s agrégés à deux flux avec la configuration finale, et jusqu’à 188,9 tok/s à seize flux en relevant un seul paramètre (voir « Relever le plafond »).

Porte de qualité : le code produit est extrait puis exécuté contre des assertions cachées. De l’exécution, pas un test de mots-clés. Score de la configuration finale : 96/100 (Python 50/50, Go 46/50), aucune tâche instable sur cent tirages. Le banc complet est plus bas.

Le même moteur reprend aussi les petites tâches de l’agent, classement et extraction d’entités, 25 sur 25. Le second modèle qui les servait a été retiré.

Le format réel du checkpoint

À vérifier soi-même plutôt qu’à croire sur parole. En lisant les en-têtes des 48 safetensors :

  • Experts : I8 empaqueté en 4 bits + échelles F8_E8M0, bloc 32 → MXFP4 (expert_dtype: fp4).
  • Dense et attention : F8_E4M3 + échelles F8_E8M0, weight_block_size [128,128], scale_fmt: ue8m0.
  • Têtes DSpark incluses dans le checkpoint : dspark_target_layer_ids: [40,41,42], dspark_markov_rank: 256.
  • 43 couches, 256 experts routés, max_position_embeddings: 1048576, YaRN facteur 16 au-dessus de 65536.

Le lancement

vLLM depuis le fork jasl/vllm (build 20260721b1.dev0+g48d274954.d20260721.cu132), installé dans un venv .venv-dsv4 identique sur les deux nœuds. TP=2 exige des builds appariés : même arbre, même torch. Un décalage se manifeste par des plantages obscurs à l’initialisation collective.

Topologie :

--distributed-executor-backend mp --nnodes 2 \
--master-addr 192.168.100.10 --master-port 29519

Tête : --node-rank 0 --port 8082. Travailleur : --node-rank 1 --headless.

Options qui comptent :

--tokenizer-mode deepseek_v4 --kv-cache-dtype fp8 --block-size 256 \
--enable-prefix-caching --max-num-seqs 2 --max-num-batched-tokens 4096 \
--gpu-memory-utilization 0.85 --no-enable-flashinfer-autotune \
--reasoning-parser deepseek_v4 --enable-auto-tool-choice \
--tool-call-parser deepseek_v4

Spéculation :

{"method":"dspark","num_speculative_tokens":5,"draft_sample_method":"greedy"}

Compilation :

{"cudagraph_mode":"FULL_AND_PIECEWISE","custom_ops":["all"]}

Plus VLLM_USE_FLASHINFER_SAMPLER=1, et pas --enable-expert-parallel.

Reproduire pas à pas

La séquence complète, dans l’ordre, telle qu’on la rejoue à chaque session.

1. Le réseau

Les deux machines sont reliées en direct, une adresse RoCE de chaque côté (192.168.100.10 et .11). Vérifier que les deux HCA remontent : ls /sys/class/infiniband/. On en attend deux utiles, rocep1s0f0 et roceP2p1s0f0. Les déclarer toutes les deux à NCCL, avec la fusion :

NCCL_IB_HCA=rocep1s0f0,roceP2p1s0f0
NCCL_IB_MERGE_NICS=1
NCCL_PROTO=Simple
NCCL_NET_GDR_LEVEL=0        # GPUDirect RDMA n'existe pas sur GB10

Un seul câble, deux interfaces à déclarer : oublier la seconde coûte 39 % de bande passante collective.

2. Le venv et le build

À faire sur les deux nœuds, à l’identique. Compter une trentaine de minutes de compilation par nœud.

# venv dédié, Python 3.12
python3.12 -m venv ~/.venv-dsv4

# torch pour GB10 : cu132, surtout pas torchaudio (il casse la résolution)
~/.venv-dsv4/bin/pip install torch==2.13.0+cu132 \
  --index-url https://download.pytorch.org/whl/cu132

# le fork, sur la branche qui porte sm_121
git clone https://github.com/jasl/vllm.git ~/vllm-jasl-dsv4
cd ~/vllm-jasl-dsv4
git checkout b12x-nvfp4-mxfp4

# le seul correctif obligatoire : lever l'épinglage torch==2.11.0
git apply ~/models/_runbook/0001-depin-torch-cuda.patch

# build. MAX_JOBS=4 est LE réglage anti-OOM sur une boîte 128 Go unifiée :
# sans lui, l'édition de liens se fait tuer.
MAX_JOBS=4 ~/.venv-dsv4/bin/pip install -e . --no-build-isolation

# le NCCL effectif vient de torch, pas de pip : vérifier, ne rien installer
~/.venv-dsv4/bin/python -c "import torch;print(torch.cuda.nccl.version())"
# attendu ici : (2, 29, 7)

Piège au passage : pip list affiche nvidia-nccl-cu13 2.30.4 dans ce venv, alors que torch est lié à 2.29.7 et charge celui-là. Installer un NCCL plus récent par pip ne change pas le NCCL qui tourne. La seule source de vérité est torch.cuda.nccl.version().

Le correctif de l’étape 4 retire torch == 2.11.0 de pyproject.toml, de requirements/build/cuda.txt et de requirements/cuda.txt, ainsi que les dépendances torchaudio/torchcodec qui entraînent la résolution avec elles. Il ne touche à aucune ligne de code du moteur. C’est la totalité de ce qu’il faut patcher pour reproduire les chiffres de ce tutoriel : le fork sert ce checkpoint tel quel.

Vérifier ensuite que les deux nœuds sont bien appariés : même arbre source, même torch. Un décalage se manifeste par des plantages illisibles à l’initialisation collective, jamais par un message clair :

for h in spark-1 spark-2; do
  ssh $h '~/.venv-dsv4/bin/python -c "import vllm,torch;print(vllm.__version__,torch.__version__)"'
done
# attendu, deux fois la même ligne :
# 20260721b1.dev0+g48d274954.d20260721.cu132 2.13.0+cu132

Versions effectivement installées ici, pour comparaison : Python 3.12.13, torch 2.13.0+cu132, triton 3.7.1, flashinfer-python 0.6.14 (0.6.13 ne suffit pas), tilelang 0.1.9, nvidia-nccl-cu13 2.30.4, numpy 2.3.5.

Ce qui n’est pas dans cette pile, contrairement à ce qu’on lit ailleurs pour DeepSeek-V4 sur GB10 : DeepGEMM et le correctif d’indexeur. import deep_gemm échoue dans le venv qui a produit toutes les mesures. Ces deux éléments concernent la variante requantifiée en NVFP4, pas le checkpoint officiel 0731.

3. Le checkpoint

48 shards, 235 Go. On le récupère une fois, puis on le recopie sur le second nœud par le lien direct :

# depuis le nœud qui l'a déjà
rsync -a --info=progress2 --no-compress -e 'ssh -c aes128-gcm@openssh.com' \
  ~/models/dsv4-0731/ spark-2:~/models/dsv4-0731/

672 Mo/s mesurés, 3 min 56. Vérifier ensuite chaque en-tête safetensors, pas les tailles de fichier (voir plus bas) : un shard tronqué a la bonne taille si la copie a été relancée avec cp -n.

4. Vider le cache page avant de lancer

sync && echo 3 > /proc/sys/vm/drop_caches sur les deux nœuds. Sur une mémoire unifiée, le cache page dispute la place au modèle.

5. Lancer

Deux sessions tmux, jamais ssh + nohup :

tmux new-session -d -s dsv4 \
  'CGMODE=FULL_AND_PIECEWISE NOEP=1 SPECK=5 GPUUTIL=0.85 ./dsv4_run.sh head N0731'
# sur le second nœud, la même chose avec 'worker'

Attendre Application startup complete dans le journal. Compter environ six minutes, dont l’essentiel en capture des graphes CUDA.

6. Préchauffer avant de mesurer quoi que ce soit

Cinq générations longues au minimum. Un moteur qui vient de démarrer n’est pas le moteur qui sert : les premières requêtes paient un surcoût que le journal de démarrage n’affiche nulle part. Qui mesure à froid mesure le chemin froid.

7. Mesurer

Le harnais de qualité de code se lance ainsi :

URL=http://127.0.0.1:8082/v1 MODEL=deepseek-v4-flash \
  python codebench/run.py -k 5 --out resultats.json

Avant de juger un modèle, lancer python codebench/run.py --selftest : les solutions de référence doivent passer 20/20. Si le harnais échoue sur ses propres réponses, il ne mesure rien.

Ce qui fait le débit, mesuré

Chaque ligne est une relance complète du modèle sur les deux nœuds, puis une mesure courte. Les configurations qui ne bootent pas sont enregistrées comme telles au lieu d’interrompre le balayage.

Campagne du 1er août 2026, protocole de mesure de l’époque : les chiffres absolus de ce tableau ne se comparent pas à ceux de l’en-tête, qui viennent d’un banc plus strict (sortie fixe, hors TTFT). Ce qui se lit ici, ce sont les écarts entre lignes, tous mesurés le même jour de la même façon.

Configurationpetitmoyenacceptation
sans spéculation17,0616,69—
référence : PIECEWISE + EP + k=536,3438,6247,4 %
+ CUDA graphs FULL_AND_PIECEWISE44,0844,8442,1 %
sans EP seul (k=5)37,6541,0046,1 %
CUDA graphs FULL + sans EP + k=549,9945,7245,6 %
le même + mémoire 0,8547,9653,6850,7 %
k=738,9242,3929,4 %
k=1023,9027,1524,0 %
backend MoE tritonne démarre pas
■ petit contexte■ contexte moyensans spéculation17,0616,69référence : PIECEWISE + EP + k=536,3438,62+ CUDA graphs FULL_AND_PIECEWISE44,0844,84sans EP seul (k=5)37,6541,00CUDA graphs FULL + sans EP + k=549,9945,72le même + mémoire 0,8547,9653,68k=738,9242,39k=1023,9027,15backend MoE tritonne démarre pas
Campagne du 1er août 2026, deux longueurs de contexte. La spéculation DSpark fait le gros du travail ; au-delà de k=5, le débit retombe.

Les leçons :

  1. La spéculation DSpark fait tout. 16,7 → 38,6 tok/s, soit un facteur 2,3. C’est le levier principal, et il ne coûte rien : les têtes sont dans le checkpoint.

  2. FULL_AND_PIECEWISE vaut +16 %. Le mode CUDA graph par défaut laisse de la performance sur la table à batch 1.

  3. L’expert-parallel coûte du débit ici. Contre-intuitif : à 128 experts locaux par nœud, le trafic de dispatch pèse plus que le gain de parallélisme en régime mono-flux. EP se justifie en forte concurrence, pas pour un agent.

  4. k=5 est l’optimum, et c’est aussi le minimum. DSpark refuse en-dessous (num_speculative_tokens >= dspark_block_size (5)). Au-dessus, le débit tombe : 38,92 à k=7 et 23,90 à k=10 contre 49,99 à k=5. Confirmé le 3 août sur la configuration finale, où k=7 coûte de 11,5 % à 17,1 % selon la charge.

    Attention à ne pas lire le taux d’acceptation comme la cause. Il chute (45,6 % → 29,4 % → 24,0 %) mais son dénominateur grossit en même temps. Ce qui compte est le nombre de tokens acceptés par pas, et sur la mesure du 3 août il est identique à k=5 et à k=7 : 4,30. Le drafter ne devient pas moins bon, il propose davantage sans que rien de plus soit retenu, et chaque pas coûte plus cher à vérifier : 72,0 ms à k=5, 82,5 ms à k=7. Le débit paie la vérification, pas la qualité du brouillon.

  5. L’acceptation du drafter varie de 41 à 52 % d’un essai à l’autre sur le même prompt. C’est la principale source de bruit entre deux mesures ; ne pas conclure sur un écart de 5 % entre deux configurations.

Le prefill, lui, ne bouge pas avec ces leviers : 1 972 tok/s à 8K, 1 593 à 82K, 1 425 à 164K. La dégradation est douce, le modèle tient le long contexte.

Le débit dépend du contenu, pas seulement de la machine

C’est ce qui fausse le plus souvent les chiffres publiés. Même moteur, même configuration, même journée, cinq contenus différents :

Ce qu’on demandeDébit
Compter de 1 à 30085,4 tok/s
Produire 60 objets JSON77,9 tok/s
Table de multiplication par 1274,4 tok/s
Arbre binaire de recherche64,1 tok/s
Nouvelle de 500 mots43,8 tok/s

Le premier et le dernier tiennent dans un rapport de deux. La raison est mécanique : le décodage spéculatif propose plusieurs tokens d’avance et n’en garde que ceux que le grand modèle valide. Sur une suite de nombres, il devine presque tout. Sur de la prose, presque rien. Un banc d’essai bâti sur du comptage mesure la prévisibilité du texte, pas la puissance de la machine.

Sur nos propres contenus de production, la fourchette se resserre :

TâcheDébit
Extraction JSON par lots78,1 tok/s
Extraction JSON unitaire54,9 tok/s
Traitement documentaire54,2 tok/s
Écriture de types Go50,3 tok/s
Écriture d’un handler Go46,4 tok/s
■ contenus de banc d'essai■ contenus de productionCompter de 1 à 30085,4Extraction JSON par lots78,1Produire 60 objets JSON77,9Table de multiplication par 1274,4Arbre binaire de recherche64,1Extraction JSON unitaire54,9Traitement documentaire54,2Écriture de types Go50,3Écriture d'un handler Go46,4Nouvelle de 500 mots43,8
Les deux tableaux réunis, triés par débit décroissant. En bleu les contenus de banc d’essai, en vert nos contenus de production. Le rapport de deux entre le comptage et la prose est intégralement dû à la prévisibilité du texte.

Pic 78,1, moyenne 56,8, plancher 46,4. Le plancher est le seul chiffre qu’on peut promettre à un client. Et il tombe sur un cas qu’on n’attendait pas là : la génération de code Go est plus lente chez nous que la prose.

Combien de sessions, combien de contexte

Le cache KV alloué en configuration finale tient 1 793 656 tokens, chiffre lu dans le journal de démarrage (GPU KV cache size, avec Maximum concurrency for 393,216 tokens per request: 4.56x qui le recoupe).

Contexte par sessionSessions simultanées en mémoire
384 000 tokens4,7
256 0007,0
128 00014,0
32 00056,1
8 000224,2
384 000 tokens4,7 sessions256 0007,0 sessions128 00014,0 sessions32 00056,1 sessions8 000224,2 sessions
Échelle logarithmique. La mémoire n’est pourtant pas la contrainte : le plafond de requêtes en vol l’est.

Mais la mémoire n’est pas la contrainte : --max-num-seqs 2 l’est. Au-delà de deux requêtes en vol, les suivantes attendent en file. Une mesure à « concurrence 6 » sur cette configuration ne mesure pas six flux, elle mesure une file d’attente. Ce plafond est un choix, pas une limite de la machine, et il se relève presque gratuitement.

À deux flux réellement simultanés, on tient 100,4 tok/s agrégés, soit ~50,2 par flux : presque le double du mono-flux, sans rien perdre par flux. Mesure de référence, cinq minutes de charge soutenue, 108 requêtes, 30 558 tokens en 304,4 s.

Relever le plafond : la seule mesure qui ait produit un gain

Deux échelles, une seule variable qui change (--max-num-seqs), même harnais : sortie fixée à 512 tokens exactement (ignore_eos), T=0, préfixe unique par requête pour neutraliser le cache de préfixe, trois tirages par point. La sortie fixe est le point clé : tous les créneaux d’un lot se libèrent ensemble, donc aucun ne reste vide en attendant un traînard. C’est ce biais qui faisait sous-estimer la capacité dans nos campagnes précédentes.

fluxseqs=2TTFT méd.seqs=16TTFT méd.
140,050,23 s43,150,25 s
263,440,39 s62,800,35 s
464,487,54 s88,110,32 s
662,6315,58 s116,510,51 s
859,8124,25 s134,300,44 s
1660,3456,64 s188,880,75 s
■ seqs=16■ seqs=20501001502001246816tok/s agrégésflux concurrents
Débit agrégé. Les deux séries coïncident à un et deux flux, ce qui valide le harnais, puis divergent exactement là où --max-num-seqs 2 sature. À seize flux, 188,88 contre 60,34 tok/s : un facteur 3,1.
■ seqs=2■ seqs=160,21520801246816TTFT médian, sflux concurrents
Latence médiane avant le premier token, échelle logarithmique. À seqs=2, l’attente passe de 0,39 s à 56,6 s pendant que le débit agrégé reste plat : on n’achète que de l’attente. À seqs=16, elle reste sous 0,8 s partout.

Les deux séries coïncident à un et deux flux : les deux configurations y font la même chose, ce qui valide le harnais. Elles divergent exactement là où max-num-seqs 2 sature : à gauche l’agrégat est plat de C2 à C16 pendant que l’attente avant le premier token passe de 0,39 s à 56,6 s ; à droite il monte jusqu’à 188,88 tok/s, soit 3,1×, avec un TTFT qui reste sous 0,8 s partout.

Le prix est le débit par flux : 44,1 tok/s seul, 13,1 à seize flux. C’est l’arbitrage normal d’un serveur. Le coût mémoire, lui, est marginal : le pool KV passe de 1 793 656 à 1 717 797 tokens, −4,2 %. C’est --max-num-batched-tokens qui coûte de la mémoire, pas --max-num-seqs.

Pour choisir : un agent seul, --max-num-seqs 2, meilleure latence et meilleur débit mono-flux. Plusieurs utilisateurs, montez le paramètre : c’est le levier le plus rentable de toute cette campagne, et le seul qui ait produit un gain net.

Mesurer ce chiffre est plus piégeux qu’il n’y paraît. Sur des rafales courtes, le même serveur donne entre 77 et 116 tok/s selon la façon de compter. La ligne Avg generation throughput du journal divise un nombre de tokens par une fenêtre de dix secondes, quoi qu’il se soit passé dedans : pendant un préremplissage long elle affiche 0,1 tok/s alors que la machine sature, et sur une rafale de quatre secondes elle mélange la fenêtre utile avec les fenêtres de montée et de descente. Sur cinq minutes soutenues, journal et client convergent à 0,4 % près. Une métrique moyennée sur une fenêtre fixe ne mesure le débit que si la charge remplit la fenêtre.

Le contexte long : ce que ça coûte vraiment

Sortie tenue strictement identique à toutes les longueurs : le prompt est un remplissage de longueur variable suivi de « ignore le texte ci-dessus, recopie mot pour mot le passage suivant », avec un passage fixe, à température 0. Trois tirages par point, préfixe unique pour que le cache de préfixe ne rende pas les tirages suivants gratuits, acceptation relevée sur /metrics avant et après chaque point.

entréeTTFTpréremplissagedécodageacceptationpas/s
4 2402,30 s1 846 tok/s76,388,9 %14,02
16 5208,67 s1 90571,182,1 %13,92
32 88018,12 s1 81468,377,8 %13,97
65 68040,16 s1 63661,269,5 %13,69
80 12049,69 s1 61279,193,2 %13,97
100 12063,60 s1 57476,391,1 %13,73
131 20087,28 s1 50384,0100,0 %14,00
■ décodage, tok/s■ acceptation, %506070809060 %70 %80 %90 %100 %4 k17 k33 k66 k131 kdécodage, tok/sacceptationtokens d'entrée
Le débit en tokens par seconde suit l’acceptation de la spéculation, courbe pour courbe — et pas la longueur du contexte. Le point le plus long est le plus rapide, 84,0 tok/s à 131 k, parce que la recopie y est acceptée à 100 %.
■ pas par secondeamplitude des sept points : 2,4 %04812164 k17 k33 k66 k131 kpas/stokens d'entrée
Le même balayage en pas de décodage par seconde : 13,69 à 14,02, soit 2,4 % d’écart, sous la barre d’erreur de ±2 % entre deux démarrages. La bande couvre l’amplitude complète des sept points.

La colonne pas/s est le nombre de pas de décodage par seconde : le débit divisé par le multiplicateur de spéculation 1 + longueur d'acceptation. Elle est constante à 2,4 % près sur toute la plage.

Le résultat qui compte pour dimensionner un agent : la longueur du contexte n’a aucun effet mesurable sur la vitesse d’un pas de décodage entre 4 k et 131 k. C’est l’attente à ne pas avoir avec une attention dense. Le débit en tokens par seconde bouge, mais il suit l’acceptation de la spéculation, pas la longueur, et le point le plus long est même le plus rapide, 84,0 tok/s à 131 k, parce que la recopie y est acceptée à 100 %.

Pourquoi, et c’est ce qui permet de savoir quand transposer ce résultat : le checkpoint déclare index_topk: 512, et au décodage le noyau reçoit des topk_indices de forme (num_decodes, seq_len, 512). L’attention lit un budget fixe de 512 entrées de cache, quelle que soit la longueur du contexte. Le journal de démarrage le confirme (FlashInfer SM120 packed sparse-MLA decode, DSA indexer decode path). Sur une attention dense, le même balayage donnerait une décroissance nette : ce résultat vaut pour une attention sparse à budget fixe, pas pour n’importe quelle architecture.

Les sept points tiennent dans une formule à un paramètre, exacte à 1,5 % près :

débit ≈ 13,90 × (1 + tokens acceptés par pas), un pas dure 72 ms.

Elle a une conséquence pratique immédiate : avec SPECK=5, le mono-flux ne peut pas dépasser 13,90 × 6 = 83,4 tok/s, et notre meilleur point mesure 84,03. On est au plafond, pas près du plafond. Inutile de chercher du débit dans les réglages d’ordonnancement : aucun ne touche à ce terme.

Le seul levier est k, et le moteur accepte 7. Nous l’avons mesuré, et ça coûte : le pas passe de 72,0 à 82,5 ms (−12,8 % de pas par seconde) pendant que les tokens acceptés par pas restent identiques, à 4,30 dans les deux cas. Le brouilleur DSpark sature en dessous de 5 : lui demander sept propositions ne lui en fait pas rendre davantage, on paie juste la vérification plus cher. En pratique SPECK=7 perd 11,5 % à 17,1 % de débit selon la charge, à qualité intacte (98/100). SPECK=5 n’est pas seulement le plancher imposé par le moteur, c’est le meilleur réglage.

■ préremplissage, tok/s■ TTFT, s1 4001 5501 7001 8502 0000 s25 s50 s75 s100 s4 k17 k33 k66 k131 kpréremplissage, tok/sTTFTtokens d'entrée
Préremplissage et attente avant le premier token. C’est le seul terme qui dépend réellement de la longueur : −19 % de débit de prefill entre 4 k et 131 k, et 87 secondes avant le premier mot.

Ce qui coûte vraiment, c’est le premier token : 87 secondes pour avaler 131 k, et un préremplissage qui perd 19 % entre 4 k et 131 k. D’où l’intérêt du cache de préfixe, section suivante.

Le cache de préfixe survit aux requêtes

Question qui décide de l’architecture d’un agent : le contexte injecté est-il rejeté à la fin de chaque tour ? Non. Mesure, un fichier de 32 818 tokens placé en tête de prompt, la question variant à chaque tour :

TourPrefillTokens retrouvés en cache
1, préfixe neuf18,1 s0 sur 32 818
2, même fichier, autre question1,0 s32 512 sur 32 819
3, question du tour 10,9 s32 512 sur 32 818
1, préfixe neuf18,1 s2, même fichier, autre question1,0 s3, question du tour 10,9 s
Facteur 18 sur le préremplissage dès le second tour. Le partage vaut aussi entre deux agents distincts qui reçoivent le même préambule.

Les blocs KV survivent à la requête qui les a créés et sont réutilisés tant que l’éviction LRU ne les a pas repris. Facteur 18 sur le prefill, et le partage vaut aussi entre deux agents distincts qui reçoivent le même préambule.

Deux conditions : le fichier doit être au début du prompt, avant tout ce qui varie, car la correspondance casse au premier token différent ; et il ne doit pas changer entre les tours. C’est aussi ce qui rend la taille du pool KV concrète : elle ne limite pas ce qu’un tour peut recevoir (--max-model-len s’en charge), elle décide de combien d’historique survit avant éviction quand plusieurs agents alternent.

Ce que font les machines pendant un run

Relevé sur 90 secondes, deux flux en charge, un échantillon par seconde sur chaque nœud :

premier nœudsecond nœud
Horloge SM min / méd. / max2 411 / 2 457 / 2 496 MHz2 411 / 2 483 / 2 509 MHz
Puissance33 W médians, 35 W max40 W médians, 41 W max
Température56 °C médians, 61 max62 °C médians, 67 max
Occupation GPU96 %95 %
Bridage matériel0x0 sur 90 relevés0x0 sur 90 relevés
■médiane,■maximum, en °C. La ligne marque le seuil de bridage, jamais atteintPremier nœud56 °C · médiane61 °C · maximumSecond nœud62 °C · médiane67 °C · maximum
Aucun bridage thermique ni électrique sur 180 relevés. À 67 °C au pire et 41 W de puissance GPU par boîtier, un bureau suffit, sans salle climatisée.

Aucun bridage thermique ni électrique sur 180 relevés. Les horloges tiennent autour de 2,45 GHz sur 3,0 GHz de maximum théorique ; l’écart vient de la charge de travail, pas d’une limitation. À 67 °C au pire et 41 W de puissance GPU, un bureau suffit, sans salle climatisée.

Côté réseau, sur la même fenêtre : 5 272 Mio émis sur la première interface, 3 240 Mio sur la seconde, soit environ 112 Mio/s pendant la charge réelle. C’est moins de 1 % d’un lien 200 Gb/s. La latence RDMA mesurée en charge (ib_write_lat, messages de 8 octets, 2 000 itérations) donne 1,86 µs en typique, 2,67 µs au 99ᵉ centile, 3,15 µs au pire.

Pour qui dimensionne, la communication entre les deux boîtiers est donc bornée par la latence, pas par la bande passante. Acheter du lien plus rapide ne rapporterait rien. Le RTT ICMP, lui, ressort à 0,42 ms en moyenne : c’est la pile réseau du noyau, pas le chemin RDMA, et le citer comme latence d’interconnexion serait faux de trois ordres de grandeur.

La qualité du code produit

La vitesse ne vaut rien si le code est faux. Le banc d’essai ne juge donc pas le style, il exécute.

La méthode. Vingt exercices, dix en Python et dix en Go, tirés de problèmes qu’on rencontre vraiment : parsing de montants, ventilation de TVA, échéances de fin de mois, fusion d’intervalles, rapprochement de deux jeux d’écritures, compteurs concurrents, cache LRU. Chaque énoncé part au modèle, le bloc de code produit est extrait, déposé dans un module jetable, et jugé par la machine :

  • en Go, go vet puis go test ; deux exercices passent en plus au détecteur de course ;
  • en Python, un import isolé d’abord, puis des assertions cachées du modèle, exécutées en sous-processus.

Le verdict est mécanique et gradué : réponse tronquée, aucun code exploitable, ne compile pas, compile mais échoue aux tests, juste. Un jury humain n’entre nulle part.

Chaque exercice est tiré cinq fois. À température nulle, le même énoncé ne donne pas toujours le même code : le décodage spéculatif et le routage entre experts rendent le modèle non reproductible. Un score en une passe est un tirage, pas une mesure. Cent tirages, 43 minutes.

Le résultat.

RéussiteCompileTronquéÉcart-type inter-tâche
Python50/50 (100 %)50/5000,00
Go45/50 (90 %)45/5000,10
Total95/100 (95 %)95/10000,09
■ Python■ Goparse_montant5/5ventiler_tva5/5echeance_fin_de_mois5/5merge_intervals5/5cle_tva_fr5/5solde_progressif5/5top_k_deterministe5/5parse_ligne_csv5/5rapprochement5/5cache_lru5/5ParseMontant4/5VentilerTVA4/5Echeance5/5MergeIntervals4/5CompteurConcurrent5/5MapConcurrent5/5TopK5/5ParseLigneCSV5/5RetryContexte4/5Rapprocher4/5
Réussite sur cinq tirages, par exercice, campagne du 1er août 2026. Aucun exercice n’échoue systématiquement : les vingt sont résolus au moins une fois.

Campagne du 1er août 2026. Le même banc rejoué le 2 août sur la configuration finale donne 96/100 (Python 50/50, Go 46/50), et 98/100 sur le bras k=7 écarté par ailleurs. Trois points d’écart sur cent tirages, entre configurations proches : c’est du bruit, pas une hiérarchie. Nous publions les trois plutôt que de retenir le plus flatteur. Le chiffre à retenir pour la configuration livrée est 96/100.

Aucun exercice n’échoue systématiquement : les vingt sont résolus au moins une fois. Les cinq échecs se concentrent sur cinq tâches Go qui passent parfois et pas toujours.

La nature des échecs importe plus que leur nombre. Les cinq sont des erreurs de compilation, jamais un test métier faux. Quatre sur cinq tiennent à un import manquant (fmt, strconv, context) sur un code par ailleurs correct. Le cinquième mélange les types int64 et int sur une même ligne. Le modèle sait donc résoudre le problème et rate parfois la mécanique déclarative de Go. Un passage d’outillage standard avant compilation corrigerait les quatre premiers ; nous ne l’avons pas rejoué sur les sorties fautives, qui n’ont pas été conservées, et l’argument reste à vérifier.

Sur deux boîtiers de bureau, ce modèle produit donc du code exécutable et correct dans 95 % des cas, avec des défauts résiduels que la chaîne de build attrape.

Durée par exercice

Médiane sur cinq tirages, budget 16 000 tokens :

ExerciceLangueRéussiteMédiane
parse_montantPython5/5158,6 s
ventiler_tvaPython5/568,9 s
echeance_fin_de_moisPython5/523,8 s
merge_intervalsPython5/515,3 s
cle_tva_frPython5/59,8 s
solde_progressifPython5/511,2 s
top_k_deterministePython5/510,3 s
parse_ligne_csvPython5/596,9 s
rapprochementPython5/543,8 s
cache_lruPython5/514,7 s
ParseMontantGo4/5127,4 s
VentilerTVAGo4/593,2 s
EcheanceGo5/523,1 s
MergeIntervalsGo4/532,5 s
CompteurConcurrentGo5/512,9 s
MapConcurrentGo5/543,9 s
TopKGo5/514,4 s
ParseLigneCSVGo5/588,6 s
RetryContexteGo4/518,6 s
RapprocherGo4/567,6 s
parse_montant158,6 sParseMontant127,4 sparse_ligne_csv96,9 sVentilerTVA93,2 sParseLigneCSV88,6 sventiler_tva68,9 sRapprocher67,6 sMapConcurrent43,9 srapprochement43,8 sMergeIntervals32,5 secheance_fin_de_mois23,8 sEcheance23,1 sRetryContexte18,6 smerge_intervals15,3 scache_lru14,7 sTopK14,4 sCompteurConcurrent12,9 ssolde_progressif11,2 stop_k_deterministe10,3 scle_tva_fr9,8 s
Le temps suit la longueur du raisonnement, pas la difficulté apparente. En bleu Python, en vert Go.

Un seul modèle pour les petites tâches

Un agent n’appelle pas que son gros modèle. Il classe des documents dans une taxonomie, extrait des entités, étiquette, résume. Ces passes tournaient chez nous sur un petit modèle dédié, un milliard de paramètres servi à côté, sur la seconde machine. Question posée au banc : DeepSeek-V4-Flash peut-il les reprendre toutes ?

Le protocole reprend les prompts, les paramètres d’échantillonnage, les budgets de tokens et le code d’analyse des réponses tels qu’ils tournent en production, sans les adapter au nouveau modèle. En changer un seul ne testerait plus le remplacement envisagé. Documents synthétiques, aucune donnée réelle.

PasseBudgetRésultatLatenceTokens émis
Classement dans une taxonomie fermée de 20 étiquettes64 tokens20/200,4 à 0,5 s2 à 7
Extraction d’entités contrainte par schéma JSON2 048 tokens5/51,2 à 2,1 s56 à 87

Le point de rupture attendu était le budget de 64 tokens. Un modèle qui raisonne avant de répondre peut les dépenser entièrement en réflexion et rendre un contenu vide. Le paramètre de gabarit chat_template_kwargs: {"enable_thinking": false} est honoré par ce modèle, et les réponses de classement font quatre tokens. Nous n’avons pas mesuré la même passe sans ce paramètre. Ce qu’on sait, c’est que l’échec prendrait l’apparence d’un modèle incapable de classer alors qu’il n’aurait pas eu la place de répondre.

Le seul écart de forme sur les vingt documents tient à un bail commercial, rangé en immobilier et en juridique. Les deux étiquettes se défendent, et le code en garde deux.

Ce qui tient à côté du modèle. Retirer le petit modèle libère bien plus que sa taille, parce que --gpu-memory-utilization réserve une fraction du total à l’avance, sans rapport avec le poids réellement chargé. Un vLLM lancé à 0.1 pour un modèle d’un milliard de paramètres réclame 12,2 Gio. Sur une machine où le modèle principal tient déjà 0,85, ça ne rentre pas.

Le serveur d’embeddings, lui, alloue ce qu’il consomme. Mesure de la mémoire disponible avant et après démarrage : 941 Mio pour un modèle de 379 Mio en Q6_K, contexte 8 192. Réservation d’un côté, allocation de l’autre : c’est cette différence qui décide de ce qui peut cohabiter, et aucune fiche technique ne la donne.

Dernier point pour qui empile des services sur une mémoire unifiée : garder de la marge sous le seuil du tueur d’OOM. Configuré avec une préférence sur les processus Python, il désignera le travailleur vLLM comme victime, et sa mort casse le TP=2 sur les deux machines à la fois.

Les pièges qui coûtent une heure chacun

Le cache de préfixe falsifie le prefill. Un appel de chauffe avant la mesure amorce le cache, et on lit 127 000 tok/s de prefill. C’est physiquement impossible et ça n’a rien à voir avec le modèle. Pour mesurer honnêtement : prompts uniques (un horodatage nanoseconde suffit) et max_tokens=1.

pkill -f tue le shell qui le lance. La ligne de commande SSH distante contient le motif. Encadrer la première lettre : pkill -9 -f "[b]in/vllm".

pkill -f "mon_script.sh" détruit le serveur tmux entier. Le serveur tmux hérite de l’argv de la commande qui l’a démarré. Si ce script s’appelle dsv4_run.sh, le motif correspond au serveur lui-même et toutes les sessions meurent d’un coup. Fermer la session par tmux kill-session, puis ne cibler que les binaires.

Ne jamais lancer un processus long par ssh + nohup. Toujours tmux new-session -d puis capture-pane. Et attention au traînard VLLM::Worker qui survit à l’arrêt du serveur.

En bash set -e, un [ cond ] && VAR=x en dernière instruction d’une branche case renvoie 1 quand la condition est fausse et avorte le script. Écrire if ... fi.

cp -n fichier fichier.bak après avoir édité le fichier produit une sauvegarde contaminée. Le -n protège contre l’écrasement d’une sauvegarde existante, il ne remonte pas le temps. Une .bak qui a exactement la même taille que le fichier courant est le symptôme. Sauvegarder avant d’éditer, et vérifier la sauvegarde par un diff ou un grep du motif ajouté, pas par sa seule présence.

Une session tmux new-session -d n’hérite pas de l’environnement virtuel. Elle démarre un shell de connexion propre : le python de la .venv activée dans le terminal courant n’y existe pas, et le banc meurt en une ligne (python : commande introuvable) alors que le serveur, lui, tourne. Appeler l’interpréteur en chemin absolu, ~/.venv-dsv4/bin/python, plutôt que compter sur une activation héritée.

Tous les avertissements du moteur ne sont pas des boutons. Au démarrage, vLLM émet max_num_scheduled_tokens is set to N ... Consider increasing max_num_batched_tokens. Le message se redéclenche à l’identique après avoir doublé max_num_batched_tokens : il compare l’ordonnançable aux créneaux réservés au brouillon, écart qui existe à toute valeur. Vérifier qu’un avertissement se referme avant de le traiter comme une recommandation.

Vérifier un transfert de checkpoint

48 shards, 235 Go, par rsync sur le lien direct avec aes128-gcm et sans compression : 672 Mo/s, 3 min 56. La vérification ne consiste pas à comparer des tailles : on relit l’en-tête de chaque safetensors et on contrôle que 8 + taille_entete + décalage_max == taille_fichier exactement, et qu’aucun tenseur de l’index ne manque. 48 shards, 72 317 tenseurs, zéro écart.

torch.compile sur DeepSeek-V4 NVIDIA : pourquoi il n’y est pas

Une recette concurrente annonce des débits supérieurs aux nôtres en gardant torch.compile actif. Nous avons cherché à savoir si ce chemin nous manquait. Réponse courte : DeepSeek-V4 n’est pas câblé pour torch.compile sur NVIDIA, et c’est un choix, pas un oubli.

Les faits vérifiables :

  • La recette officielle vLLM lance DSv4 avec --compilation-config '{"cudagraph_mode":"FULL_AND_PIECEWISE","custom_ops":["all"]}' et sans --enforce-eager. cudagraph_mode pilote la capture de graphes CUDA, pas la compilation Dynamo. Le modèle amont ne porte pas @support_torch_compile.
  • Le décorateur existe pourtant dans l’arbre, sur la variante XPU du même modèle. Le portage NVIDIA ne l’a pas repris.
  • La recette qui garde la compilation reste épinglée sur vLLM 0.21.1, et le dit explicitement : les kernels MoE B12X et le chemin torch.compile vivent sur cette version-là. Ce n’est pas de la dissimulation, c’est une dette de version assumée.

Entre 0.21 et 0.25, DSv4 a gagné l’indexeur CuTe DSL (18 appels .compile() à l’exécution, répartis sur trois fichiers d’ops) et une orchestration multi-flux (8 sites dans l’attention). Les deux sont intraçables. Le fork a troqué la compilation contre des kernels fusionnés à la main.

Ce que coûte la remise en route, mesuré

Nous avons quand même tenté, parce qu’une boîte noire n’est pas auditable. Cinq patches, appliqués l’un après l’autre, chacun débloquant une couche et en révélant la suivante :

#patchprécédent dans l’arbre
1@support_torch_compile sur DeepseekV4Modeloui (variante XPU)
2six sites MHC passés en torch.ops.vllm.*oui (layers/mhc.py)
3enregistrement de mhc_pre_broadcast_tilelangnon
4réservation du workspace à l’init de la couchepartiel
5mémoïsation de get_device_capability par dictnon

Le point dur à connaître avant de se lancer : fullgraph=True (vllm/compilation/wrapper.py). Sous ce réglage, une rupture de graphe Dynamo n’est pas un coût de performance, c’est une erreur fatale. Toute la famille des solutions « désactiver le traçage sur la fonction gênante » (torch.compiler.disable, dynamo.disable) est donc inopérante : Dynamo répond Skip inlining torch.compiler.disable()d function et s’arrête. Nous avons perdu un boot à le vérifier.

Les blocages rencontrés, dans l’ordre, tous du même genre, du code Python qui inspecte son propre source ou manipule un objet C au moment de l’appel :

  • torch.accelerator.empty_cache() dans la croissance du workspace ;
  • functools._lru_cache_wrapper sur get_device_capability ;
  • le JIT CuTe DSL de l’indexeur (IndexerQFp8Kernel.compile), atteint via l’orchestration multi-flux ;
  • inspect.getsourcelines appelé par TileLang pour décider de son mode JIT, qui retombe sur _patched_getfile, une fonction que Dynamo marque explicitement non traçable.

La parade générique pour le troisième point : rendre l’attention opaque en l’enregistrant comme custom op, sur le patron amont unified_attention_with_output (@eager_break_during_capture, implémentation factice vide, mutates_args=["out"], couche retrouvée par son préfixe dans static_forward_context puisqu’un custom op ne peut pas recevoir de nn.Module). Ça marche : le traçage traverse l’attention sans broncher et va mourir plus loin, sur hc_head_fused_kernel_tilelang : un septième kernel TileLang à enregistrer.

C’est là que nous avons arrêté. Le motif est clair et il est sans fond : chaque kernel fusionné à la main demande son propre op enregistré. Remonter la compilation revient à défaire une par une les fusions qui font la performance du fork.

La conclusion utile

torch.compile n’est pas la source du débit sur DSv4 moderne. L’amont s’en passe, et la recette qui le garde paie une version épinglée pour un résultat qui reste du même ordre. Si vous cherchez du débit sur cette pile, cherchez-le dans les réglages de service, pas dans la compilation.

Ce qu’on n’a pas encore fait

Des recettes publiées annoncent ~83 tok/s en contexte court avec le MoE B12X et un cache KV NVFP4. Notre analyse du code : FlashInfer 0.6.14 embarque déjà le chemin W4A16 SM120 complet : rien à compiler. Deux choses manquent de notre côté :

  • oracle/mxfp4.py n’a aucune entrée B12X (zéro occurrence) ; le routage n’existe que dans oracle/nvfp4.py.
  • FlashInferB12xExperts impose quant_dtype == "nvfp4" par assertion et refuse l’expert-parallel.

Mesurer sans se mentir

Deux règles qui ont servi tout du long :

  • La porte de qualité passe avant le chiffre de performance, jamais après. Et elle exécute le code produit ; un test de mots-clés ne détecte pas un modèle subtilement cassé.
  • Un débit se mesure hors TTFT : (tokens_sortis - 1) / (durée_totale - TTFT), en streaming. Sinon on mélange prefill et décodage et on compare des choses qui ne se comparent pas.

Mesures réalisées du 1er au 3 août 2026 sur deux DGX Spark (GB10, SM121), 121 Go de mémoire unifiée chacune, liées en direct par un lien 200 Gb/s. Harnais de mesure et jeux d’exercices reproductibles : codebench/. Le montage complet des deux voies logicielles, le balayage à un bouton et la matrice des paramètres qui ne paient pas sont dans le rapport détaillé.

Sources

  1. Mesures internes, deux NVIDIA DGX Spark (GB10, SM121), TP=2, 1er au 3 août 2026 : débit, capacité, thermique, RDMA (ib_write_lat), banc de code codebench (selftest 20/20)
  2. jasl/vllm, branche b12x-nvfp4-mxfp4, build 20260721b1.dev0+g48d274954.d20260721.cu132 (journal de démarrage, kv_cache_utils.py, oracle/mxfp4.py, oracle/nvfp4.py)
  3. Checkpoint DeepSeek-V4-Flash-0731 : en-têtes des 48 fichiers safetensors et configuration (index_topk 512, dspark_target_layer_ids, expert_dtype fp4)
  4. Recette officielle vLLM pour DeepSeek-V4 (cudagraph_mode FULL_AND_PIECEWISE, custom_ops all, sans --enforce-eager)
  5. FlashInfer 0.6.14 : chemin W4A16 SM120, prepare_w4a16_packed_weights