Aller au contenu
Multi-utilisateurs

Multi-utilisateurs : servir 5 à 10 personnes sur une seule machine

Pourquoi une machine à 256 Go/s est bornée en génération, ce que le batching et les MoE y changent, ce que les mesures publiées disent, et ce qu'il reste à mesurer avant de promettre un nombre d'utilisateurs.

À vérifier#multi-utilisateurs#kv-cache#llama-cpp#strix-halo#benchmarkPublié le 16 sept. 2026Mis à jour le 16 sept. 2026Vérifié le 16 sept. 2026À revérifier le 15 déc. 2026

L'essentiel

  • La Box vise 5 à 10 comptes, dont 1 à 3 actifs au même instant (Q-001, hypothèse à vérifier chez le client).
  • En génération, une machine à mémoire unifiée est bornée par sa bande passante : environ 256 Go/s théoriques, 212 Go/s mesurés. Le débit maximal d'un utilisateur seul ≈ bande passante ÷ octets de poids lus par token.
  • Servir plusieurs utilisateurs coûte moins que N fois une requête : les poids sont lus une fois par pas pour tous les slots. Le débit agrégé monte, le débit par utilisateur baisse.
  • Les MoE (peu de paramètres actifs) sont dix fois plus rapides qu'un dense de taille comparable sur cette machine : c'est le levier principal.
  • Une seule courbe de montée en charge est publiée sur cette puce (Qwen3.6-35B-A3B : 59 t/s à 1 slot, 162 t/s agrégés à 8). Rien sur gpt-oss-120b ni sur un 70B dense. Tout le reste est à mesurer.

Le problème posé

Un cabinet de 5 à 10 personnes partage une machine. À un instant donné, une à trois personnes attendent une réponse : une question courte (« résume cette clause »), une analyse de dossier de 50 pages, un brouillon de courrier. Chacune veut voir le premier mot arriver vite (TTFT) puis le texte défiler à une vitesse de lecture confortable (environ 10 à 15 tokens par seconde suffisent à un lecteur humain ; hypothèse de confort, non sourcée). Le serveur, lui, doit maximiser le débit total sans laisser un utilisateur bloqué derrière un long traitement.

Notions

NotionDéfinitionPourquoi ça compte pour la Box
Requêtes simultanéesnombre de générations en cours au même instant1 à 3 attendues, 5 à 10 en pointe théorique
Prompt processing (prefill)lecture du prompt et des documents : opération matrice-matrice, limitée par le calcul 2c'est ce qui détermine le TTFT sur un long dossier
Génération (decode)production token par token : opération matrice-vecteur, limitée par la mémoire 2c'est ce qui détermine la vitesse de défilement
TTFTdélai avant le premier token 5objectif de confort à fixer (voir dimensionnement)
TPOT / ITLtemps par token de sortie, intervalle entre tokens 5inverse du débit perçu par un utilisateur
Tokens/s par utilisateur vs agrégésdébit vu par une personne vs somme sur tous les slots 3ne jamais confondre les deux dans un benchmark
Continuous batchingordonnancement par itération : une séquence terminée libère sa place immédiatement 4activé par défaut dans llama-server 1
Slotséquence servie en parallèle par llama-server (-np)fixe le nombre maximal de requêtes simultanées
File d'attenterequêtes au-delà des slots, servies dans l'ordrepas de priorité documentée dans llama-server ni Ollama
Contexte partagéavec --kv-unified, un seul buffer KV réparti entre les slots selon l'usage réelsouplesse quand les requêtes ont des longueurs très différentes
KV cachemémoire des clés et valeurs d'attention de chaque token du contextecroît avec le contexte × le nombre de slots ; voir KV cache
p50 / p95médiane et 95e percentile d'une latencepromettre un p95, pas une moyenne

Pourquoi une machine à 256 Go/s est bornée en génération

À chaque token généré, le GPU doit relire l'ensemble des poids actifs du modèle depuis la mémoire, plus le KV cache. Databricks formalise cela par le MBU : bande passante atteinte = (taille des poids + KV) ÷ TPOT 3. En inversant, pour un utilisateur seul :

débit max (t/s) ≈ bande passante (Go/s) ÷ octets lus par token (Go)

Applications numériques avec 212 Go/s mesurés 7 (la valeur AMD de 256 Go/s est théorique 6). Toutes les lignes sont des estimations (poids seuls, sans KV) comparées aux mesures publiées.

