SSD Nodes Learn Hosting plans →
Przewodniki Matt ConnorAutor: Matt Connor · Zaktualizowano 2026-10-20

Prefill a decode w LLM: dlaczego pierwszy token trwa

Faza prefill jest ograniczona mocą obliczeniową i wpływa na czas pierwszego tokena. Faza decode zależy od przepustowości pamięci. Zmierz te parametry osobno dla swojego GPU.

Prefill a decode – różnice w jednym akapicie

Rozróżnienie między fazami prefill i decode wyjaśnia większość problemów z opóźnieniami w przypadku samodzielnie hostowanych modeli LLM (large language model). Faza prefill odczytuje cały prompt w jednym przebiegu i jest ograniczona mocą obliczeniową. Faza decode generuje odpowiedź token po tokenie i jest ograniczona przepustowością pamięci. Czas do uzyskania pierwszego tokena (time to first token) zależy od fazy prefill. Liczba tokenów na sekundę (tokens per second) zależy od fazy decode.

Obie fazy działają na tym samym GPU (graphics processing unit), wykorzystują te same wagi i ten sam proces, dlatego naturalne jest traktowanie ich jako jednego obciążenia. W rzeczywistości zachowują się one jak dwa różne programy współdzielące jedno urządzenie. Rozdzielenie tych pojęć sprawia, że lista niejasnych wyników staje się zrozumiała.

Dlaczego obliczenia prefill są ograniczone mocą obliczeniową?

Prefill przepuszcza cały prompt przez każdą warstwę jeden raz. Prompt zawierający 2,000 tokenów przekazuje do każdego mnożenia macierzy 2,000 wierszy pracy, dlatego GPU wykonuje dużo operacji arytmetycznych dla każdego załadowanego bajtu wag. Ten stosunek, czyli liczba operacji arytmetycznych przypadających na przeniesiony bajt, nosi nazwę intensywności arytmetycznej. W fazie prefill jest ona wysoka. Urządzenie działa w pobliżu limitu obliczeniowego, a magistrala pamięci ma niewykorzystaną przepustowość.

Prefill tworzy dwie rzeczy: pamięć podręczną KV (tensory key i value) dla każdego tokenu promptu oraz pierwszy token wyjściowy. Żadna zawartość nie dociera do odbiorcy przed zakończeniem tego przebiegu. Dlatego na bezczynnym serwerze prefill stanowi większość czasu do uzyskania pierwszego tokenu (TTFT). Zgodnie z definicją zawartą w przewodniku firmy NVIDIA dotyczącym testów wydajności TTFT obejmuje również kolejkowanie żądania i opóźnienie sieciowe. Na obciążonym serwerze oczekiwanie w kolejce może więc mieć takie samo znaczenie jak długość promptu.

Koszt prefill rośnie wraz z długością promptu. Część liniowa wynika z pracy wykonywanej przez mnożenia macierzy w poszczególnych warstwach. Część kwadratowa wynika z mechanizmu attention, w którym każdy token uwzględnia wszystkie wcześniejsze tokeny. Zaczyna ona mieć znaczenie przy długim kontekście. Dlatego podwojenie długości promptu co najmniej podwaja część TTFT przypadającą na prefill.

Można to sprawdzić w ciągu jednej minuty. Należy wysłać do serwera prompt zawierający 200 tokenów, a następnie prompt zawierający 2,000 tokenów, za każdym razem żądając takiej samej liczby tokenów wyjściowych. TTFT wyraźnie wzrośnie. Prędkość strumieniowania po otrzymaniu pierwszego tokenu prawie się nie zmieni.

Dlaczego dekodowanie jest ograniczone przepustowością pamięci?

Dekodowanie generuje jeden token w każdym kroku. Aby wygenerować ten pojedynczy token, GPU musi odczytać z pamięci wszystkie wagi modelu, użyć każdej wagi w kilku operacjach, a następnie ją odrzucić. Intensywność obliczeń jest bliska 1, dlatego jednostki obliczeniowe przez większość czasu oczekują.

