# 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: 2026-08-04
- Language: fr
- URL: https://0x0800.com/fr/blog/dsv4-2x-spark-recette/
- Tags: dgx-spark, deepseek-v4, vllm, tp2, inference-locale
- Translation (en): https://0x0800.com/blog/dsv4-2x-spark-recette/


{{< keyfigures >}}
[
  {"label": "Code juste", "value": "96/100", "detail": "jugé par exécution, config livrée"},
  {"label": "Débit mono-flux", "value": "78,55 tok/s", "detail": "code, 512 tokens, hors TTFT"},
  {"label": "Débit agrégé", "value": "188,9 tok/s", "detail": "à seize flux, TTFT sous 0,8 s"},
  {"label": "Cache KV", "value": "1,79 M", "detail": "tokens, lus dans le journal de démarrage"},
  {"label": "Puissance", "value": "41 W", "detail": "puissance GPU par boîtier en pointe, aucun bridage"},
  {"label": "Latence RDMA", "value": "1,86 µs", "detail": "typique en charge, messages de 8 octets"}
]
{{< /keyfigures >}}

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 :

| charge | décodage |
|---|---:|
| **code, 512 tokens de sortie** | **78,55 tok/s** |
| code, 1024 tokens | 75,33 |
| prose, 512 tokens | 47,16 |

{{< hbars title="Débit de décodage par charge, configuration finale" caption="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." minwidth=560 barheight=18 marginleft=210 >}}
{"bars":[
  {"label":"code, 512 tokens de sortie","value":78.55,"text":"78,55 tok/s","color":"accent"},
  {"label":"code, 1024 tokens","value":75.33,"text":"75,33 tok/s","color":"accent"},
  {"label":"prose, 512 tokens","value":47.16,"text":"47,16 tok/s","color":"accent"}]}
{{< /hbars >}}

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.

{{< callout label="Piège de vocabulaire" >}}
Il fait perdre une heure : **MXFP4 et NVFP4 sont deux axes différents**. MXFP4 décrit les poids des experts, NVFP4 apparaît dans les recettes d'autres personnes comme dtype du cache KV. Voir « MXFP4 » quelque part et « NVFP4 » ailleurs n'est pas une contradiction.
{{< /callout >}}

## 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 :

```bash
--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 :

```bash
--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 :

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

Compilation :

```json
{"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 :

```env
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.

```bash
# 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 :

```bash
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 :

```bash
# 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` :

```bash
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 :

```bash
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.

| Configuration | petit | moyen | acceptation |
|---|---:|---:|---:|
| sans spéculation | 17,06 | 16,69 | — |
| référence : PIECEWISE + EP + k=5 | 36,34 | 38,62 | 47,4 % |
| + CUDA graphs FULL_AND_PIECEWISE | 44,08 | 44,84 | 42,1 % |
| sans EP seul (k=5) | 37,65 | 41,00 | 46,1 % |
| CUDA graphs FULL + sans EP + k=5 | 49,99 | 45,72 | 45,6 % |
| **le même + mémoire 0,85** | **47,96** | **53,68** | **50,7 %** |
| k=7 | 38,92 | 42,39 | 29,4 % |
| k=10 | 23,90 | 27,15 | 24,0 % |
| backend MoE triton | ne démarre pas | | |

