Die zentrale Frage bei einem MoE-Modell, das nicht ins VRAM passt: wo verläuft die Grenze zwischen GPU und RAM? Dieses Dokument beschreibt die Methode und zeigt, was sie auf dem Referenzsystem gebracht hat.
Ein dichtes Modell muss für jedes Token alle Gewichte lesen. Ein Mixture-of-Experts liest nur die aktiven. Bei Qwen3.6-35B-A3B sind das 3 von 35 Milliarden Parametern — und genau deshalb ist es auf einer 8-GB-Karte benutzbar, während ein dichtes 27-B-Modell auf derselben Karte bei ~4 Token/s festhängt.
Die Aufteilung:
-ngl 99 legt von allen Layern die Nicht-Experten-Teile (Attention,
Embeddings, Norms) plus den KV-Cache ins VRAM-ncmoe N lässt die Expert-Gewichte der ersten N Layer im RAM, gerechnet
von der CPUBeides arbeitet gleichzeitig. Pro Token wandern die Aktivierungen zwischen GPU und CPU hin und her.
detect.py macht das automatisch, aber die Logik sollte man kennen:
freies VRAM
− Nicht-Experten-Gewichte
− KV-Cache (ctx × Layer × 2 × KV-Heads × head_dim × 2 Byte)
− Reserve für Compute-Puffer
────────────────────────────
÷ Bytes pro Expert-Layer = Layer, die auf die GPU passen
Der naheliegende Weg — expert_count × 3 × embedding × ffn_length × Bits/8 — geht
bei modernen Quantisierungen daneben. Dynamische Quants (unsloth „UD”, i-Quants)
geben verschiedenen Tensoren verschiedene Bitbreiten: Experten weniger,
Attention und Embeddings mehr. Auf dem Referenzsystem lag diese Rechnung um Faktor
zwei daneben.
Richtig ist, die Tensor-Tabelle im GGUF-Header auszuwerten. Dort steht jeder
Tensor mit Name, Typ und Datei-Offset. Die Differenz zweier aufeinanderfolgender
Offsets ist die exakte Größe — unabhängig vom Quant-Typ, auch für Typen, die es
beim Schreiben dieses Textes noch nicht gab. detect.py summiert alle Tensoren,
deren Name auf _exps endet, gruppiert nach Layer.
Gegenprobe auf dem Referenzsystem: Summe aller Tensoren 17,72 GB gegen 17,73 GB Dateigröße.
Modell Qwen3.6-35B-A3B-UD-IQ4_XS, 40 Layer, 256 Experten, 8 aktiv, GQA 16:2.
| Experten gesamt | 14,12 GiB |
| Nicht-Experten | 2,38 GiB |
| pro Expert-Layer | 361,6 MiB |
| KV-Cache bei 16k Kontext | 640 MiB |
Der KV-Cache ist dank GQA 8:1 winzig — 40 KB pro Token. Kontext ist bei diesem Modell also billig; das Verdoppeln auf 32k kostet nur 640 MiB.
-ncmoe 99 (alles CPU) |
-ncmoe 34 (6 Layer GPU) |
|
|---|---|---|
| VRAM belegt | 5132 MiB | 6733 MiB |
| Decode | 15,9 t/s | 19,4 t/s |
| Prefill (warm, langer Prompt) | 160 t/s | 180–306 t/s |
Sechs von vierzig Layern auf der GPU bringen 22 % beim Decoding und knapp das Doppelte beim Prefill. Der Grund für den überproportionalen Prefill-Gewinn: der ist compute-bound, und die GPU rechnet Matrixmultiplikationen um Größenordnungen schneller als acht CPU-Kerne.
Warum der Prefill eine Spanne ist und keine Zahl. Er hängt davon ab, wie viele Modellseiten schon im RAM liegen und wie lang der Prompt ist. Innerhalb einer einzigen Sitzung gemessen:
| Aufruf | Prompt | Prefill |
|---|---|---|
| erster, kalt | 81 Token | 6,1 t/s |
| dritter | 4 Token | 25,7 t/s |
| später | 1826 Token | 90,2 t/s |
| später | 1134 Token | 243,3 t/s |
Wer eine einzelne Zahl nennt, hat einen Ausschnitt davon gemessen. Das Decoding ist dagegen über dieselbe Sitzung stabil bei 29–30 t/s.
Kurze Prompts sehen dabei langsamer aus als lange, weil der feste Aufwand pro Anfrage sich auf wenige Token verteilt. Für die Frage „wie lange warte ich auf einen 16k-Prompt” ist nur der Wert bei langen Prompts aussagekräftig.
Falls detect.py nicht passt, geht es auch empirisch:
-ncmoe 99 starten — läuft garantiert, alles auf der CPUnvidia-smi ansehen, wie viel VRAM frei bleibtWichtig: vor dem Messen alle anderen GPU-Verbraucher schließen. Ein Browser belegt schnell 2 GB VRAM, und dann misst man dessen Schwankungen statt des Modells.
-np 1 — ein Slotllama-server legt standardmäßig mehrere Slots an. Jeder hat einen eigenen
Prefix-Cache. Für einen sequenziellen Client bedeutet das: jeder Aufruf landet in
einem anderen Slot und der System-Prompt wird jedes Mal neu prefillt.
Mit -np 1 bleibt alles in einem Cache. Für interaktive Nutzung ist das die
wichtigste einzelne Einstellung. Für Batch-Durchsatz ist das Gegenteil richtig:
mehrere parallele Anfragen lasten die Expert-Matmuls besser aus. Zwei Profile
anlegen, eines je Zweck.
-lm — Lademodus und SSD-VerschleißSSD-Verschleiß entsteht durch Schreiben, nicht durch Lesen. Ein Modell zu laden ist reines Lesen und kostet keine Lebensdauer.
| Modus | Verhalten |
|---|---|
mmap (Default) |
Modellseiten sind dateigebunden und sauber. Unter Speicherdruck werden sie verworfen und neu gelesen. Kein Verschleiß, aber langsamer Prefill bei RAM-Mangel. |
mmap+mlock |
wie mmap, zusätzlich resident gepinnt. Keine Verdrängung, keine Re-Reads. Das Optimum — wenn genug RAM frei ist. |
none |
anonymer Speicher. Bei RAM-Mangel landet das Modell im Pagefile — echte Schreibvorgänge. Nur bei viel freiem RAM. |
Auf dem Referenzsystem war der allererste Prefill 6 t/s statt der 243, die
dieselbe Sitzung wenig später zeigte. Ursache
war nicht die CPU, sondern Paging: die mmap-Seiten wurden unter Speicherdruck
laufend verdrängt und neu von SSD gelesen. Der Fix ist nicht -lm none, sondern
RAM freimachen.
-c kostet KV-Cache im VRAM, und der geht direkt von den Expert-Layern ab. Bei
GQA-Modellen ist er klein genug, dass man großzügig sein kann. Bei Modellen ohne
GQA (KV-Heads = Attention-Heads) ist er 8-fach größer und die Rechnung fällt anders
aus — detect.py zeigt den Wert an.
Prompt-Kompaktierung in Agent-Schleifen. Bei append-only Verlauf und einem Slot trägt der Prefix-Cache den gesamten Kontext; pro Schritt werden nur die neuen Tokens prefillt. Jede Operation, die die Historie umschreibt — Compaction, Timestamps im System-Prompt, nachträgliches Trimmen — wirft den Cache weg und erzwingt vollen Re-Prefill. Bei 8k Kontext sind das rund 50 Sekunden pro Schritt statt 5.