Dekodowanie jest wolne, ponieważ wygenerowanie każdego tokenu wymaga odczytania całego modelu z pamięci. Tempo wyznacza więc magistrala pamięci, a jednostki obliczeniowe pozostają bezczynne.

Dlatego górne ograniczenie szybkości dekodowania dla pojedynczego strumienia można obliczyć na papierze. Należy podzielić przepustowość pamięci przez rozmiar zajmowany przez wagi.

WykresPublished memory bandwidth and the decode ceiling it implies for a 16 GB model
Dane, na których opiera się ten wykres
[
  {
    "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
  }
]

Kolumna przepustowości zawiera opublikowaną przez danego producenta wartość specyfikacji. Kolumna górnego ograniczenia zawiera wynik dzielenia tej wartości przez 16 GB, czyli rozmiar modelu z 8 miliardami parametrów zapisanych z precyzją 16 bitów. Jest to obliczenie, a nie wynik testu wydajności. Zmierzona szybkość będzie niższa. Warto wiedzieć, o ile niższa, ponieważ wskazuje to, czy należy poprawić stos obsługujący model, czy sprzęt.

Odczytanie kolejno 6 wierszy pokazuje wyraźny wzorzec. CPU z dwukanałową pamięcią DDR5 osiąga około 90 GB/s, co ogranicza szybkość dekodowania tego modelu do około 6 tokenów na sekundę. L40S osiąga około 54. H100 SXM, z opublikowaną przepustowością wynoszącą 3350 GB/s, osiąga około 209.

Z tego samego powodu kwantyzacja jest najsilniejszym pojedynczym sposobem zwiększenia szybkości dekodowania. Zapisanie tych samych wag z użyciem 8 bitów zamiast 16 zmniejsza o połowę liczbę bajtów wag odczytywanych dla każdego tokenu, więc górne ograniczenie szybkości zwiększa się mniej więcej dwukrotnie. Nie jest to jednak rzeczywisty wynik. Pamięć KV cache jest nadal odczytywana zgodnie ze swoim rozmiarem, a niektóre formaty 8-bitowe zwiększają liczbę operacji wykonywanych dla każdego tokenu. Przykładem jest dynamiczna kwantyzacja aktywacji dla każdego tokenu, opisana przez vLLM dla jednego z jego schematów FP8. Z tego powodu zmierzony wzrost szybkości zwykle pozostaje niższy niż 2x. Mechanizm działa z tego samego powodu, z którego zmienia się górne ograniczenie: odczytywana jest mniejsza ilość danych z pamięci.

Jak zmierzyć poszczególne fazy na własnym serwerze?

Ollama zwraca podział w treści odpowiedzi. Należy zażądać odpowiedzi bez streamingu i odczytać liczniki.

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}'

Należy użyć tagu modelu, który został faktycznie pobrany. Dostępne tagi wyświetla ollama list. Wartości prompt_eval_count i prompt_eval_duration dotyczą prefillingu: liczby tokenów promptu oraz czasu poświęconego na jego przetworzenie. eval_count i eval_duration dotyczą dekodowania. Czasy są podawane w nanosekundach, dlatego prędkość dekodowania wynosi eval_count / eval_duration * 1e9, a prędkość prefillingu prompt_eval_count / prompt_eval_duration * 1e9. Z dokumentacji API Ollama wynika, że prompt_eval_duration obejmuje wyłącznie tokeny promptu nieobecne w cache. Dlatego prędkość prefillingu należy obliczać na podstawie promptu, którego serwer nie przetwarzał bezpośrednio wcześniej. Należy oczekiwać, że prędkość prefillingu będzie znacznie wyższa niż prędkość dekodowania w ramach tego samego żądania. Tę różnicę wyjaśniają pozostałe informacje.

W przypadku serwera zgodnego z OpenAI API, takiego jak vLLM, można użyć curl do zmierzenia czasu do odebrania pierwszego bajtu.

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 oznacza moment odebrania pierwszego bajtu treści odpowiedzi, więc razem z "stream": true obejmuje TTFT i ustanowienie połączenia. Należy odjąć time_pretransfer, aby usunąć koszt ustanowienia połączenia. Polecenie należy uruchomić dwa razy i zachować drugi wynik, ponieważ pierwsze wywołanie może obejmować zimne ładowanie modelu.