{{< groupedbars title="Débit par configuration, petit et moyen contexte" caption="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." minwidth=660 marginleft=230 dec=2 >}}
{"series":[{"label":"petit contexte","color":"accent"},{"label":"contexte moyen","color":"signal"}],
 "groups":[
  {"label":"sans spéculation","values":[17.06,16.69],"texts":["17,06","16,69"]},
  {"label":"référence : PIECEWISE + EP + k=5","values":[36.34,38.62],"texts":["36,34","38,62"]},
  {"label":"+ CUDA graphs FULL_AND_PIECEWISE","values":[44.08,44.84],"texts":["44,08","44,84"]},
  {"label":"sans EP seul (k=5)","values":[37.65,41.0],"texts":["37,65","41,00"]},
  {"label":"CUDA graphs FULL + sans EP + k=5","values":[49.99,45.72],"texts":["49,99","45,72"]},
  {"label":"le même + mémoire 0,85","values":[47.96,53.68],"texts":["47,96","53,68"]},
  {"label":"k=7","values":[38.92,42.39],"texts":["38,92","42,39"]},
  {"label":"k=10","values":[23.9,27.15],"texts":["23,90","27,15"]},
  {"label":"backend MoE triton","values":[null,null],"texts":["ne démarre pas"," "]}]}
{{< /groupedbars >}}

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 demande | Débit |
|---|---:|
| Compter de 1 à 300 | 85,4 tok/s |
| Produire 60 objets JSON | 77,9 tok/s |
| Table de multiplication par 12 | 74,4 tok/s |
| Arbre binaire de recherche | 64,1 tok/s |
| Nouvelle de 500 mots | 43,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âche | Débit |
|---|---:|
| Extraction JSON par lots | 78,1 tok/s |
| Extraction JSON unitaire | 54,9 tok/s |
| Traitement documentaire | 54,2 tok/s |
| Écriture de types Go | 50,3 tok/s |
| Écriture d'un handler Go | 46,4 tok/s |

{{< hbars title="Débit selon le contenu généré" caption="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." minwidth=660 headroom=22 barheight=16 marginleft=230 >}}
{"legend":[{"label":"contenus de banc d'essai","color":"accent"},{"label":"contenus de production","color":"signal"}],
 "bars":[
  {"label":"Compter de 1 à 300","value":85.4,"text":"85,4","color":"accent"},
  {"label":"Extraction JSON par lots","value":78.1,"text":"78,1","color":"signal"},
  {"label":"Produire 60 objets JSON","value":77.9,"text":"77,9","color":"accent"},
  {"label":"Table de multiplication par 12","value":74.4,"text":"74,4","color":"accent"},
  {"label":"Arbre binaire de recherche","value":64.1,"text":"64,1","color":"accent"},
  {"label":"Extraction JSON unitaire","value":54.9,"text":"54,9","color":"signal"},
  {"label":"Traitement documentaire","value":54.2,"text":"54,2","color":"signal"},
  {"label":"Écriture de types Go","value":50.3,"text":"50,3","color":"signal"},
  {"label":"Écriture d'un handler Go","value":46.4,"text":"46,4","color":"signal"},
  {"label":"Nouvelle de 500 mots","value":43.8,"text":"43,8","color":"accent"}]}
{{< /hbars >}}

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).

{{< callout label="Attention à la source" >}}
**Le serveur donne deux chiffres qui diffèrent d'un facteur deux.** Sur le même serveur à la même seconde, `/metrics` annonce `kv_cache_size_tokens 877 986` et `kv_cache_max_concurrency 2,23`. Les deux paires sont cohérentes avec elles-mêmes, et pourtant elles ne disent pas la même chose. Le code tranche : la valeur du journal vient de `get_kv_cache_capacity()`, commentée dans `kv_cache_utils.py` par « *Sourcing this from the concurrency calculation handles hybrid layouts correctly* », et ce modèle a précisément une disposition hybride. Indice supplémentaire que la métrique n'est pas à jour : le même bloc `/metrics` affiche `block_size="4"` alors qu'on a lancé avec `--block-size 256`. **Citer le journal de démarrage, pas `/metrics`.** Une version précédente de ce tutoriel publiait le chiffre de `/metrics` ; il était deux fois trop bas, et le tableau ci-dessous avec lui.
{{< /callout >}}

| Contexte par session | Sessions simultanées en mémoire |
|---|---:|
| 384 000 tokens | 4,7 |
| 256 000 | 7,0 |
| 128 000 | 14,0 |
| 32 000 | 56,1 |
| 8 000 | 224,2 |

