Prefill vs. Decode: Warum Token eins langsamer ist
Prefill ist rechengebunden und bestimmt die Zeit bis zum ersten Token. Decode ist speicherbandbreitengebunden und bestimmt Token pro Sekunde. Messen Sie beide Werte getrennt.
Prefill vs. Decode in einem Absatz
Prefill vs. Decode ist die zentrale Unterscheidung, die die meisten Latenzfragen zu einem selbst gehosteten LLM (Large Language Model) erklärt. Prefill liest den gesamten Prompt in einem Durchlauf und ist durch die Rechenleistung begrenzt. Decode schreibt die Antwort Token für Token und ist durch die Speicherbandbreite begrenzt. Die Zeit bis zum ersten Token ist ein Prefill-Wert. Die Token pro Sekunde sind ein Decode-Wert.
Beide Phasen laufen auf derselben GPU (Graphics Processing Unit), mit denselben Gewichten und innerhalb desselben Prozesses. Daher liegt es nahe, sie als eine einzige Workload zu betrachten. Tatsächlich verhalten sie sich wie zwei verschiedene Programme, die sich ein Gerät teilen. Wenn Sie sie getrennt betrachten, sind viele zunächst verwirrende Ergebnisse nicht mehr verwirrend.
Warum ist Prefill durch die Rechenleistung begrenzt?
Beim Prefill wird der gesamte Prompt einmal durch jede Schicht verarbeitet. Ein Prompt mit 2,000 Tokens erzeugt für jede Matrixmultiplikation 2,000 Zeilen Arbeit. Dadurch führt die GPU für jedes geladene Byte an Gewichten viele Rechenoperationen aus. Dieses Verhältnis aus Rechenoperationen und übertragenen Bytes wird als arithmetische Intensität bezeichnet. Beim Prefill ist sie hoch. Das Gerät arbeitet nahe an seiner Rechenleistungsgrenze, während der Speicherbus noch Kapazität hat.
Prefill erzeugt zwei Dinge: den KV-Cache (die Key- und Value-Tensoren) für jedes Prompt-Token und das erste Ausgabetoken. Vor dem Abschluss dieses Durchlaufs erreicht nichts den Leser. Deshalb entfällt auf einem nicht ausgelasteten Server der größte Teil der Zeit bis zum ersten Token (TTFT) auf den Prefill. Die von NVIDIA im Benchmarking-Leitfaden definierte TTFT umfasst auch die Anforderungswarteschlange und die Netzwerklatenz. Auf einem ausgelasteten Server kann die Wartezeit in der Warteschlange daher genauso wichtig sein wie der Prompt.
Die Kosten des Prefill steigen mit der Prompt-Länge. Der lineare Anteil entfällt auf die Matrixberechnungen pro Schicht. Der quadratische Anteil entfällt auf die Attention. Dabei berücksichtigt jedes Token jedes frühere Token. Bei langen Kontexten wird dieser Anteil relevant. Wenn Sie den Prompt verdoppeln, verdoppelt sich der Prefill-Anteil der TTFT daher mindestens.
Sie können das innerhalb einer Minute beobachten. Senden Sie Ihrem Server zunächst einen Prompt mit 200 Tokens und danach einen Prompt mit 2,000 Tokens. Fordern Sie in beiden Fällen dieselbe Anzahl an Ausgabetokens an. Die TTFT steigt deutlich. Die Streaming-Geschwindigkeit nach dem ersten Token verändert sich kaum.
Warum ist Decode durch die Speicherbandbreite begrenzt?
Decode erzeugt pro Schritt genau ein Token. Für dieses einzelne Token muss die GPU alle Gewichte des Modells aus dem Speicher lesen, jedes Gewicht für einige Operationen verwenden und anschließend verwerfen. Die arithmetische Intensität liegt nahe 1. Daher warten die Recheneinheiten die meiste Zeit.
Decode ist langsam, weil für jedes Token das gesamte Modell aus dem Speicher gelesen werden muss. Dadurch gibt der Speicherbus das Tempo vor, während die Recheneinheiten untätig sind.
Damit lässt sich die Obergrenze für die Decode-Geschwindigkeit eines einzelnen Datenstroms rechnerisch bestimmen. Teilen Sie die Speicherbandbreite durch den Speicherbedarf der Gewichte.
Die Daten hinter diesem Diagramm
[
{
"device": "CPU, dual channel DDR5-5600",
"mem_bandwidth_gb_s": 90,
"decode_ceiling_tok_s": 6
},
{
"device": "NVIDIA A10G",
"mem_bandwidth_gb_s": 600,
"decode_ceiling_tok_s": 38
},
{
"device": "NVIDIA L40S",
"mem_bandwidth_gb_s": 864,
"decode_ceiling_tok_s": 54
},
{
"device": "NVIDIA RTX 4090",
"mem_bandwidth_gb_s": 1008,
"decode_ceiling_tok_s": 63
},
{
"device": "NVIDIA A100 80GB SXM",
"mem_bandwidth_gb_s": 2039,
"decode_ceiling_tok_s": 127
},
{
"device": "NVIDIA H100 SXM",
"mem_bandwidth_gb_s": 3350,
"decode_ceiling_tok_s": 209
}
]Die Spalte „Bandbreite“ enthält den von jedem Hersteller veröffentlichten Spezifikationswert. Die Spalte „Obergrenze“ ergibt sich aus diesem Wert geteilt durch 16 GB, der Größe eines Modells mit 8 Milliarden Parametern bei einer Speicherung mit 16 Bit. Das ist eine Berechnung und kein Benchmark-Ergebnis. Ihre gemessene Rate wird darunter liegen. Zu wissen, wie groß der Abstand ist, ist hilfreich, weil Sie dadurch erkennen, ob Sie Ihren Serving-Stack oder Ihre Hardware anpassen müssen.
Lesen Sie die 6 Zeilen der Reihe nach. Das Muster ist eindeutig. Eine CPU mit zweikanaligem DDR5 erreicht etwa 90 GB/s. Damit ist Decode für dieses Modell auf ungefähr 6 Token pro Sekunde begrenzt. Eine L40S erreicht ungefähr 54. Eine H100 SXM mit einer veröffentlichten Bandbreite von 3350 GB/s liegt bei ungefähr 209.
Das erklärt auch, warum Quantisierung der stärkste einzelne Hebel für die Decode-Geschwindigkeit ist. Wenn Sie dieselben Gewichte statt mit 16 Bit mit 8 Bit speichern, halbiert sich die Zahl der pro Token gelesenen Gewicht-Bytes. Dadurch verdoppelt sich die Obergrenze ungefähr. Die Obergrenze entspricht jedoch nicht dem tatsächlichen Ergebnis. Der KV-Cache wird weiterhin entsprechend seiner eigenen Größe gelesen. Außerdem verursachen einige 8-Bit-Formate zusätzliche Arbeit pro Token, beispielsweise die dynamische Aktivierungsquantisierung pro Token, die vLLM für eines seiner FP8-Schemata dokumentiert. Daher liegt der gemessene Zugewinn meist unter 2x. Der Hebel funktioniert aus demselben Grund, aus dem sich die Obergrenze verschiebt: Es werden weniger Daten aus dem Speicher gelesen.
Wie messe ich jede Phase auf meinem eigenen Server?
Ollama gibt die Aufteilung im Response-Body zurück. Fordern Sie eine nicht gestreamte Completion an und lesen Sie die Zähler aus.
curl -s http://localhost:11434/api/generate -d '{
"model": "llama3.2",
"prompt": "Explain memory bandwidth in two sentences.",
"stream": false
}' | jq '{prompt_eval_count, prompt_eval_duration, eval_count, eval_duration}'Verwenden Sie einen Modell-Tag, den Sie tatsächlich heruntergeladen haben. ollama list zeigt Ihnen die verfügbaren Tags. prompt_eval_count und prompt_eval_duration beziehen sich auf das Prefill: die Anzahl der Prompt-Tokens und die dafür benötigte Zeit. eval_count und eval_duration beziehen sich auf das Decoding. Die Dauer wird in Nanosekunden angegeben. Daher beträgt die Decoding-Geschwindigkeit eval_count / eval_duration * 1e9 und die Prefill-Geschwindigkeit prompt_eval_count / prompt_eval_duration * 1e9. Laut der Ollama-API-Referenz umfasst prompt_eval_duration nur nicht gecachte Prompt-Tokens. Ermitteln Sie die Prefill-Rate daher mit einem Prompt, den der Server nicht gerade erst verarbeitet hat. Die Prefill-Rate ist bei derselben Anfrage voraussichtlich deutlich höher als die Decoding-Rate. Diese Differenz erklärt alle weiteren Punkte.
Bei einem OpenAI-kompatiblen Server wie vLLM kann curl die Zeit bis zum ersten Byte für Sie messen.
curl -N -s -o /dev/null \
-w 'pretransfer %{time_pretransfer}s first_byte %{time_starttransfer}s\n' \
http://localhost:8000/v1/completions \
-H 'Content-Type: application/json' \
-d '{"model": "meta-llama/Llama-3.1-8B-Instruct", "prompt": "Explain memory bandwidth.", "max_tokens": 128, "stream": true}'time_starttransfer bezeichnet den Zeitpunkt, zu dem das erste Byte des Bodys eingetroffen ist. Zusammen mit "stream": true ist das die TTFT plus der Verbindungsaufbau. Ziehen Sie time_pretransfer ab, um die Kosten des Verbindungsaufbaus zu entfernen. Führen Sie den Test zweimal aus und verwenden Sie das zweite Ergebnis, da der erste Aufruf das Laden eines noch nicht im Speicher befindlichen Modells enthalten kann.
vLLM veröffentlicht die Aufteilung außerdem als Prometheus-Metriken unter /metrics. Mit curl -s http://localhost:8000/metrics | grep -E 'time_to_first_token|inter_token_latency' erhalten Sie die Histogramme vllm:time_to_first_token_seconds und vllm:inter_token_latency_seconds. Ergänzen Sie vllm:num_requests_running und vllm:num_requests_waiting für die Warteschlangentiefe sowie vllm:kv_cache_usage_perc für die Cache-Auslastung. Diese fünf Namen bilden das vollständige Dashboard.
Unter Last belastet vllm bench serve --model <name> --num-prompts 200 --request-rate 4 den laufenden Server und meldet die Zeit bis zum ersten Token sowie die Latenz pro ausgegebenem Token mit Perzentilen. Das ist die direkteste Methode, um zu sehen, wie die beiden Phasen auf Ihrem bestehenden Stack miteinander konkurrieren. NVIDIA's GenAI-Perf und LLMPerf messen dieselben Werte, wenn Sie ein separates Tool bevorzugen. Erstellen Sie vor jeder Optimierung eine saubere Baseline. Die Methode unter Tokens pro Sekunde bei einem lokalen LLM messen liefert einen Messwert, der auch nach einem Reboot Bestand hat.
Warum verzögert ein langer System-Prompt das erste Token, aber nicht die Streaming-Geschwindigkeit?
Der System-Prompt verursacht ausschließlich Prefill-Arbeit. Er wird einmal zusammen mit dem restlichen Prompt verarbeitet, bevor das erste Token erscheint. Danach liegt er nur noch als KV-Cache-Einträge vor, die der Decode-Schritt zusammen mit allen anderen Einträgen liest. Ohne Prefix-Caching erhöht ein System-Prompt mit 3,000 Tokens daher bei jeder einzelnen Anfrage die TTFT, während die Tokens pro Sekunde nahezu unverändert bleiben.
Nahezu, aber nicht vollständig. Diese zusätzlichen KV-Einträge werden bei jedem Decode-Schritt erneut gelesen. Ein sehr langer Prompt verlangsamt den Decode-Schritt daher geringfügig. Der nächste Abschnitt behandelt diesen Effekt.
Die Lösung besteht darin, dasselbe Prefix nicht erneut zu berechnen. Ein Server mit Prefix-Caching behält den KV-Cache eines gemeinsamen Prefixes und verwendet ihn wieder. Die zweite Anfrage mit demselben System-Prompt überspringt dadurch diesen Teil des Prefill-Schritts vollständig. vLLM bezeichnet dies als automatisches Prefix-Caching. Prüfen Sie vllm serve --help für Ihre Version, da sich der Standardwert zwischen Releases geändert hat. Dieser KV-Cache im GPU-Speicher ist etwas anderes als der Prompt-Cache, den ein API-Anbieter abrechnet. Der Unterschied zwischen einem KV-Cache und einem Prompt-Cache ist lesenswert, bevor Sie einen der beiden optimieren.
Warum wird der Decode-Vorgang langsamer, wenn der Kontext wächst?
Dafür gibt es zwei Gründe. Beide betreffen den KV-Cache.
Der erste Grund ist die Speicherbandbreite. Bei jedem Decode-Schritt liest die Attention die Keys und Values aller vorherigen Tokens. Die Gewichte verursachen pro Token einen festen Aufwand. Der KV-Cache wächst dagegen mit jedem Token. Seine Größe lässt sich aus dem config.json des Modells berechnen: Die Bytezahl pro Token entspricht 2 multipliziert mit num_hidden_layers, mit num_key_value_heads, mit der Head-Dimension und mit der Bytezahl pro Element. Verwenden Sie head_dim, wenn die Konfiguration diesen Wert angibt. Verwenden Sie hidden_size geteilt durch num_attention_heads nur dann, wenn der Wert nicht angegeben ist, da manche Modelle beide Werte unabhängig voneinander setzen. Mistral NeMo hat beispielsweise eine Breite von 5,120 und 32 Heads, aber eine Head-Dimension von 128 und nicht von 160. Die führende 2 steht für jeweils einen Key und einen Value.
Bei einer üblichen Konfiguration mit 8 Milliarden Parametern, 32 Layern, 8 Key-Value-Heads unter GQA (Grouped Query Attention), einer Head-Dimension von 128 und 16-Bit-Präzision ergibt sich: 2 x 32 x 8 x 128 x 2 = 131,072 Byte, also etwa 128 KiB pro Token. Eine Unterhaltung mit 8,000 Tokens belegt daher ungefähr 1 GB KV-Cache pro Anfrage.
Der zweite Grund ist die Kapazität. Dieser 1 GB große Speicherbereich kann weder Gewichte noch den Kontext eines anderen Benutzers aufnehmen. Der Server legt die Größe seines KV-Pools einmal beim Start fest, bei vLLM über --gpu-memory-utilization. Wenn der Pool vollständig belegt ist, warten neue Anfragen. Wenn vllm:num_requests_waiting steigt, während vllm:kv_cache_usage_perc nahe bei 1 bleibt, ist das das eindeutige Anzeichen für diesen Zustand. Manche Stacks unterbrechen eine laufende Anfrage und berechnen ihren Cache später erneut, anstatt sie in die Warteschlange einzureihen. Für den Benutzer zeigt sich das als Unterbrechung mitten im Stream.
Ein langer Kontext kostet Sie doppelt: zunächst mehr Prefill-Arbeit und anschließend bei jedem weiteren Token mehr Speicherzugriffe.
Warum verbessert Batching den Durchsatz und verschlechtert die Tail-Latenz?
Da Decode bandbreitenbegrenzt ist, verursachen zusätzliche Anfragen auf der Compute-Seite kaum Mehrkosten. Ein Lesen der Gewichte kann für jede Sequenz im Batch ein Token erzeugen. Dadurch steigt der Gesamtdurchsatz mit der Batch-Größe nahezu linear, bis entweder der KV-Pool erschöpft ist oder der Batch so groß wird, dass die Verarbeitung wieder Compute-bound ist. Continuous Batching erstellt den Batch bei jedem Schritt neu. Eine abgeschlossene Anfrage verlässt ihn, und eine wartende Anfrage kommt hinzu, ohne auf die anderen Anfragen zu warten.
Die Kosten zeigen sich in den Perzentilen. Das nächste Token jedes Benutzers wartet nun auf den langsamsten Teil eines gemeinsam genutzten Schritts. Dadurch bleibt p50, der Median, akzeptabel, während sich p99, die langsamste 1 von 100 Anfragen, verlängert. p99 nehmen Benutzer wahr, weil es die Pause mitten in einem Satz ist.
Prefill verstärkt diesen Effekt. Wenn während des laufenden Betriebs ein großer Prompt eintrifft, belegt er das Gerät für einen langen Schritt. Alle aktuell laufenden Sequenzen sehen dadurch eine Unterbrechung. Chunked Prefill reduziert diesen Effekt weitgehend, indem ein langer Prompt in Abschnitte geteilt und jeder Abschnitt in die Decode-Batches eingemischt wird. Seit October 2026 führt die vLLM V1 Engine dies standardmäßig aus und stellt das Verhältnis über --max-num-batched-tokens ein. Die vLLM-Tuning-Dokumentation beschreibt den Zielkonflikt eindeutig: Kleinere Werte um 2048 verbessern die Inter-Token-Latenz (ITL), weil weniger Prefills die Decodes unterbrechen. Größere Werte verbessern TTFT, weil mehr Prefill-Tokens in einen Batch passen. Dieses einzelne Flag stellt das Verhältnis zwischen Prefill und Decode als einen einstellbaren Zahlenwert bereit. Ab welchem Punkt p99 nicht mehr akzeptabel ist, hängt von der Kapazität ab. Wie viele gleichzeitige Benutzer ein selbst gehostetes LLM bedienen kann lässt sich anhand derselben Metriken bestimmen.
Warum ändert eine größere GPU manchmal nichts?
Weil „größer“ in der Regel mehr Rechenleistung bedeutet. Für Decode ist jedoch nicht die Rechenleistung der begrenzende Faktor.
Vergleichen Sie zwei Zeilen der obigen Tabelle. Die A100 80GB erreicht eine angegebene Speicherbandbreite von 2039 GB/s. Die L40S erreicht 864 GB/s. Die Decode-Obergrenze folgt genau diesem Verhältnis: 127 Tokens pro Sekunde gegenüber 54. Die RTX 4090 ist nach den meisten Maßstäben eine sehr schnelle Karte. Mit 1008 GB/s liegt ihre Obergrenze bei 63. Unabhängig von weiteren Unterschieden zwischen zwei Karten folgt Single-Stream-Decode der Speicherbandbreite im Datenblatt.
Es gibt daher zwei Möglichkeiten, Decode zu beschleunigen: Lesen Sie pro Token weniger Bytes, indem Sie die Gewichte quantisieren oder ein kleineres Modell verwenden, oder kaufen Sie mehr Speicherbandbreite. Prefill ist der umgekehrte Fall. Prefill benötigt Rechenleistung. Eine schnellere Karte verkürzt daher die TTFT bei langen Prompts tatsächlich. Wenn das Problem darin besteht, dass das erste Token vier Sekunden benötigt, kann bessere Hardware helfen. Wenn der Text jedoch langsam ausgegeben wird, hilft sie wahrscheinlich nicht.
Sollten Prefill und Decode auf getrennten Workern ausgeführt werden?
Große Serving-Stacks nutzen genau diesen Ansatz; die Technik wird als Prefill- und Decode-Disaggregation bezeichnet. Ein Pool von Workern führt ausschließlich Prefill aus, ein zweiter Pool nur Decode. Der vom ersten Pool erstellte KV-Cache wird über eine schnelle Verbindung an den zweiten übertragen. Das Verfahren funktioniert, weil die Phasen unterschiedliche Anforderungen an Hardware und Scheduling stellen. Prefill benötigt Rechenleistung und große Token-Batches. Decode benötigt Bandbreite und eine hohe Anzahl gleichzeitiger Sequenzen. Durch die Trennung lässt sich jeder Pool individuell skalieren, zudem verhindert es, dass ein einzelner, sehr großer Prompt alle aktiven Streams blockiert.
Auf einem einzelnen VPS (Virtual Private Server) mit nur einer GPU lohnt sich dies fast nie. Sie würden ein einzelnes Gerät gegen sich selbst ausspielen und einen Zeiger in einen Netzwerktransfer von Gigabytes an Cache verwandeln. Die Technik zahlt sich erst aus, wenn Sie über genügend Beschleuniger verfügen, um ganze Maschinen für die jeweilige Phase zu reservieren, und wenn das Verkehrsaufkommen konstant genug ist, um beide Pools auszulasten. Unterhalb dieser Schwelle bietet Chunked Prefill mit einem einzigen Flag einen Großteil der gleichen Isolation.
Was Sie bei schlechten Messwerten ändern sollten
Wenn TTFT zu hoch ist:
- Kürzen Sie den Prompt. Die Prefill-Kosten folgen der Anzahl der Prompt-Tokens. Ohne Prefix-Caching wird der System-Prompt bei jeder Anfrage erneut verarbeitet.
- Aktivieren Sie Prefix-Caching, damit ein wiederholtes Präfix nur einmal statt bei jeder Anfrage berechnet wird.
- Erhöhen Sie
--max-num-batched-tokens, damit mehr Prefill-Arbeit in jedem Schritt verarbeitet wird. - Prüfen Sie die Warteschlange, bevor Sie das Modell verantwortlich machen. Ein Wert von
vllm:num_requests_waitingüber 0 bedeutet, dass die Anfrage noch nicht gestartet wurde. Das ist ein Kapazitätsproblem.
Wenn die Tokenrate pro Sekunde zu niedrig ist:
- Quantisieren Sie die Gewichte. Weniger Bytes pro Gewicht bedeuten weniger gelesene Bytes pro Token.
- Vergleichen Sie die angegebene Speicherbandbreite Ihrer Karte mit der obigen Tabelle und prüfen Sie, wie nahe Sie an der Obergrenze liegen.
- Verringern Sie
--max-num-batched-tokens, damit Prefill die Decode-Phase seltener unterbricht. - Prüfen Sie die Kontextlänge. Bei einer auf Tausende von Tokens angewachsenen Konversation wird bei jedem Schritt ein deutlich größerer KV-Cache gelesen.
Auch die Runtime ist hier relevant, weil Ollama und vLLM Prefill und Decode unterschiedlich planen und eine Einstellung, die bei einer Runtime hilft, bei der anderen wirkungslos sein kann. Messen Sie zuerst beide Phasen. Ändern Sie anschließend jeweils nur eine Einstellung.
FAQ
Warum benötigt mein erstes Token Sekunden, während die übrigen schnell gestreamt werden?
Die Wartezeit entsteht beim Prefill, das Streaming beim Decode. Beim Prefill wird der gesamte Prompt in einem rechengebundenen Durchlauf verarbeitet, bevor eine Ausgabe vorhanden ist. Die Kosten steigen daher mit der Prompt-Länge. Beim Decode wird anschließend in jedem Schritt ein Token ausgegeben. Die Geschwindigkeit wird dabei durch die Speicherbandbreite bestimmt und hängt kaum von der Prompt-Länge ab. Ein langer System-Prompt bei jeder Anfrage ist die häufigste Ursache. Prefix-Caching vermeidet die wiederholte Verarbeitung dieses Teils.
Verlangsamt ein längerer Prompt die Token-Rate?
Ein wenig, und aus einem anderen Grund als bei TTFT. Bei jedem Decode-Schritt werden die Keys und Values aller vorherigen Tokens gelesen. Ein größerer KV-Cache bedeutet daher mehr gelesene Bytes pro Token. Bei einer üblichen Konfiguration mit 8 Milliarden Parametern ist der Cache etwa 128 KiB pro Token groß. Bei einem Kontext mit 8,000 Tokens werden somit bei jedem Schritt ungefähr 1 GB gelesen. Die größere Auswirkung eines langen Prompts betrifft weiterhin TTFT, nicht die Streaming-Geschwindigkeit.
Welche GPU-Spezifikation sagt die Decode-Geschwindigkeit voraus?
Die Speicherbandbreite. Teilen Sie die angegebene Bandbreite durch die Größe der im Speicher befindlichen Gewichte. Das Ergebnis ist die rechnerische Obergrenze für einen Stream. Eine Karte mit mehr Rechenleistung, aber derselben Bandbreite streamt nicht schneller. Deshalb verdoppelt die Quantisierung der Gewichte auf 8 Bit die Decode-Obergrenze ungefähr: Pro Token müssen halb so viele Gewichte gelesen werden. Der tatsächlich gemessene Zugewinn ist meist kleiner. Der KV-Cache wird weiterhin in seiner ursprünglichen Größe gelesen. Außerdem verursachen einige 8-Bit-Formate zusätzliche Arbeit pro Token, beispielsweise durch die Quantisierung von Aktivierungen.
Warum steigt der Durchsatz, wenn ich weitere Benutzer hinzufüge, während sich jede Anfrage langsamer anfühlt?
Ein einmaliges Lesen der Gewichte verarbeitet ein Token für jede Sequenz im Batch. Deshalb steigt der Gesamtdurchsatz in Tokens pro Sekunde mit der Batch-Größe. Jedes einzelne Token wartet nun auf einen gemeinsamen Verarbeitungsschritt. Dadurch steigt gleichzeitig die Latenz pro Benutzer. Überwachen Sie die p99-Latenz zwischen Tokens und nicht nur den aggregierten Durchsatz. Prüfen Sie außerdem vllm:num_requests_waiting, um festzustellen, ob sich Anfragen in der Warteschlange befinden, statt verarbeitet zu werden.