vLLM udostępnia również ten podział jako metryki Prometheus na /metrics. Po uruchomieniu curl -s http://localhost:8000/metrics | grep -E 'time_to_first_token|inter_token_latency' zostaną zwrócone histogramy vllm:time_to_first_token_seconds i vllm:inter_token_latency_seconds. Należy dodać vllm:num_requests_running i vllm:num_requests_waiting, aby uzyskać informacje o głębokości kolejki, oraz vllm:kv_cache_usage_perc, aby monitorować obciążenie cache. Te pięć nazw wystarcza do zbudowania całego dashboardu.

Pod obciążeniem vllm bench serve --model <name> --num-prompts 200 --request-rate 4 obciąża działający serwer i raportuje czas do pierwszego tokena oraz opóźnienie dla każdego tokena wyjściowego z wartościami percentylowymi. Jest to najbardziej bezpośredni sposób obserwowania wzajemnego wpływu obu faz na już używanym stosie. NVIDIA GenAI-Perf i LLMPerf mierzą te same wartości, jeśli wymagane jest użycie osobnego narzędzia. Przed rozpoczęciem dostrajania należy zebrać czysty punkt odniesienia. Metoda opisana w pomiar tokenów na sekundę w lokalnym LLM zapewnia wynik zachowujący aktualność po restarcie.

Dlaczego długi prompt systemowy opóźnia pierwszy token, ale nie wpływa na szybkość strumieniowania?

Ponieważ prompt systemowy jest przetwarzany w ramach prefill i nie wykonuje się przy nim żadna inna operacja. Jest przetwarzany jeden raz, w tym samym przebiegu co pozostała część promptu, zanim pojawi się pierwszy token. Po zakończeniu tego przebiegu istnieje wyłącznie jako wpisy w pamięci podręcznej KV, a podczas dekodowania są one odczytywane razem z pozostałymi wpisami. Bez buforowania prefiksu prompt systemowy o długości 3,000 tokenów zwiększa więc TTFT przy każdym żądaniu, ale szybkość generowania tokenów na sekundę pozostaje prawie bez zmian.

Prawie, ale nie całkowicie. Te dodatkowe wpisy KV są odczytywane ponownie przy każdym kroku dekodowania, dlatego bardzo długi prompt nieznacznie spowalnia dekodowanie. Zostało to omówione w następnej sekcji.

Rozwiązaniem jest zaprzestanie ponownego obliczania tego samego prefiksu. Serwer z buforowaniem prefiksu przechowuje pamięć podręczną KV współdzielonego prefiksu i wykorzystuje ją ponownie, dzięki czemu drugie żądanie zawierające ten sam prompt systemowy całkowicie pomija tę część prefill. W vLLM funkcja ta nosi nazwę automatic prefix caching. Należy sprawdzić vllm serve --help w używanej wersji, ponieważ wartość domyślna zmieniała się między wydaniami. Ta pamięć podręczna KV w GPU różni się od pamięci podręcznej promptów, za którą dostawca API nalicza opłaty. Przed konfiguracją któregokolwiek z tych mechanizmów warto zapoznać się z różnicą między pamięcią podręczną KV a pamięcią podręczną promptów.

Dlaczego dekodowanie zwalnia wraz ze wzrostem kontekstu?

Są dwie przyczyny. Obie dotyczą pamięci podręcznej KV.

Pierwsza to przepustowość pamięci. Na każdym kroku dekodowania mechanizm attention odczytuje klucze i wartości wszystkich wcześniejszych tokenów. Wagi generują stały koszt dla każdego tokena. Pamięć podręczna KV rośnie wraz z kontekstem. Jej rozmiar można obliczyć na podstawie config.json modelu: liczba bajtów na token wynosi 2 pomnożone przez num_hidden_layers, przez num_key_value_heads, przez wymiar głowy oraz przez liczbę bajtów na element. Należy użyć head_dim, gdy konfiguracja go podaje, a hidden_size podzielonego przez num_attention_heads tylko wtedy, gdy go nie podaje, ponieważ niektóre modele ustawiają te dwie wartości niezależnie. Przykładowo Mistral NeMo ma szerokość 5,120 i 32 głowy, ale wymiar głowy wynosi 128, a nie 160. Początkowa 2 oznacza jeden klucz i jedną wartość.