{{< hbars title="Sessions simultanées selon la taille de contexte" caption="Échelle logarithmique. La mémoire n'est pourtant pas la contrainte : le plafond de requêtes en vol l'est." minwidth=560 barheight=18 scale="log" max=240 marginright=110 >}}
{"bars":[
  {"label":"384 000 tokens","value":4.7,"text":"4,7 sessions","color":"accent"},
  {"label":"256 000","value":7.0,"text":"7,0 sessions","color":"accent"},
  {"label":"128 000","value":14.0,"text":"14,0 sessions","color":"accent"},
  {"label":"32 000","value":56.1,"text":"56,1 sessions","color":"accent"},
  {"label":"8 000","value":224.2,"text":"224,2 sessions","color":"accent"}]}
{{< /hbars >}}

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.

| flux | `seqs=2` | TTFT méd. | `seqs=16` | TTFT méd. |
|---:|---:|---:|---:|---:|
| 1 | 40,05 | 0,23 s | 43,15 | 0,25 s |
| 2 | 63,44 | 0,39 s | 62,80 | 0,35 s |
| 4 | 64,48 | **7,54 s** | **88,11** | 0,32 s |
| 6 | 62,63 | **15,58 s** | **116,51** | 0,51 s |
| 8 | 59,81 | **24,25 s** | **134,30** | 0,44 s |
| 16 | 60,34 | **56,64 s** | **188,88** | **0,75 s** |

{{< linechart title="Débit agrégé selon le nombre de flux" caption="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." minwidth=620 xlabel="flux concurrents" ymax=205 ylabel="tok/s agrégés" >}}
{"xs":[1,2,4,6,8,16],"xticks":[1,2,4,6,8,16],"yticks":[0,50,100,150,200],
 "series":[
  {"label":"seqs=16","points":[43.15,62.8,88.11,116.51,134.3,188.88],"color":"accent"},
  {"label":"seqs=2","points":[40.05,63.44,64.48,62.63,59.81,60.34],"color":"alert"}]}
{{< /linechart >}}

{{< linechart title="Latence au premier token selon le nombre de flux" caption="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." minwidth=620 xlabel="flux concurrents" yscale="log" ymin=0.2 ymax=80 ydec="auto" ylabel="TTFT médian, s" >}}
{"xs":[1,2,4,6,8,16],"xticks":[1,2,4,6,8,16],"yticks":[0.2,1,5,20,80],
 "series":[
  {"label":"seqs=2","points":[0.23,0.39,7.54,15.58,24.25,56.64],"color":"alert"},
  {"label":"seqs=16","points":[0.25,0.35,0.32,0.51,0.44,0.75],"color":"accent"}]}
{{< /linechart >}}

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.

{{< callout label="Ce que nous avions publié avant" >}}
Une version précédente de ce tutoriel concluait qu'au-delà de deux flux on n'achetait que de l'attente. C'était vrai de la configuration mesurée, faux de la machine, car la seule variable disponible était bornée à 2, et le protocole en rafale hétérogène masquait le reste.
{{< /callout >}}

**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ée | TTFT | préremplissage | décodage | acceptation | pas/s |
|---:|---:|---:|---:|---:|---:|
| 4 240 | 2,30 s | 1 846 tok/s | 76,3 | 88,9 % | **14,02** |
| 16 520 | 8,67 s | 1 905 | 71,1 | 82,1 % | **13,92** |
| 32 880 | 18,12 s | 1 814 | 68,3 | 77,8 % | **13,97** |
| 65 680 | 40,16 s | 1 636 | 61,2 | 69,5 % | **13,69** |
| 80 120 | 49,69 s | 1 612 | 79,1 | 93,2 % | **13,97** |
| 100 120 | 63,60 s | 1 574 | 76,3 | 91,1 % | **13,73** |
| 131 200 | 87,28 s | 1 503 | 84,0 | 100,0 % | **14,00** |

