backends MoE sur Hopper : marlin, humming, trtllm, cutlass

banc_backends_moe_hopper.py

@@ -0,0 +1,227 @@
+"""Forcer chaque backend MoE NVFP4 sur sm_120, au lieu de subir le choix de vLLM.
+
+Le journal de vLLM affiche :
+
+    Using 'MARLIN' NvFp4 MoE backend out of potential backends:
+    ['FLASHINFER_TRTLLM', 'FLASHINFER_CUTEDSL', 'FLASHINFER_CUTEDSL_BATCHED',
+     'FLASHINFER_CUTLASS', 'VLLM_CUTLASS', 'MARLIN', 'HUMMING', 'EMULATION']
+
+Cette liste est l'ENUMERATION des valeurs possibles, pas la liste des backends
+compatibles avec la carte. vLLM enumere tout, filtre selon la capacite, et
+retient Marlin -- sans jamais dire pourquoi il ecarte les autres.
+
+Or toute la conclusion de la campagne tient en une phrase : « le goulot est la
+dequantification de Marlin, pas la bande passante ». Cette phrase se teste en
+SORTANT de Marlin. On ne l'avait jamais tente, seulement observe passivement.
+
+Chaque backend est donc force explicitement. Trois issues possibles, et les
+trois sont informatives :
+  - il demarre et va plus vite  -> la conclusion Marlin tombe, il faut la reecrire ;
+  - il demarre et va moins vite -> Marlin est bien le meilleur disponible ici ;
+  - il refuse de demarrer       -> on capture la raison exacte, qui manquait.
+
+Contexte reduit a 131 072 volontairement : on compare des backends entre eux
+dans une meme execution, pas a la reference 1 M. Ca divise par plusieurs le
+temps d'allocation du cache et de capture des graphes, donc le cout.
+"""
+import json
+import statistics
+import subprocess
+import threading
+import time
+import urllib.request
+
+MODEL = "nvidia/NVIDIA-Nemotron-3.5-Lightning-30B-A3B-NVFP4"
+PORT = 8000
+URL = "http://127.0.0.1:%d" % PORT
+
+# Liste reduite pour Hopper : quatre essais au lieu de sept, parce que la H200
+# coute 5 $/h et que chaque demarrage vaut ~4 minutes. On garde :
+#   marlin            -- la reference, le seul qui tourne partout ;
+#   humming           -- ce que NVIDIA prescrit pour le DEBIT sur H100 :
+#                        "1x H100 - max throughput (batch) : vLLM, no spec
+#                        decoding (humming backend)". Jamais essaye sur sm_90 ;
+#   flashinfer_trtllm -- refuse sur sm_120 pour "kernel does not support current
+#                        device" : ses noyaux visent sm_100/sm_90, donc ici ils
+#                        devraient passer ;
+#   flashinfer_cutlass-- refuse sur sm_120 pour le SCHEMA de quantification
+#                        (u8 + echelles f8e4m3), pas pour la carte : on saura
+#                        si ce refus est materiel ou lie au depot.
+BACKENDS = ["marlin", "humming", "flashinfer_trtllm", "flashinfer_cutlass"]
+
+
+def dire(*a):
+    print(*a, flush=True)
+
+
+dire("=" * 72)
+subprocess.run(["nvidia-smi", "--query-gpu=name,memory.total,compute_cap",
+                "--format=csv,noheader"], check=False)
+subprocess.run(["python3", "-c",
+                "import vllm,torch;print('vllm',vllm.__version__,'torch',torch.__version__,"
+                "'cap',torch.cuda.get_device_capability(0))"], check=False)
+dire("=" * 72)
+
+BASE = ["vllm", "serve", MODEL,
+        "--served-model-name", "ornith",
+        "--host", "127.0.0.1", "--port", str(PORT),
+        "--trust-remote-code",
+        "--max-model-len", "131072",
+        "--kv-cache-dtype", "fp8",
+        "--enable-prefix-caching",
+        "--gpu-memory-utilization", "0.85",
+        "--mamba-backend", "flashinfer",
+        "--mamba-cache-mode", "align",
+        "--reasoning-parser", "nemotron_v3",
+        "--tool-call-parser", "qwen3_coder",
+        "--enable-auto-tool-choice"]
+
+SUJETS = ["un cache LRU avec dict et liste doublement chainee",
+          "un pool de connexions avec expiration et sante des sockets",
+          "un analyseur d'expressions arithmetiques par descente recursive",
+          "une file de priorite par tas binaire avec decrease-key"]
+
+
+def demarrer(backend, journal):
+    with open(journal, "w") as f:
+        p = subprocess.Popen(BASE + ["--moe-backend", backend],
+                             stdout=f, stderr=subprocess.STDOUT)
+    for i in range(75):
+        try:
+            urllib.request.urlopen(URL + "/v1/models", timeout=5).read()
+            return p, i * 10
+        except Exception:
+            pass
+        if p.poll() is not None:
+            return None, i * 10
+        time.sleep(10)
+    p.terminate()
+    return None, 750
+
+
+def une(sujet, res, i):
+    corps = json.dumps({
+        "model": "ornith",
+        "messages": [{"role": "user",
+                      "content": "Ecris en Python %s, avec trois tests unittest." % sujet}],
+        "max_tokens": 300, "temperature": 0.0, "stream": True}).encode()
+    r = urllib.request.Request(URL + "/v1/chat/completions", data=corps,
+                               headers={"Content-Type": "application/json"})
+    t1 = None
+    n = 0
+    bouts = []
+    try:
+        with urllib.request.urlopen(r, timeout=600) as rep:
+            for l in rep:
+                l = l.strip()
+                if not l.startswith(b"data: ") or l[6:] == b"[DONE]":
+                    continue
+                ch = (json.loads(l[6:]).get("choices") or [{}])[0]
+                de = ch.get("delta", {}) or {}
+                x = de.get("content") or de.get("reasoning") or de.get("reasoning_content")
+                if x:
+                    if t1 is None:
+                        t1 = time.time()
+                    n += 1
+                    bouts.append(x)
+    except Exception as e:
+        res[i] = {"err": "%s: %s" % (type(e).__name__, str(e)[:70])}
+        return
+    res[i] = {"n": n, "t1": t1, "t2": time.time(), "txt": "".join(bouts)}
+
+
+def div4(t):
+    m = t.split()
+    if len(m) < 40:
+        return 1.0
+    g = [tuple(m[i:i + 4]) for i in range(len(m) - 3)]
+    return len(set(g)) / len(g)
+
+
+def mesurer(conc):
+    res = [None] * conc
+    d0 = time.time()
+    fils = [threading.Thread(target=une, args=(SUJETS[i % len(SUJETS)], res, i))
+            for i in range(conc)]
+    for f in fils:
+        f.start()
+    for f in fils:
+        f.join()
+    d1 = time.time()
+    bons = [r for r in res if r and not r.get("err") and r.get("t1")]
+    if not bons:
+        return None, None, None
+    tot = sum(r["n"] for r in bons)
+    pf = statistics.median([(r["n"] - 1) / (r["t2"] - r["t1"])
+                            for r in bons if r["t2"] > r["t1"]])
+    dv = statistics.median([div4(r["txt"]) for r in bons])
+    return tot / (d1 - d0), pf, dv
+
+
+resume = []
+for idx, backend in enumerate(BACKENDS):
+    dire("\n" + "=" * 72)
+    dire("%d. --moe-backend %s" % (idx + 1, backend))
+    dire("=" * 72)
+    journal = "/tmp/moe_%s.log" % backend
+    proc, secondes = demarrer(backend, journal)
+    texte = open(journal, errors="replace").read()
+
+    retenu = None
+    for ligne in texte.splitlines():
+        if "NvFp4 MoE backend" in ligne:
+            retenu = ligne.split("Using")[-1].split("NvFp4")[0].strip().strip("'")
+            dire("   backend effectivement retenu : %s" % retenu)
+            break
+    for motif in ("NvFp4LinearKernel", "GPU KV cache size"):
+        for ligne in texte.splitlines():
+            if motif in ligne:
+                dire("   " + ligne.split("] ")[-1][:150])
+                break
+
+    if not proc:
+        dire("   NE DEMARRE PAS (%d s)" % secondes)
+        # La raison exacte du refus est le vrai produit de cet essai.
+        vu = set()
+        for ligne in texte.splitlines():
+            if any(m in ligne for m in ("RuntimeError", "ValueError", "Traceback",
+                                        "NotImplementedError", "AssertionError",
+                                        "is not supported", "not supported on",
+                                        "Unsupported", "requires", "ImportError",
+                                        "ModuleNotFoundError", "capability")):
+                t = ligne.split("] ")[-1][:170]
+                if t not in vu:
+                    vu.add(t)
+                    dire("   > " + t)
+                if len(vu) >= 6:
+                    break
+        resume.append((backend, retenu, None, None))
+        continue
+
+    dire("   PRET en %d s" % secondes)
+    dire("conc |  agrege  | par flux |  4-gr")
+    solo = None
+    for conc in (1, 4):
+        ag, pf, dv = mesurer(conc)
+        if ag is None:
+            dire("%4d | ECHEC" % conc)
+            continue
+        if conc == 1:
+            solo = pf
+        dire("%4d | %8.1f | %8.1f | %.3f %s"
+             % (conc, ag, pf, dv, "" if dv > 0.6 else "  DEGENERE"))
+    resume.append((backend, retenu, solo, None))
+    proc.terminate()
+    time.sleep(25)
+
+dire("\n" + "=" * 72)
+dire("RESUME -- backends MoE NVFP4 sur cette carte")
+dire("=" * 72)
+dire("%-28s %-14s %10s" % ("demande", "retenu", "solo"))
+for backend, retenu, solo, _ in resume:
+    dire("%-28s %-14s %10s"
+         % (backend, retenu or "-", ("%.1f" % solo) if solo else "ne demarre pas"))
+dire("\nUn backend 'retenu' different du 'demande' signifie que vLLM a ignore le")
+dire("drapeau et refait son propre choix : dans ce cas le chiffre n'est PAS")
+dire("celui du backend demande, et ne prouve rien sur lui.")
+dire("\ncontexte 131 072 ici : comparaison entre backends, pas avec la mesure 1 M.")