W typowym układzie modelu z 8 miliardami parametrów, 32 warstwami, 8 głowami kluczy i wartości w ramach GQA (grouped query attention), wymiarem głowy 128 oraz precyzją 16-bitową daje to 2 x 32 x 8 x 128 x 2 = 131,072 bajtów, czyli około 128 KiB na token. Rozmowa obejmująca 8,000 tokenów zajmuje więc około 1 GB pamięci podręcznej KV na żądanie.

Druga przyczyna to pojemność. Tego 1 GB nie można wykorzystać na wagi ani kontekst innego użytkownika. Serwer ustala rozmiar puli KV podczas uruchamiania, w vLLM za pośrednictwem --gpu-memory-utilization, a po zapełnieniu puli nowe żądania oczekują. Wzrost vllm:num_requests_waiting przy vllm:kv_cache_usage_perc utrzymującym się w pobliżu 1 jest dokładnym sygnałem takiego stanu. Niektóre stosy wstrzymują aktywne żądanie i później ponownie obliczają jego pamięć podręczną zamiast umieszczać żądanie w kolejce. Użytkownik odczuwa to jako zatrzymanie strumienia w jego trakcie.

Długi kontekst generuje podwójny koszt: więcej pracy podczas prefill na początku oraz więcej danych odczytywanych z pamięci przy każdym tokenie przez pozostałą część odpowiedzi.

Dlaczego przetwarzanie wsadowe zwiększa przepustowość, ale pogarsza opóźnienia w ogonie rozkładu?

Ponieważ proces dekodowania jest ograniczony przepustowością pamięci, dodatkowe żądania są niemal bezkosztowe pod względem obliczeniowym. Jeden odczyt wag pozwala wygenerować token dla każdej sekwencji wewnątrz wsadu, więc całkowita przepustowość rośnie niemal liniowo wraz z rozmiarem wsadu, dopóki nie wyczerpie się pula KV lub wsad nie stanie się na tyle duży, że ponownie zacznie ograniczać go moc obliczeniowa. Ciągłe przetwarzanie wsadowe (continuous batching) przebudowuje wsad w każdym kroku, dzięki czemu zakończone żądanie jest usuwane, a żądanie z kolejki dołączane bez oczekiwania na pozostałe elementy.

Koszty ujawniają się w percentylach. Kolejny token każdego użytkownika musi teraz czekać na najwolniejszą część wspólnego kroku, więc p50, czyli mediana, pozostaje na akceptowalnym poziomie, podczas gdy p99, czyli najwolniejsze 1 żądanie na 100, ulega wydłużeniu. Wartość p99 jest zauważalna dla użytkowników, ponieważ objawia się jako przerwa w środku zdania.

Faza prefill zaostrza ten problem. Duży prompt przychodzący w trakcie strumieniowania zajmuje urządzenie na jeden długi krok, co powoduje przerwę dla wszystkich użytkowników aktualnie otrzymujących dane. Technika chunked prefill eliminuje większość tego zjawiska poprzez dzielenie długiego promptu na fragmenty i mieszanie każdego z nich z wsadami dekodowania. Według stanu na październik 2026 silnik vLLM V1 wykonuje to domyślnie i udostępnia regulację tego balansu za pomocą --max-num-batched-tokens. Dokumentacja strojenia vLLM jasno określa ten kompromis: mniejsze wartości, w okolicach 2048, zapewniają lepsze opóźnienie między tokenami (ITL), ponieważ mniej operacji prefill przerywa dekodowanie, natomiast większe wartości zapewniają lepszy czas do pierwszego tokena (TTFT), ponieważ więcej tokenów prefill mieści się w jednym wsadzie. Ta pojedyncza flaga stanowi przełącznik między prefill a dekodowaniem, wyrażony jako liczba, którą można dostosować. To, przy jakiej wartości p99 przestaje być akceptowalne, jest kwestią pojemności systemu, a ilu jednoczesnych użytkowników może obsłużyć jeden samodzielnie hostowany LLM analizuje to zagadnienie przy użyciu tych samych metryk.