{{< linechart title="Débit de décodage et acceptation selon la longueur d'entrée" caption="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 %." minwidth=620 xscale="log" xdiv="k" xdec=0 xlabel="tokens d'entrée" ymin=50 ymax=95 ylabel="décodage, tok/s" rmin=60 rmax=105 rdec=0 runit=" %" rlabel="acceptation" >}}
{"xs":[4240,16520,32880,65680,80120,100120,131200],"xticks":[4240,16520,32880,65680,131200],
 "yticks":[50,60,70,80,90],"rticks":[60,70,80,90,100],
 "series":[
  {"label":"décodage, tok/s","points":[76.3,71.1,68.3,61.2,79.1,76.3,84.0],"color":"accent"},
  {"label":"acceptation, %","points":[88.9,82.1,77.8,69.5,93.2,91.1,100.0],"color":"signal","axis":"right"}]}
{{< /linechart >}}

{{< linechart title="Pas de décodage par seconde selon la longueur d'entrée" caption="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." minwidth=620 xscale="log" xdiv="k" xdec=0 xlabel="tokens d'entrée" ymin=0 ymax=16 ylabel="pas/s" height=266 >}}
{"xs":[4240,16520,32880,65680,80120,100120,131200],"xticks":[4240,16520,32880,65680,131200],
 "yticks":[0,4,8,12,16],
 "band":{"from":13.69,"to":14.02,"label":"amplitude des sept points : 2,4 %"},
 "series":[{"label":"pas par seconde","points":[14.02,13.92,13.97,13.69,13.97,13.73,14.0],"color":"accent"}]}
{{< /linechart >}}

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.**

{{< linechart title="Préremplissage et TTFT selon la longueur d'entrée" caption="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." minwidth=620 xscale="log" xdiv="k" xdec=0 xlabel="tokens d'entrée" ymin=1400 ymax=2000 ydec=0 ylabel="préremplissage, tok/s" rmin=0 rmax=100 rdec=0 runit=" s" rlabel="TTFT" >}}
{"xs":[4240,16520,32880,65680,80120,100120,131200],"xticks":[4240,16520,32880,65680,131200],
 "yticks":[1400,1550,1700,1850,2000],"rticks":[0,25,50,75,100],
 "series":[
  {"label":"préremplissage, tok/s","points":[1846,1905,1814,1636,1612,1574,1503],"color":"accent"},
  {"label":"TTFT, s","points":[2.3,8.67,18.12,40.16,49.69,63.6,87.28],"color":"alert","axis":"right"}]}
{{< /linechart >}}

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.

{{< callout label="Piège de mesure, valable pour tout moteur à décodage spéculatif" >}}
Notre premier balayage faisait varier la longueur en changeant le texte à résumer. Il donnait une chute de 30 % à 131 k, qui tombait pile au-dessus du seuil YaRN du checkpoint (65 536). Une explication très convaincante, et fausse. En changeant le texte, on changeait la prévisibilité de la sortie, donc l'acceptation du brouillon : elle allait de 34 % à 64 %, et le débit suivait. Ajouter des points intermédiaires suffisait à casser la monotonie de la courbe. **Une courbe « débit en fonction de X » n'est interprétable que si X est la seule chose qui varie ; publiez l'acceptation à côté du débit pour qu'on puisse le vérifier.**
{{< /callout >}}

### 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 :

| Tour | Prefill | Tokens retrouvés en cache |
|---|---|---|
| 1, préfixe neuf | 18,1 s | 0 sur 32 818 |
| **2, même fichier, autre question** | **1,0 s** | **32 512 sur 32 819** |
| **3, question du tour 1** | **0,9 s** | **32 512 sur 32 818** |

{{< hbars title="Durée de préremplissage par tour" caption="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." minwidth=520 barheight=18 marginleft=230 >}}
{"bars":[
  {"label":"1, préfixe neuf","value":18.1,"text":"18,1 s","color":"alert"},
  {"label":"2, même fichier, autre question","value":1.0,"text":"1,0 s","color":"signal"},
  {"label":"3, question du tour 1","value":0.9,"text":"0,9 s","color":"signal"}]}
{{< /hbars >}}

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œud | second nœud |
|---|---|---|
| Horloge SM min / méd. / max | 2 411 / 2 457 / 2 496 MHz | 2 411 / 2 483 / 2 509 MHz |
| Puissance | 33 W médians, 35 W max | 40 W médians, 41 W max |
| Température | 56 °C médians, 61 max | 62 °C médians, 67 max |
| Occupation GPU | 96 % | 95 % |
| **Bridage matériel** | **`0x0` sur 90 relevés** | **`0x0` sur 90 relevés** |