ModèleOctets lus par tokenPlafond estiméMesures publiées
Llama 3.3 70B Q4_K_M (42,5 Go de poids 8)42,5 Go≈ 5,0 t/s4,7 à 5,1 t/s 16 17 11 : borné par la mémoire
gpt-oss-120b MXFP4 (59 Go au total, 5,1 Md actifs 9)≈ 3 à 4 Go (experts actifs + attention + embeddings)≈ 50 à 70 t/s51 à 56 t/s 14 11
Qwen3-30B-A3B Q4_K_M (18,6 Go, 3,3 Md actifs 10)≈ 2 Goau-delà de 100 t/s72 à 98 t/s

Le dense de 70 Md est exactement à son plafond. Les MoE sont en dessous du leur : d'autres facteurs (calcul de l'attention, routage des experts, échantillonnage CPU 15) interviennent. Retenir : sur cette machine, le nombre de paramètres actifs commande la vitesse, pas le nombre total.

L'avantage des MoE

gpt-oss-120b et Llama 3.3 70B occupent une mémoire comparable (59 vs 42,5 Go). Le premier génère dix fois plus vite parce qu'il n'active que 5,1 Md de paramètres par token. Pour le multi-utilisateurs, cela signifie qu'un MoE de 120 Md laisse de la marge de débit à partager entre les slots, là où un dense de 70 Md n'en a aucune : à 5 t/s par utilisateur au mieux, il est inutilisable en conversation.

Effet du nombre de slots

En génération memory-bound, ajouter des slots coûte peu : les poids sont lus une fois par pas pour toutes les séquences ; seul le KV cache de chaque slot s'ajoute. Le débit agrégé monte donc presque linéairement au début, puis sature quand le calcul (ou l'échantillonnage) devient le goulot. Le prefill, lui, est compute-bound : un long dossier soumis par un utilisateur occupe le GPU et allonge le TTFT de tous.

Mesures publiées sur Strix Halo :

llama-server, Qwen3.6-35B-A3B UD-Q4_K_M, Vulkan RADV b9010 11 (communauté, Beelink GTR9 Pro) :

-npt/s par utilisateuragrégéTTFT
159,259,20,117 s
432,7130,80,237 s
820,3162,00,307 s
1610,4166,00,547 s

L'auteur retient -np 8 comme point d'équilibre (2,7 fois le débit mono). Au-delà, l'agrégé ne monte plus et chaque utilisateur descend sous 10 t/s.

Autres points : environ 45 t/s mono et environ 168 t/s agrégés sur 16 slots en HIP (mars 2026, modèle non précisé dans le résumé) 12 ; Vulkan +6,7 % en agrégé à 2 clients sur des modèles 122B 14 ; vLLM 86,6 → 246,5 → 311,6 t/s agrégés à 1/4/8 clients sur un 0,8B, contre 81,7 → 138,0 → 207,1 pour llama.cpp 13.

Matrice de capacité

La matrice ci-dessous est alimentée uniquement par la collection benchmarks : chaque cellule affiche la meilleure mesure enregistrée pour ce nombre d'utilisateurs simultanés et cette classe de modèle, avec son origine (indépendant, communauté, nôtre). Les cellules « à tester » ne sont pas inventées : elles signalent l'absence de mesure. Les colonnes 2, 3, 5 et 10 utilisateurs resteront vides tant que nos propres mesures ne seront pas faites ; les publications utilisent 1, 4, 8 et 16 slots.

Utilisateurs simultanésPetit modèle≤ 15 Md paramètres totauxModèle moyen15 à 40 MdGros modèle> 40 Md (dense ou MoE)
1à tester97,7 tok/sQwen3-Coder-30B-A3B Q4_K_SBenchmark indépendant55,6 tok/sgpt-oss-120b MXFP4Communauté
2à testerà testerà tester
3à testerà testerà tester
5à testerà testerà tester
10à testerà testerà tester

Hypothèses de dimensionnement

Utilisateurs actifsPetit modèle (≤ 15 Md, ex. gpt-oss-20b)Modèle moyen MoE (15 à 40 Md, ex. Qwen3-30B-A3B)Gros MoE (ex. gpt-oss-120b)Gros dense (ex. Llama 70B)
1au-delà de 60 t/s (estimation)60 à 98 t/s (mesuré)51 à 56 t/s (mesuré)5 t/s (mesuré)
2confortable (hypothèse)≈ 45 t/s par utilisateur (interpolation)à tester ; hypothèse : 35 à 45 t/s≈ 4 à 5 t/s par utilisateur (hypothèse)
3confortable (hypothèse)≈ 38 t/s par utilisateur (interpolation)à tester ; hypothèse : 30 à 40 t/sinutilisable en conversation
5confortable (hypothèse)≈ 28 t/s par utilisateur (interpolation)à tester ; hypothèse : 20 à 30 t/sinutilisable
10à tester≈ 17 t/s par utilisateur (interpolation entre 8 et 16 slots)à tester ; hypothèse : 10 à 20 t/sinutilisable