Dlaczego mocniejszy GPU czasami nie przynosi zmian?

Ponieważ większa moc zazwyczaj oznacza większą wydajność obliczeniową, a proces dekodowania nie jest od niej zależny.

Porównaj dwa wiersze z powyższej tabeli. Karta A100 80GB posiada przepustowość wynoszącą 2039 GB/s, podczas gdy L40S oferuje 864 GB/s. Limit dekodowania podąża za tymi wartościami: odpowiednio 127 tokenów na sekundę wobec 54. RTX 4090 jest pod wieloma względami bardzo szybką kartą, a jej przepustowość 1008 GB/s wyznacza limit na poziomie 63. Niezależnie od innych różnic między kartami, szybkość dekodowania pojedynczego strumienia jest ściśle powiązana z przepustowością pamięci podaną w specyfikacji.

Istnieją zatem dwa sposoby na przyspieszenie dekodowania: odczytywanie mniejszej liczby bajtów na token (poprzez kwantyzację wag lub uruchomienie mniejszego modelu) albo zwiększenie przepustowości. W przypadku fazy prefill sytuacja jest odwrotna. Wymaga ona mocy obliczeniowej, więc szybsza karta faktycznie skraca czas TTFT przy długich promptach. Jeśli problemem jest długi czas oczekiwania na pierwszy token, lepszy sprzęt może go rozwiązać. Jeśli jednak tekst generowany jest zbyt wolno, wymiana sprzętu prawdopodobnie nie przyniesie poprawy.

Czy należy uruchamiać prefill i decode na oddzielnych procesach roboczych?

Duże stosy serwujące wykonują dokładnie to zadanie, a technika ta nazywana jest dezagregacją prefill i decode. Jedna pula procesów roboczych obsługuje wyłącznie prefill, a druga wyłącznie decode, przy czym pamięć podręczna KV utworzona przez pierwszą pulę jest przesyłana do drugiej za pośrednictwem szybkiego połączenia. Rozwiązanie to sprawdza się, ponieważ obie fazy wymagają odmiennego sprzętu i innego planowania zadań. Prefill wymaga dużej mocy obliczeniowej i przetwarzania dużych partii tokenów. Decode wymaga wysokiej przepustowości i obsługi wielu jednoczesnych sekwencji. Rozdzielenie tych faz pozwala na niezależne skalowanie każdej puli i zapobiega sytuacji, w której jeden ogromny prompt blokuje wszystkie aktywne strumienie.

Na pojedynczym VPS (virtual private server) z jedną jednostką GPU takie rozwiązanie prawie nigdy nie jest opłacalne. Prowadziłoby to do rywalizacji jednego urządzenia z samym sobą i zamiany wskaźnika na transfer sieciowy gigabajtów pamięci podręcznej. Technika ta przynosi korzyści dopiero wtedy, gdy dostępna jest wystarczająca liczba akceleratorów, aby dedykować całe maszyny do każdej z faz, oraz gdy występuje stały ruch pozwalający na obciążenie obu pul. Poniżej tego progu, chunked prefill zapewnia większość tych samych korzyści w zakresie izolacji przy użyciu jednej flagi.

Co zmienić, gdy wyniki są niezadowalające

Gdy TTFT jest zbyt wysokie:

  • Skróć prompt. Koszt prefill zależy od liczby tokenów promptu, a bez cache'owania prefiksu prompt systemowy jest przetwarzany przy każdym żądaniu.
  • Włącz cache'owanie prefiksu, aby powtarzany prefiks był obliczany tylko raz, a nie przy każdym żądaniu.
  • Zwiększ --max-num-batched-tokens, aby więcej pracy prefill przypadało na jeden krok.
  • Sprawdź kolejkę, zanim obwinisz model. Wartość vllm:num_requests_waiting większa od zera oznacza, że przetwarzanie żądania jeszcze się nie rozpoczęło, co wskazuje na problem z przepustowością.