{{< thermalchart title="Températures médiane et maximale par nœud" caption="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." minwidth=560 >}}
{"rows":[["Premier nœud",56,61],["Second nœud",62,67]]}
{{< /thermalchart >}}

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éussite | Compile | Tronqué | Écart-type inter-tâche |
|---|---|---|---|---|
| Python | **50/50 (100 %)** | 50/50 | 0 | 0,00 |
| Go | **45/50 (90 %)** | 45/50 | 0 | 0,10 |
| **Total** | **95/100 (95 %)** | **95/100** | **0** | **0,09** |

{{< qualitygrid title="Réussite par exercice, cinq tirages chacun" caption="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." minwidth=640 >}}
{"rows":[
  ["parse_montant","py",5],["ventiler_tva","py",5],["echeance_fin_de_mois","py",5],["merge_intervals","py",5],
  ["cle_tva_fr","py",5],["solde_progressif","py",5],["top_k_deterministe","py",5],["parse_ligne_csv","py",5],
  ["rapprochement","py",5],["cache_lru","py",5],
  ["ParseMontant","go",4],["VentilerTVA","go",4],["Echeance","go",5],["MergeIntervals","go",4],
  ["CompteurConcurrent","go",5],["MapConcurrent","go",5],["TopK","go",5],["ParseLigneCSV","go",5],
  ["RetryContexte","go",4],["Rapprocher","go",4]]}
{{< /qualitygrid >}}

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 :

| Exercice | Langue | Réussite | Médiane |
|---|---|---|---:|
| parse_montant | Python | 5/5 | 158,6 s |
| ventiler_tva | Python | 5/5 | 68,9 s |
| echeance_fin_de_mois | Python | 5/5 | 23,8 s |
| merge_intervals | Python | 5/5 | 15,3 s |
| cle_tva_fr | Python | 5/5 | 9,8 s |
| solde_progressif | Python | 5/5 | 11,2 s |
| top_k_deterministe | Python | 5/5 | 10,3 s |
| parse_ligne_csv | Python | 5/5 | 96,9 s |
| rapprochement | Python | 5/5 | 43,8 s |
| cache_lru | Python | 5/5 | 14,7 s |
| ParseMontant | Go | 4/5 | 127,4 s |
| VentilerTVA | Go | 4/5 | 93,2 s |
| Echeance | Go | 5/5 | 23,1 s |
| MergeIntervals | Go | 4/5 | 32,5 s |
| CompteurConcurrent | Go | 5/5 | 12,9 s |
| MapConcurrent | Go | 5/5 | 43,9 s |
| TopK | Go | 5/5 | 14,4 s |
| ParseLigneCSV | Go | 5/5 | 88,6 s |
| RetryContexte | Go | 4/5 | 18,6 s |
| Rapprocher | Go | 4/5 | 67,6 s |