Hypothèse de fond pour gpt-oss-120b : avec 5,1 Md actifs, sa courbe devrait ressembler à celle du 35B-A3B (3 Md actifs) décalée vers le bas ; c'est précisément ce que doit vérifier l'expérimentation de montée en charge. Le TTFT sur longs prompts n'apparaît pas dans ce tableau : il dépend du prefill (300 à 1 400 t/s selon modèle et backend) et de la longueur du dossier, voir Dimensionnement.

Questions ouvertes

Ce qu'il reste à tester

Sources

  1. 1llama.cpp — README de llama-server (tools/server)GitHubFiabilité hauteggml-org · publié 2026 (master) · consulté le 16 sept. 2026 · fiche source
  2. 2NVIDIA — Mastering LLM Techniques: Inference OptimizationArticle techniqueFiabilité hauteNVIDIA · S. Verma, N. Vaidya · publié 2023-11-17 · consulté le 16 sept. 2026 · fiche source
  3. 3Databricks — LLM Inference Performance Engineering: Best PracticesArticle techniqueFiabilité hauteDatabricks (Mosaic) · publié 2023-10-12 · consulté le 16 sept. 2026 · fiche source
  4. 4Anyscale — How continuous batching enables 23x throughput in LLM inferenceArticle techniqueFiabilité hauteAnyscale · publié 2023-06-22 · consulté le 16 sept. 2026 · fiche source
  5. 5Anyscale — Understand LLM latency and throughput metricsDocumentation officielleFiabilité hauteAnyscale · publié 2026 · consulté le 16 sept. 2026 · fiche source
  6. 6AMD Ryzen AI Max+ 395 — page produitConstructeur / éditeurFiabilité hauteAMD · publié s.d. · consulté le 16 sept. 2026 · fiche source
  7. 7AMD Strix Halo (Ryzen AI Max+ 395) GPU Performance (llm-tracker)BenchmarkFiabilité hautellm-tracker.info · lhl · publié 2025-05-17 · consulté le 16 sept. 2026 · fiche source
  8. 8bartowski/Llama-3.3-70B-Instruct-GGUFAutreFiabilité moyennebartowski · publié 2024-12 · consulté le 16 sept. 2026 · fiche source
  9. 9openai/gpt-oss-120b — fiche modèleDocumentation officielleFiabilité hauteOpenAI · publié 2025-08-05 · consulté le 16 sept. 2026 · fiche source
  10. 10Qwen/Qwen3-30B-A3B-Instruct-2507 — fiche modèleDocumentation officielleFiabilité hauteAlibaba Qwen · publié 2025-07 · consulté le 16 sept. 2026 · fiche source
  11. 11strix-halo-guide (README + BENCHMARKS.md)GitHubFiabilité moyenneGitHub (communauté) · hogeheer499 · publié 2026-03 → 2026-08-30 · consulté le 16 sept. 2026 · fiche source
  12. 12llama.cpp discussion #20856 — Known-Good Strix Halo ROCm + llama.cpp StackGitHubFiabilité moyenneGitHub ggml-org (communauté) · realugbun · publié 2026-03-22 (màj 2026-07-23) · consulté le 16 sept. 2026 · fiche source
  13. 13Soothill — SGLang vs vLLM vs llama.cpp on Strix HaloBenchmarkFiabilité hautesoothill.io · Darren Soothill · publié 2026-08-10 · consulté le 16 sept. 2026 · fiche source
  14. 14Running 122B-Parameter LLMs Locally on AMD Strix Halo (Pellegrini, LinkedIn)BenchmarkFiabilité moyenneLinkedIn (article personnel) · Pellegrini · publié 2026 · consulté le 16 sept. 2026 · fiche source
  15. 15Discussion llama.cpp #18308 — paramètres optimaux pour l'inférence parallèleForumFiabilité moyenneggml-org (discussion) · publié 2025-12 · consulté le 16 sept. 2026 · fiche source
  16. 16Strix Halo (Ryzen AI Max+ 395) LLM Benchmark Results (Level1Techs, lhl)BenchmarkFiabilité moyenneLevel1Techs Forums · lhl · publié 2025-07-22 (màj 2025-08-31) · consulté le 16 sept. 2026 · fiche source
  17. 17praveentechworld — AMD Strix Halo Local LLM Benchmarks: 128GB Unified Memory GuideBlogFiabilité faiblepraveentechworld.com · Praveen · publié 2026-09-09 · consulté le 16 sept. 2026 · fiche source
content/docs/multi-user/index.md1562 mots