Gdy liczba tokenów na sekundę jest zbyt mała:

  • Zastosuj kwantyzację wag. Mniejsza liczba bajtów przypadających na wagę oznacza mniej bajtów odczytywanych dla każdego tokenu.
  • Porównaj opublikowaną przepustowość pamięci karty z wykresem powyżej i sprawdź, jak blisko osiągnięto limit.
  • Zmniejsz --max-num-batched-tokens, aby operacje prefill rzadziej przerywały dekodowanie.
  • Sprawdź długość kontekstu. Rozmowa, która rozrosła się do tysięcy tokenów, wymaga odczytu znacznie większej pamięci podręcznej KV w każdym kroku.

Znaczenie ma również środowisko uruchomieniowe, ponieważ Ollama i vLLM inaczej planują operacje prefill i dekodowanie, a ustawienie korzystne dla jednego z nich może nie dać żadnego efektu w drugim. Najpierw wykonaj pomiary w obu fazach, a następnie zmieniaj jedną rzecz naraz.

FAQ

Dlaczego pierwszy token pojawia się po kilku sekundach, a pozostałe są generowane szybko?

To oczekiwanie wynika z fazy prefill, a generowanie strumieniowe z fazy decode. Prefill przetwarza cały prompt w jednym przebiegu ograniczonym mocą obliczeniową, zanim powstanie jakikolwiek wynik, dlatego jego koszt rośnie wraz z długością promptu. Następnie decode generuje jeden token na krok z szybkością zależną od przepustowości pamięci, która jest prawie niezależna od długości promptu. Najczęstszą przyczyną jest długi system prompt dołączany do każdego żądania. Cache prefiksów eliminuje powtarzającą się część tego kosztu.

Czy dłuższy prompt zmniejsza liczbę tokenów na sekundę?

Nieznacznie, ale z innego powodu niż TTFT. Każdy krok decode odczytuje klucze i wartości wszystkich wcześniejszych tokenów, dlatego większy cache KV oznacza więcej bajtów odczytywanych dla każdego tokenu. W typowym układzie z 8 miliardami parametrów cache zajmuje około 128 KiB na token, więc kontekst o długości 8,000 tokenów oznacza około 1 GB danych odczytywanych przy każdym kroku. Większy wpływ długiego promptu dotyczy nadal TTFT, a nie szybkości generowania strumieniowego.

Która specyfikacja GPU pozwala przewidzieć szybkość fazy decode?

Przepustowość pamięci. Po podzieleniu podanej przepustowości przez rozmiar wag w pamięci otrzymuje się teoretyczne ograniczenie dla jednego strumienia. Karta z większą mocą obliczeniową, ale taką samą przepustowością pamięci, nie będzie generować strumienia szybciej. Z tego samego powodu kwantyzacja wag do 8 bitów zwiększa teoretyczne ograniczenie fazy decode mniej więcej dwukrotnie: zmniejsza o połowę liczbę bajtów wag odczytywanych dla każdego tokenu. Zmierzony zysk jest zwykle mniejszy, ponieważ cache KV jest nadal odczytywany w swoim pełnym rozmiarze, a niektóre formaty 8-bitowe wymagają dodatkowych operacji dla każdego tokenu, takich jak kwantyzacja aktywacji.

Dlaczego przepustowość rośnie po dodaniu użytkowników, ale każdy użytkownik odczuwa większe opóźnienie?

Jeden odczyt wag obsługuje token dla każdej sekwencji w batchu, dlatego łączna liczba tokenów na sekundę rośnie wraz z rozmiarem batchu. Każdy pojedynczy token musi teraz czekać na wspólny krok, więc jednocześnie rośnie opóźnienie poszczególnych użytkowników. Należy monitorować opóźnienie między tokenami p99, a nie zagregowaną przepustowość, oraz sprawdzić vllm:num_requests_waiting, aby ustalić, czy żądania oczekują w kolejce, zamiast być przetwarzane.

Czy ten artykuł był przydatny?