{{< hbars title="Durée médiane par exercice" caption="Le temps suit la longueur du raisonnement, pas la difficulté apparente. En bleu Python, en vert Go." minwidth=640 headroom=6 >}}
{"bars":[
  {"label":"parse_montant","value":158.6,"text":"158,6 s","color":"accent"},
  {"label":"ParseMontant","value":127.4,"text":"127,4 s","color":"signal"},
  {"label":"parse_ligne_csv","value":96.9,"text":"96,9 s","color":"accent"},
  {"label":"VentilerTVA","value":93.2,"text":"93,2 s","color":"signal"},
  {"label":"ParseLigneCSV","value":88.6,"text":"88,6 s","color":"signal"},
  {"label":"ventiler_tva","value":68.9,"text":"68,9 s","color":"accent"},
  {"label":"Rapprocher","value":67.6,"text":"67,6 s","color":"signal"},
  {"label":"MapConcurrent","value":43.9,"text":"43,9 s","color":"signal"},
  {"label":"rapprochement","value":43.8,"text":"43,8 s","color":"accent"},
  {"label":"MergeIntervals","value":32.5,"text":"32,5 s","color":"signal"},
  {"label":"echeance_fin_de_mois","value":23.8,"text":"23,8 s","color":"accent"},
  {"label":"Echeance","value":23.1,"text":"23,1 s","color":"signal"},
  {"label":"RetryContexte","value":18.6,"text":"18,6 s","color":"signal"},
  {"label":"merge_intervals","value":15.3,"text":"15,3 s","color":"accent"},
  {"label":"cache_lru","value":14.7,"text":"14,7 s","color":"accent"},
  {"label":"TopK","value":14.4,"text":"14,4 s","color":"signal"},
  {"label":"CompteurConcurrent","value":12.9,"text":"12,9 s","color":"signal"},
  {"label":"solde_progressif","value":11.2,"text":"11,2 s","color":"accent"},
  {"label":"top_k_deterministe","value":10.3,"text":"10,3 s","color":"accent"},
  {"label":"cle_tva_fr","value":9.8,"text":"9,8 s","color":"accent"}]}
{{< /hbars >}}

{{< callout label="Le piège du budget de tokens" >}}
DeepSeek-V4-Flash raisonne avant de répondre, et cette trace ne compte pas dans le contenu rendu. Notre première version du harnais accordait 1 600 tokens : l'exercice le plus simple de la suite a rendu un contenu **vide** avec 5 327 caractères de raisonnement. Sur le premier exercice Go, 23 510 caractères de raisonnement avant la première ligne de code. Un budget trop court ne mesure pas un modèle incapable d'écrire ; il mesure un harnais qui coupe avant la réponse. Nous sommes à 16 000, et zéro troncature sur cent tirages.
{{< /callout >}}

## 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.

| Passe | Budget | Résultat | Latence | Tokens émis |
|---|---|---|---|---|
| Classement dans une taxonomie fermée de 20 étiquettes | 64 tokens | 20/20 | 0,4 à 0,5 s | 2 à 7 |
| Extraction d’entités contrainte par schéma JSON | 2 048 tokens | 5/5 | 1,2 à 2,1 s | 56 à 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 :

| # | patch | précédent dans l'arbre |
|---|---|---|
| 1 | `@support_torch_compile` sur `DeepseekV4Model` | oui (variante XPU) |
| 2 | six sites MHC passés en `torch.ops.vllm.*` | oui (`layers/mhc.py`) |
| 3 | enregistrement de `mhc_pre_broadcast_tilelang` | non |
| 4 | réservation du workspace à l'init de la couche | partiel |
| 5 | mémoïsation de `get_device_capability` par dict | non |

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.

{{< callout label="Réserve importante" >}}
`prepare_w4a16_packed_weights` attend un `source_format` `modelopt` ou `compressed_tensors`, alors que notre checkpoint est en MXFP4 natif DeepSeek. Une erreur de mise en page des poids ne plante pas, elle produit du texte plausible et faux. Tout résultat B12X doit donc passer la porte de qualité exécutable avant qu'on en cite le moindre chiffre.
{{< /callout >}}

## 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é](/fr/blog/dsv4-2x-spark-rapport/).



## Sources

- 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)
- 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)
- Checkpoint DeepSeek-V4-Flash-0731 : en-têtes des 48 fichiers safetensors et configuration (index_topk 512, dspark_target_layer_ids, expert_dtype fp4)
- Recette officielle vLLM pour DeepSeek-V4 (cudagraph_mode FULL_AND_PIECEWISE, custom_ops all, sans --enforce-eager)
- FlashInfer 0.6.14 : chemin W4A16 SM120, prepare_w4a16_packed_weights

