Kalkulator LLM na GPU
Ten kalkulator LLM na GPU śledzi prompt wysłany do dużego modelu językowego (LLM) na karcie graficznej (GPU), aż do ukończenia odpowiedzi, w sześciu krokach, i sprawdza, czy model i jego rozmowy mieszczą się w pamięci karty (VRAM). Model i karta przyjmuje dane modelu i karty, Pamięć mieści rozmowy użytkowników obok wag i pamięci roboczej oprogramowania serwującego, Przetwarzanie promptu podaje czas do pierwszego tokenu odpowiedzi, Szybkość dla jednego użytkownika liczbę tokenów na sekundę, która potem następuje, Szybkość dla wielu użytkowników to samo, gdy karta pisze kilka odpowiedzi naraz, a Od promptu do odpowiedzi pokazuje odpowiedź każdego użytkownika tak, jak pojawia się w kolejności ustalonej przez oprogramowanie serwujące.
Token to słowo albo część słowa. Model językowy czyta rozmowę i pisze odpowiedź po jednym tokenie, więc liczba tokenów na sekundę (tok./s) decyduje o tym, jak szybko pojawia się odpowiedź.
Kalkulator obejmuje model Qwen3.8-27B z wagami w 4 lub 8 bitach, Arete-27B w 4 bitach i Bielik-11B-v3.0 w 8 lub 16 bitach na karcie GeForce RTX 3080, 3090, 4080, 5070, 5080 lub 5090, A100 80GB PCIe, H100 NVL lub H200 NVL albo na twojej własnej.
Jego szacunki pochodzą z kart katalogowych, plików modeli i kodu oprogramowania serwującego, a szacunki praktyczne z tego, co osiągnęły kroki samego vLLM na dwóch kartach, GeForce RTX 3090 i RTX 5090, oraz jego jądra 8-bitowe na H200 NVL. Część Porównanie z pomiarami zestawia wyniki z wynikami vLLM na tych trzech kartach, z błędem w każdym punkcie. Pozostałe karty i modele są szacowane bez porównania, a strona zaznacza to przy ich wynikach.
Wyniki możesz pobrać jako PNG albo skopiować jako tekst na końcu strony.
Przykład obliczeń
Kalkulator otwiera się z modelem Qwen3.8-27B, którego wagi zapisano w 4 bitach każda (NVFP4), na jednej karcie GeForce RTX 5090, dla jednego użytkownika z rozmową o długości 4096 tokenów i pamięcią podręczną w 8 bitach. Wagi zajmują 21,07 GB z 33,85 GB, z których mogą korzystać programy na karcie. Oprogramowanie serwujące, vLLM, może użyć 92% tej pamięci, 31,14 GB, i potrzebuje z tego 2,547 GB na własną pracę, co zostawia 7,521 GB na rozmowy: 217 952 tokenów dla jednego użytkownika, tak jak liczy je vLLM, mniej niż najdłuższa rozmowa, którą przyjmuje model, 262 144 tokeny. W praktyce, przy tym, co vLLM zajął przy starcie na zmierzonych kartach, zostaje od 6,281 do 7,150 GB, od 180 320 do 206 976 tokenów.
Każdy nowy token uruchamia 821 jąder, odczytuje 17,61 GB wag oraz odczytuje i zapisuje 0,4615 GB dla użytkownika: stały stan, aktywacje i pamięć podręczną. Przy 92% przepustowości karty wynoszącej 1792 GB/s wagi zajmują 10,68 ms, a bajty użytkownika 0,2799 ms, a jądra potrzebują 0,7292 ms na start i dotarcie do pamięci, więc jeden użytkownik otrzymuje 85,55 tokenu na sekundę. Sama przepustowość pozwoliłaby na 99,17. W praktyce, z wartościami zmierzonymi w krokach samego vLLM, jeden użytkownik otrzymuje od 66,74 do 74,21.
Przed pierwszym tokenem odpowiedzi karta przetwarza prompt o długości 3584 tokenów w 3 fragmentach po najwyżej 1568 tokenów. Ich mnożenia macierzy zajmują 206,8 ms przy wydajnościach rdzeni tensorowych, uwaga pełna 14,19 ms, uwaga liniowa 8,487 ms, a odczyt i zapis małych jąder 63,07 ms; silnik vLLM dodaje 2,850 ms między fragmentami. Pierwszy token pojawia się po 0,2954 s, a odpowiedź o długości 512 tokenów jest gotowa po 6,266 s. W praktyce pierwszy token pojawia się po 0,4476 do 0,4519 s, a odpowiedź jest gotowa po 7,331 do 8,105 s.
Gdy czterech użytkowników wysyła takie prompty w tej samej chwili, vLLM przetwarza je jeden po drugim, więc pierwsze tokeny pojawiają się po 0,4199 s do 1,182 s. Gdy wszyscy czterej piszą, każdy otrzymuje 79,81 tokenu na sekundę, razem 319,3, a ostatnia odpowiedź jest gotowa po 7,571 s. W praktyce każdy otrzymuje od 61,13 do 68,49.
Otwórz kalkulator
Kalkulator wraz ze wzorami i założeniami otwiera link, który wyślemy na twój adres e-mail. Adres służy do wysłania linku, a w sprawie naszych usług napiszemy do ciebie tylko wtedy, gdy zaznaczysz pole newslettera. Szczegóły w polityce prywatności.
Pamięć
Ten krok sprawdza, czy wagi, pamięć robocza oprogramowania serwującego i pamięć rozmowy każdego użytkownika mieszczą się w tej części pamięci karty, z której może korzystać oprogramowanie serwujące.
Pamięć rozmowy użytkownika to stały stan plus pamięć podręczna każdego dotychczasowego tokenu; vLLM przechowuje stały stan dwukrotnie na potrzeby pamięci podręcznej prefiksów, a raz, dopóki rozmowa mieści się w pierwszym bloku. Oprogramowanie serwujące, tu vLLM, powszechnie używany program open source, który uruchamia modele językowe dla wielu użytkowników naraz, domyślnie zostawia wolne 8% pamięci karty, więc może użyć 92%, a część z tego potrzebuje na własną pracę: to pamięć robocza, policzona tu z jego kodu.
Oprócz szacunku krok podaje jeszcze dwie liczby tokenów na użytkownika. Maksimum teoretyczne bierze udział pamięci z karty katalogowej bez wag, bez rezerwy sterownika i bez pamięci roboczej: żadne oprogramowanie serwujące nie zostawi więcej. Szacunek praktyczny przyjmuje, zamiast wartości modelu, to, co vLLM zajął przy własnym starcie na zmierzonych kartach, jako przedział.
Pamięć karty w skali
Do czego służy każda część i ile kosztuje
- Pamięć zarezerwowana. Po co: sterownik karty zatrzymuje część pamięci dla siebie. Koszt: 488 MiB, tyle podało nvidia-smi dla RTX 5090; pamięć karty to to, co zostaje z pamięci z karty katalogowej.
- Biblioteki. Po co: cuBLAS, biblioteka mnożenia macierzy firmy NVIDIA, trzyma obszar roboczy dla swoich metod. Koszt: 32 MiB na kartach od architektury Hopper, takich jak RTX 5090, i 4 MiB na starszych, takich jak RTX 3090; w ramach .
- Obszar roboczy uwagi. Po co: przy 8-bitowej pamięci podręcznej vLLM liczy uwagę biblioteką FlashInfer, która trzyma obszar roboczy na częściowe wyniki swoich jąder. Koszt: 394 MiB przy 8-bitowej pamięci podręcznej i nic przy 16-bitowej, w ramach .
- Pamięć robocza na jeden krok. Po co: vLLM odkłada tyle pamięci, ile potrzebuje jego największy krok, który znajduje przy starcie, uruchamiając raz każdy rodzaj kroku: jeden obraz największego rozmiaru przez koder obrazu, krok 2048 tokenów promptu (8192 na H100 NVL i H200 NVL) i wybór następnego tokenu dla 256 użytkowników naraz. Koszt: koder obrazu 1,852 GB, krok promptu 0,5956 GB i wybór 0,6357 GB; największy, 1,852 GB, jest w ramach .
- Grafy CUDA. Po co: vLLM nagrywa pracę karty dla jednego kroku, dla kroków od 1 do 512 tokenów, aby odtwarzać ją bez uruchamiania każdego kroku przez procesor, co przyspiesza każdy token. Koszt: 248,5 MB według kodu vLLM, w ramach . W pomiarach, przy limicie vLLM 16 użytkowników naraz, jego własne oszacowanie wynosiło 0,54 GiB na RTX 5090 i 0,19 GiB na RTX 3090; bez grafów vLLM zostawił na RTX 3090 o 0,21 GiB więcej na rozmowy. Ich wpływu na szybkość nie zmierzono: po ich wyłączeniu vLLM pomija też wcześniejsze przygotowanie swoich jąder, a jego pierwsze tokeny trwały po około 10 s.
- Bloki. Po co: vLLM przydziela pamięć rozmów blokami, więc wiele rozmów może rosnąć i się kończyć bez przenoszenia pamięci. Koszt: blok mieści 1568 tokenów pamięci podręcznej, tu 51,38 MB, a vLLM trzyma jeden blok w zapasie; liczba tokenów, które się mieszczą, jest zaokrąglana w dół do całych bloków.
- Pamięć podręczna prefiksów. Po co: vLLM zachowuje przetworzony tekst wcześniejszych żądań, aby nowe żądanie zaczynające się od tego samego tekstu, na przykład tych samych instrukcji albo dokumentu, nie musiało go przetwarzać ponownie; stały stan zachowuje na końcu każdego całego bloku, a gdy rozmowa jest dłuższa niż jeden blok, w pamięci są naraz dwa stany na użytkownika. To ustawienie domyślne vLLM. Koszt: jeden dodatkowy stały stan na użytkownika, tu 153,9 MB, w dwóch blokach na każdą grupę 16 warstw uwagi liniowej.
Wzory
gdzie to pamięć zajmowana przez rozmowę jednego użytkownika, liczba kopii stałego stanu , które przechowuje vLLM, 1 dopóki rozmowa mieści się w pierwszym bloku tokenów i 2 później, długość rozmowy w tokenach, a pamięć podręczna na token; to wagi na karcie, pamięć robocza oprogramowania serwującego, liczba użytkowników naraz, udział pamięci dostępny dla oprogramowania serwującego, a pamięć karty; to liczba tokenów, które mieszczą się na użytkownika, przed zaokrągleniem do całych bloków vLLM.
Pamięć rozmowy 2 × 153,9 MB + 4096 × 32,77 kB = 442,1 MB na użytkownika; potrzeba 21,07 GB + 2,547 GB + 1 × 0,4421 GB = 24,06 GB ≤ 92% × 33,85 GB = 31,14 GB: mieści się; tokeny na użytkownika ((31,14 GB − 21,07 GB − 2,547 GB) ÷ 1 − 2 × 153,9 MB) ÷ 32,77 kB = 220 131, 217 952 w całych blokach vLLM.
to pamięć zajmowana przez jedną rozmowę: jej stały stan , dwukrotnie, gdy rozmowa jest dłuższa niż jeden blok, oraz pamięć podręczna warstw uwagi pełnej, na każdy z jej tokenów. Model się mieści, gdy jego wagi , pamięć robocza oprogramowania serwującego i rozmowy użytkowników zajmują razem nie więcej niż udział pamięci karty . Rozwiązanie tej samej sumy względem daje najdłuższą rozmowę, jaką może mieć każdy użytkownik, .
vLLM liczy w blokach po tokenów: najmniejszej wielokrotności 16, której pamięć podręczna w jednej warstwie, , gdzie to pamięć podręczna na token w jednej warstwie, mieści stały stan jednej warstwy . Blok obejmuje warstw uwagi pełnej; w pozostałej pamięci mieści się bloków. Jeden jest trzymany w zapasie, a stały stan każdego użytkownika zajmuje dwa bloki w każdej grupie warstw uwagi liniowej, więc każdy użytkownik może mieć tokenów, czyli pokazany wynik. Rozmowa o długości najwyżej tokenów zajmuje jeden blok w każdej grupie, więc użytkowników krótkich rozmów mieści się więcej, niż podaje wzór.
to pamięć karty z jej karty katalogowej, , pomniejszona o rezerwę sterownika, = 488 MiB. Żaden dokument NVIDIA nie podaje tej rezerwy; 488 MiB to wartość, którą podało nvidia-smi dla RTX 5090 ze sterownikiem 570, a kalkulator przyjmuje ją dla każdej karty.
to pamięć, którą vLLM zajmuje poza wagami, zanim wyznaczy pamięć na rozmowy, policzona z jego kodu przy ustawieniach domyślnych: najwyżej 256 użytkowników naraz i 2048 tokenów w kroku. to obszar roboczy cuBLAS, a obszar roboczy FlashInfer, tylko przy 8-bitowej pamięci podręcznej.
Największy krok to największa z wartości: , koder obrazu na obrazie największego rozmiaru, 0 dla modelu bez kodera; , krok 2048 tokenów promptu z zachowanym wynikiem kodera obrazu; i , wybór następnego tokenu dla 256 użytkowników, których wyniki dla całego słownika są przechowywane w 16 i 32 bitach. to grafy CUDA: dla każdego z dwóch rodzajów grafów vLLM aktywacje jego największego kroku i 1 MiB na każdy kolejny graf, najmniej, ile przyjmuje własne oszacowanie vLLM.
Pamięć karty 32 GiB − 488 MiB = 33,85 GB; pamięć robocza 33,55 MB + 413,1 MB + max(1,852 GB; 0,5956 GB; 0,6357 GB) + 248,5 MB = 2,547 GB.
to maksimum teoretyczne pamięci na rozmowy: udział pamięci z karty katalogowej bez wag w takiej postaci, w jakiej zawierają je pliki; tokeny na użytkownika, , wynikają z niej tak jak , przed zaokrągleniem do całych bloków vLLM.
to szacunek praktyczny z trzema składnikami zmierzonymi przy starcie samego vLLM z modelem Qwen3.8-27B NVFP4: pamięć dostępna dla programów obok , = −170 MiB na RTX 5090 i +38 MiB na RTX 3090, według nvidia-smi; wagi, które vLLM wczytał ponad wagi z plików, = 1,05% i 1,40% ; oraz pamięć robocza vLLM ponad , = 0,781 i 0,188 GB, głównie jego grafy CUDA. Przedział przyjmuje każdy składnik przy wartości, która zostawia mniej pamięci na rozmowy, a potem przy tej, która zostawia więcej, dla każdej karty i każdego modelu; jego tokeny na użytkownika są liczone w całych blokach vLLM.
Maksimum teoretyczne 92% × 34,36 GB − 21,07 GB = 10,54 GB, tokeny na użytkownika (10,54 GB ÷ 1 − 2 × 153,9 MB) ÷ 32,77 kB = 312 226. Praktycznie, wolniejszy kraniec 92% × (33,85 GB − 0,1783 GB) − 21,07 GB × 1,014 − (2,547 GB + 0,7809 GB) = 6,281 GB, 180 320 tokenów w całych blokach vLLM; szybszy kraniec 7,150 GB, 206 976 tokenów.
Założenia
- Rozmowy wszystkich użytkowników mają tę samą długość.
- Pamięć robocza jest policzona z kodu vLLM przy ustawieniach domyślnych. Inne ustawienia i inne wersje zużywają inne ilości, a kod jąder, wczytywany przy pierwszym użyciu każdego z nich, nie jest liczony: żadne źródło nie podaje jego rozmiaru.
- Rezerwa sterownika jest taka sama dla każdej karty i każdego sterownika, 488 MiB.
- Pamięć podręczna jest przechowywana dla każdego tokenu rozmowy; nic nie jest przenoszone poza kartę.
- Składniki szacunku praktycznego zmierzono dla Qwen3.8-27B NVFP4 na dwóch kartach. Z modelem Bielik-11B-v3.0, który nie brał udziału w ich wyznaczeniu, pamięć na rozmowy vLLM mieści się w przedziale na RTX 5090; na RTX 3090 vLLM zostawił więcej niż szybszy kraniec przedziału, o 0,2% z wagami 8-bitowymi i o 52% z 16-bitowymi, 0,41 wobec 0,27 GB: wczytał wagi Bielika w takiej postaci, w jakiej zawierają je pliki, a grafy CUDA Bielika zajęły najwyżej 0,11 GiB.
Przetwarzanie promptu
Ten krok podaje czas od wysłania promptu do pierwszego tokenu odpowiedzi, wyznaczony z obliczeń przy przetwarzaniu promptu we fragmentach.
Zanim model zacznie pisać odpowiedź, przetwarza cały prompt: każdy token promptu przechodzi przez każdą warstwę, tak jak nowy token, ale wiele tokenów naraz, więc każda waga odczytana z pamięci obsługuje cały fragment. Przetwarzanie promptu ogranicza więc wydajność obliczeń karty, a nie jej przepustowość. Mnożenia macierzy wymagają dwóch operacji na wagę i token, a uwaga pełna porównuje każdy token promptu z każdym tokenem przed nim, co rośnie z kwadratem długości promptu.
vLLM przepuszcza przez kartę w jednym kroku najwyżej 2048 tokenów, na H100 NVL i H200 NVL 8192, i przetwarza prompt we fragmentach tej wielkości; dla modelu z uwagą liniową przycina każdy do pełnych bloków po = 1568 tokenów, zachowując na końcu każdego stały stan. Obliczenia przebiegają przy wydajnościach rdzeni tensorowych z karty katalogowej, w udziale zmierzonym w źródłach: 95,5% dla mnożeń macierzy i 85,0% dla uwagi. Podczas przetwarzania promptu procesor sam przekazuje karcie każde z jąder fragmentu, po około 14 µs; fragment trwa tyle co praca karty albo procesora, zależnie od tego, co dłuższe, i jeszcze około 1 ms przed następnym krokiem.
Oprócz szacunku krok podaje jeszcze dwa czasy. Minimum teoretyczne to obliczenia przy najwyższych wydajnościach karty z jej karty katalogowej i jednokrotny odczyt wag przy pełnej przepustowości, bez niczego więcej: żadna karta i żadne oprogramowanie serwujące nie mogą zrobić tego szybciej. Szacunek praktyczny przyjmuje, zamiast wartości ze źródeł, to, co osiągnęły kroki przetwarzania promptu samego vLLM na dwóch zmierzonych kartach, jako przedział od wolniejszych wartości obu kart do szybszych; na H100 NVL i H200 NVL, dla 8-bitowej uwagi i 8-bitowych mnożeń macierzy, to, co te jądra osiągnęły na H200 NVL.
Czas do pierwszego tokenu w skali
Do czego służy każda część i ile kosztuje
- Fragmenty. Po co: w jednym kroku przez kartę przechodzi najwyżej 2048 tokenów, na H100 NVL i H200 NVL 8192, a vLLM przetwarza długi prompt w kawałkach z pełnych bloków w tych granicach i na końcu każdego zachowuje stały stan, aby późniejszy prompt zaczynający się od tego samego tekstu mógł go ponownie wykorzystać. Koszt: każdy fragment odczytuje wagi raz, a silnik vLLM potrzebuje 0,95 ms między krokami.
- Mnożenia macierzy. Po co: tak jak w przypadku nowego tokenu, każdy token promptu jest mnożony przez każdą wagę, której używa, po dwie operacje na wagę. Koszt: = 48,70 miliarda operacji na token; przy wydajności rdzeni tensorowych RTX 5090 dla formatów modelu, 884,2 TFLOPS, × 95,5% to 57,7 µs na token, największa część czasu do 32 768 tokenów.
- Uwaga pełna. Po co: każdy token promptu jest porównywany z każdym tokenem przed nim w 16 warstwach uwagi pełnej; w ten sposób model znajduje to, czego potrzebuje, w dowolnym miejscu długiego dokumentu. Koszt: rośnie z kwadratem długości promptu: 14,19 ms przy 3584 tokenach, 5% czasu; około połowy czasu przy 65 536 tokenach i 65% przy 131 072.
- Uwaga liniowa. Po co: warstwy uwagi liniowej wyznaczają swój stały stan fragmentami po 64 tokeny zamiast token po tokenie. Koszt: = 0,42 miliarda operacji na token, 8,49 ms przy 3584 tokenach.
- Małe jądra. Po co: normalizacje, dodawania, bramki i konwersje liczb między mnożeniami macierzy, z których każde odczytuje i zapisuje liczby tokenów. Koszt: = 29,0 MB na token, 63,07 ms przy 3584 tokenach, 21% czasu.
- Procesor. Po co: vLLM wykonuje fragment promptu bez grafu CUDA, więc procesor uruchamia każde z jego jąder. Koszt: 1157 jąder × 14,3 µs = 16,5 ms na fragment, krócej niż praca karty nad fragmentem o długości 1568 tokenów, więc karta na niego nie czeka.
Wzory
gdzie to czas do pierwszego tokenu; suma obejmuje fragmenty promptu o długości tokenów; to praca karty nad fragmentem; to liczba operacji mnożeń macierzy na token, wydajność rdzeni tensorowych karty dla formatów liczb modelu, a osiągany jej udział; to odczyt wag, tak jak w kroku Szybkość dla jednego użytkownika; to liczba operacji uwagi pełnej we fragmencie, a uwagi liniowej na token, przy wydajności 16-bitowej × ; to bajty małych jąder na token; to liczba jąder fragmentu, a czas procesora na jedno jądro; to czas silnika vLLM na krok; to liczba tokenów promptu na sekundę.
Fragmenty o długości 1568, 1568 i 448 tokenów; mnożenia macierzy 3584 × 48,70 GFLOP ÷ 844,1 TFLOPS = 206,8 ms; uwaga pełna 14,19 ms; uwaga liniowa 8,487 ms; odczyt i zapis małych jąder 63,07 ms; praca karty 292,5 ms; procesor uruchamia 1157 jąder na fragment po 14,27 µs, 16,51 ms; każdy fragment trwa dłuższy z tych czasów, potem 0,9500 ms silnika vLLM: czas do pierwszego tokenu 0,2954 s; tokeny promptu na sekundę 3584 ÷ 0,2954 s = 12 133.
liczy dwie operacje, mnożenie i dodawanie, na każdą wagę, której mnożenia macierzy używają na token: macierzy o wierszach i kolumnach każdego rodzaju, w każdej warstwie i w warstwie wyjściowej. Dla Qwen3.8-27B to 48,70 miliarda. to wydajność rdzeni tensorowych karty dla tych operacji, każda macierz przy wydajności z karty katalogowej dla swojego formatu liczb: 884,2 TFLOPS na RTX 5090 dla modelu 4-bitowego i 71,2 TFLOPS na RTX 3090, której jądra Marlin mnożą w 16 bitach.
to liczba operacji uwagi pełnej dla fragmentu o długości tokenów, który zaczyna się po tokenach: zapytanie każdego tokenu jest mnożone przez klucz każdego tokenu przed nim, średnio , a wyniki przez ich wartości, po dwie operacje, dla jego głowic zapytań po liczb w każdej z warstw uwagi pełnej.
Fragmenty to bloki po tokenów, ostatni krótszy. Mnożenia macierzy fragmentu trwają tyle, ile ich obliczenia albo odczyt wag, zależnie od tego, co dłuższe: krótki fragment ogranicza przepustowość, tak jak nowy token. Uwaga liniowa wyznacza swój stały stan kawałkami po 64 tokeny, = 0,42 miliarda operacji na token dla Qwen3.8-27B, policzone z kodu vLLM. Małe jądra między mnożeniami macierzy odczytują i zapisują = 29,0 MB na token na RTX 5090, policzone z konfiguracji modelu.
Fragment promptu uruchamia jądra nowego tokenu, przy czym dwa jądra uwagi liniowej w każdej warstwie zastępuje dziewięć jąder obliczeń we fragmentach: = 1157 dla modelu 4-bitowego na RTX 5090. vLLM uruchamia je bez grafów CUDA, więc procesor wydaje je jedno po drugim, gdy karta pracuje nad wcześniejszymi, a fragment trwa tyle co praca karty albo czas procesora, zależnie od tego, co dłuższe. Potem silnik vLLM potrzebuje przed następnym krokiem.
= 95,5%: 16-bitowe mnożenie macierzy osiągnęło około 200 z 209,5 TFLOPS karty RTX 5090 (Zhang i in., 2025). = 85,0%: FlashAttention osiągnęło od 147 do 209 TFLOPS na RTX 5090, 178 w środku tego zakresu (ta sama praca). = 14,3 µs: 743 jądra trwały 14 ms bez grafu CUDA i 3,4 ms z grafem (Ghosh i in., 2025). = 0,95 ms: czas planowania kroku w vLLM (Li i in., 2025). Żadnej z tych czterech wartości nie zmierzono na zmierzonych tu kartach ani nie ustawiono na podstawie ich pomiarów.
Na kartach H100 NVL i H200 NVL vLLM mnoży wagi 4-bitowe swoimi jądrami Marlin, które używają instrukcji rdzeni tensorowych kart sprzed architektury Hopper; na karcie Hopper te instrukcje osiągają średnio 62,9% jej wydajności szczytowej (Luo i in., 2024). Ich wydajność dla 4 bitów to więc 62,9% wydajności 16-bitowej, 525,5 TFLOPS, a minimum teoretyczne zachowuje 16-bitową wydajność szczytową, 835,5 TFLOPS. Karty A100 80GB PCIe, RTX 3080 i RTX 3090 mnożą wagi 8- i 4-bitowe z wydajnością 16-bitową, a RTX 4080, która liczby 8-bitowe mnoży sama, tak samo mnoży wagi 4-bitowe: na kartach sprzed architektury Hopper te instrukcje osiągają mniej więcej swoją wydajność szczytową (Luo i in., 2024).
to minimum teoretyczne. i to najwyższe wydajności karty z jej karty katalogowej dla każdego formatu liczb, z akumulacją 16-bitową tam, gdzie ją podaje: 838 TFLOPS dla liczb 8-bitowych na RTX 5090 i 142,3 dla liczb 16-bitowych jąder Marlin na RTX 3090; bfloat16, w którym działa uwaga, ma tylko wydajność z akumulacją 32-bitową; na H100 NVL i H200 NVL z pamięcią podręczną 8 bitów uwaga działa w 8 bitach, przy najwyższej wydajności 8-bitowej. Szacunek przyjmuje wszędzie wydajności z akumulacją 32-bitową. Małe jądra, procesor i silnik nie dodają niczego.
to szacunek praktyczny. Jego wartości pochodzą z profili kroków przetwarzania promptu vLLM, Qwen3.8-27B NVFP4 na dwóch zmierzonych kartach, każda jako czas danej części przy wydajnościach szacunku podzielony przez jej zmierzony czas: mnożenia macierzy = 106,0% (RTX 5090) i 99,9% (RTX 3090), uwaga pełna = 68,4% (RTX 5090, przy 65 536 tokenach), uwaga liniowa = 20,7% i 24,4%, a małe jądra = 220% i 129%: przesyłały mniej bajtów, niż liczy . Wagi są odczytywane przy z kroku Szybkość dla jednego użytkownika.
Na H100 NVL i H200 NVL z pamięcią podręczną 8 bitów vLLM wykonuje uwagę w 8 bitach: tam = 23,3% najwyższej wydajności 8-bitowej, a 8-bitowe mnożenia macierzy osiągają 65,3% do 71,7% tej wydajności, niższą wartość wtedy, gdy karta utrzymywała je przez 15 s przy swoim limicie mocy; zmierzono to jądrami samego vLLM na H200 NVL przy rozmiarach Qwen3.8-27B.
Na RTX 5090 fragment czeka na procesor, który według liczników samego vLLM potrzebował = 121 µs na każde liczone jądro; na RTX 3090 dłuższa praca karty go ukrywa. Między fragmentami karta była bezczynna przez = 8,9 i 10,4 ms. Przedział przyjmuje każdą wartość przy wolniejszej z jej wartości, a potem każdą przy szybszej, dla każdej karty i każdego modelu; karta bez danej wartości przyjmuje wartość drugiej. Praktyczna praca fragmentu nigdy nie jest krótsza niż jego minimum teoretyczne.
Minimum teoretyczne: mnożenia macierzy 135,7 ms, uwaga pełna 12,05 ms, uwaga liniowa 7,211 ms, przy wydajnościach szczytowych: 0,1550 s. Praktycznie, wolniejszy kraniec: praca pierwszego fragmentu 124,7 ms przy zmierzonych wartościach, wobec 1157 jąder × 121,3 µs = 140,3 ms procesora; każdy fragment trwa tyle, ile dłuższe z nich, a potem 10,35 ms: 0,4519 s. Szybszy kraniec, każda wartość z szybszej karty: 0,4476 s.
Założenia
- Jeden prompt naraz, z nowym tekstem: nic z niego nie znajduje się w pamięci podręcznej prefiksów vLLM. Prompt zaczynający się od tekstu przetworzonego wcześniej, na przykład od tych samych instrukcji, jest szybszy.
- , , i są takie same dla każdej karty i procesora, ze źródeł podanych wyżej.
- Uwaga pełna działa w udziale, który FlashAttention osiągnęło przy wymiarze głowicy 128. Głowice tego modelu mają szerokość 256, a vLLM używa FlashInfer z 8-bitową pamięcią podręczną; na zmierzonych kartach osiągnęła ona mniej, więc długie prompty są szacowane za szybko.
- Procesor wydaje operację w czasie . Na RTX 5090 wydanie operacji vLLM trwało dłużej, a karta czekała na procesor w krótkich fragmentach, więc krótkie prompty są tam szacowane za szybko (Porównanie z pomiarami).
- Nie liczy się niczego poza kartą: sieci, zamiany tekstu na tokeny ani kolejki serwera.
- Do najdłuższego promptu bez wywłaszczenia. Powyżej niego vLLM zużywa bloki podczas przetwarzania promptu, odkłada prompt i przetwarza jego część ponownie, co trwa dłużej, niż pokazano, o wartość, której nie modelowano.
- Wartości szacunku praktycznego zmierzono dla Qwen3.8-27B NVFP4 na dwóch kartach. Bielik-11B-v3.0, który nie brał udziału w ich wyznaczeniu, mieści się w przedziale przy 7 z 18 promptów: jego długie prompty były do 6,2% szybsze, a krótkie do 8,6% wolniejsze; przyczyn nie profilowano.
Szybkość dla jednego użytkownika
Ten krok podaje liczbę tokenów na sekundę, którą otrzymuje jeden użytkownik, z liczby bajtów odczytywanych i zapisywanych przez każdy nowy token, udziału przepustowości karty osiąganego przy odczycie i jąder, które uruchamia każdy token.
Tworzenie nowego tokenu ogranicza przepustowość pamięci karty, czyli liczba bajtów na sekundę, które może odczytać ze swojej pamięci: każdy token raz odczytuje wagi, których używa, oraz odczytuje i zapisuje pamięć rozmowy użytkownika, a obliczenia na nich trwają krócej niż odczyt. Test przepustowości pamięci osiągnął 92% przepustowości podanej przez producenta na karcie GeForce RTX 4090, a kalkulator przyjmuje ten udział dla każdej karty.
Karta wykonuje pracę jednego tokenu jako ciąg jąder (ang. kernels), czyli małych programów uruchamianych jeden po drugim, około 800, policzonych z kodu vLLM. Każde dodaje mniej niż mikrosekundę, razem około 0,7 ms na token.
Oprócz szacunku krok podaje jeszcze dwie wartości. Maksimum teoretyczne to odczyt wszystkiego przy pełnej przepustowości bez czasu na jądra: żadna karta i żadne oprogramowanie serwujące nie mogą zrobić tego szybciej. Szacunek praktyczny przyjmuje, zamiast wartości ze źródeł, to, co osiągnęły kroki dekodowania samego vLLM na dwóch zmierzonych kartach. To przedział, od wolniejszych wartości obu kart do szybszych, bo karta albo model, których nikt nie zmierzył, nie mają własnych wartości.
Czas na token w skali
Wzory
gdzie to szacowana liczba tokenów na sekundę; to liczba jąder uruchamianych przy każdym tokenie; to czas startu jądra, a czas, zanim dotrze jego pierwszy odczyt z pamięci; to wagi odczytywane przy każdym tokenie, a bajty użytkownika: stały stan odczytywany i zapisywany, aktywacje i logity oraz odczytywana pamięć podręczna, w bajtach; to osiągany udział przepustowości; to przepustowość pamięci karty w bajtach na sekundę; to limit przepustowości, sam odczyt.
Jądra 821 × (0,5532 µs + 0,3350 µs) = 0,7292 ms; wagi 17,61 GB ÷ (92% × 1792 GB/s) = 10,68 ms; bajty użytkownika 0,4615 GB ÷ (92% × 1792 GB/s) = 0,2799 ms; szacunek 1 ÷ (0,7292 ms + 10,68 ms + 0,2799 ms) = 85,55 tok./s; limit przepustowości 1792 GB/s ÷ 18,07 GB = 99,17 tok./s.
Przy każdym nowym tokenie karta uruchamia jąder, odczytuje wag oraz odczytuje i zapisuje bajtów użytkownika. Każde jądro potrzebuje na start i , zanim dotrze jego pierwszy odczyt, a bajty są przesyłane przy udziale przepustowości ; razem dają jednego użytkownika. Odczyt wszystkiego przy pełnej przepustowości, bez czasu na jądra, dałby : żadna karta i żadne oprogramowanie serwujące nie mogą zrobić tego szybciej.
Warstwy uwagi liniowej aktualizują stały stan każdego użytkownika w miejscu, więc każdy token go odczytuje i zapisuje z powrotem, . Każde jądro zapisuje swoje wyniki, które odczytuje następne, czyli aktywacje, a ostatnie mnożenie macierzy zapisuje ocenę dla każdej z 248 320 pozycji słownika, czyli logity, spośród których wybierany jest token. Razem to , policzone z konfiguracji modelu: 19,40 MB na token na RTX 5090 i 20,39 MB na RTX 3090, którego mnożenia macierzy przyjmują dane wejściowe w 16 bitach. Warstwy uwagi pełnej odczytują pamięć podręczną każdego dotychczasowego tokenu, .
Jądra policzono z kodu vLLM. vLLM kompiluje model za pomocą torch.compile, który łączy normalizacje, dodawania i bramki między dwoma mnożeniami macierzy w jedno jądro; mnożenia macierzy, uwaga i aktualizacje uwagi liniowej to osobne jądra. Daje to 11 jąder w każdej warstwie uwagi pełnej, 12 w każdej warstwie uwagi liniowej i 4 raz na token.
Karta, która sama mnoży liczby 4-bitowe, tak jak RTX 5090, uruchamia jedno jądro więcej w każdej warstwie i jedno więcej raz na token, aby przekształcić dane wejściowe macierzy 4-bitowych: 821 dla modelu 4-bitowego na RTX 5090, 756 na RTX 3090 i dla modelu 8-bitowego. vLLM zapisuje jądra tokenu raz i odtwarza je jako jeden graf CUDA, więc procesor nie uruchamia każdego z nich osobno.
= 92% to udział przepustowości producenta osiągnięty w teście przepustowości pamięci na karcie GeForce RTX 4090 (Luo i in., 2024). = 0,553 µs: 1025 pustych jąder w jednym grafie CUDA zajęło 567 µs na karcie GeForce RTX 3060 (Hoffman i Oh, 2024). = 0,335 µs: odczyt z pamięci karty zajął 876,7 cykli zegara na karcie GeForce RTX 5080 (Jarmusch i in., 2025), przy jej zegarze boost 2617 MHz. Żadnej z tych trzech wartości nie zmierzono na zmierzonych tu kartach ani nie ustawiono na podstawie ich pomiarów.
to szacunek praktyczny. Jego wartości pochodzą z profili kroków dekodowania vLLM: Qwen3.8-27B NVFP4, jeden użytkownik, na zmierzonych kartach RTX 5090 i RTX 3090, po odjęciu czasu samego profilera. Mnożenia macierzy odczytywały wagi przy = 78,2% i 83,6% przepustowości. Małe jądra, przerwy między jądrami i wybór tokenu zajmowały = 1,98 i 1,38 µs na każde jądro liczone przez kalkulator, a uwaga stały czas = 18,2 i 12,9 µs w każdej warstwie uwagi pełnej.
Stały stan był odczytywany i zapisywany przy = 47,9% i 57,9% przepustowości, pamięć podręczna odczytywana przy = 95,7% i 74,8%, a karta była bezczynna przez = 0,015 i 0,051 ms między dwoma krokami. Aktywacje i logity wchodzą w czas małych jąder. Przedział przyjmuje każdą wartość przy wolniejszej z dwóch, a potem każdą przy szybszej, dla każdej karty i każdego modelu.
Praktycznie, wolniejszy kraniec: wagi 17,61 GB ÷ (78,23% × 1792 GB/s) = 12,56 ms; jądra 821 × 1,976 µs = 1,622 ms; stały koszt uwagi 16 × 18,24 µs = 0,2918 ms; stały stan 2 × 153,9 MB ÷ (47,94% × 1792 GB/s) = 0,3584 ms; pamięć podręczna 4096 × 32,77 kB ÷ (74,77% × 1792 GB/s) = 0,1002 ms; bezczynność 0,05116 ms; 1 ÷ 14,98 ms = 66,74 tok./s. Szybszy kraniec, każda wartość z szybszej karty: 74,21 tok./s.
Założenia
- Jeden użytkownik naraz, na jednej karcie; wielu użytkowników opisuje krok Szybkość dla wielu użytkowników.
- , i są takie same dla każdej karty, ze źródeł podanych wyżej.
- Wagi są odczytywane przy , udziale, który osiąga zwykły odczyt. Mnożenia macierzy w vLLM przy odczycie rozpakowują też wagi 4- i 8-bitowe i żadne źródło nie podaje udziału, który osiągają przy rozmiarach jednego użytkownika; na zmierzonych kartach osiągnęły 78% przepustowości na RTX 5090 i 84% na RTX 3090, więc szacunek jest za szybki.
- Każde jądro jest liczone raz, tak jak podaje je kod vLLM, z jednym odczytem z pamięci. Na zmierzonych kartach vLLM uruchamiał 1163 jądra na token na RTX 5090 i 926 na RTX 3090, ponieważ torch.compile połączył mniej operacji, niż zakłada liczenie, a jego jądra odczytywały pamięć więcej niż raz; oba powody czynią szacunek za szybkim.
- Inna karta jest traktowana jako karta, która sama mnoży liczby 4-bitowe, tak jak RTX 5090.
- Wartości szacunku praktycznego zmierzono dla jednego modelu, Qwen3.8-27B NVFP4, na dwóch kartach. Bielik-11B-v3.0, który nie brał udziału w ich wyznaczeniu, działał szybciej, niż podaje przedział praktyczny, w 12 z 18 zmierzonych punktów: o 0,2% do 3,0% z wagami 8-bitowymi i z wagami 16-bitowymi na RTX 3090 oraz o 6,3% do 11,0% z wagami 16-bitowymi na RTX 5090. Bielika nie profilowano, więc przyczyna nie jest ustalona.
Szybkość dla wielu użytkowników
Ten krok podaje liczbę tokenów na sekundę dla każdego użytkownika, gdy karta pisze kilka odpowiedzi naraz, i dla wszystkich użytkowników razem.
Karta tworzy w jednym kroku po jednym nowym tokenie dla każdego użytkownika: odczytuje wagi raz dla wszystkich i pamięć rozmowy każdego użytkownika osobno. Kolejny użytkownik kosztuje więc znacznie mniej niż kolejna karta: na RTX 5090 każdy z 16 użytkowników otrzymywał 58,7 tokenu na sekundę, a jeden użytkownik 68,9, razem 940 tokenów na sekundę.
Każdy kolejny użytkownik dodaje tylko własne bajty: swój stały stan, odczytywany i zapisywany, swoje aktywacje i logity oraz swoją pamięć podręczną, tak jak w kroku Szybkość dla jednego użytkownika. Jądra i odczyt wag są wspólne dla wszystkich użytkowników w kroku. Użytkownicy i długość rozmowy pochodzą z kroku Pamięć.
Jeden krok dla wszystkich użytkowników w skali
Wzory
gdzie to czas jednego kroku, który tworzy po jednym tokenie dla każdego użytkownika; to liczba użytkowników naraz; , , , , i jak w kroku Szybkość dla jednego użytkownika, a to bajty jednego użytkownika przy długości rozmowy ; i to liczba tokenów na sekundę każdego użytkownika i wszystkich razem.
Jeden użytkownik naraz: krok 0,7292 ms + (17,61 GB + 0,4615 GB) ÷ (92% × 1792 GB/s) = 11,69 ms; każdy użytkownik 1 ÷ 11,69 ms = 85,55 tok./s; wszyscy użytkownicy 1 × 85,55 = 85,55 tok./s.
Użytkownicy naraz, , to największa liczba użytkowników, najwyżej i limit vLLM wynoszący 256 naraz, których rozmowy o długości tokenów mieszczą się przez całą swoją długość: to tokeny na użytkownika z kroku Pamięć dla użytkowników. Sam vLLM uruchamia żądanie, gdy jego bloki mieszczą się w danej chwili, i wywłaszcza je później, jeśli rozmowy urosną ponad to, co się mieści: na RTX 3090 wszyscy trzej użytkownicy z rozmowami po 2304 tokeny zostali uruchomieni, a dwóch z nich wywłaszczono.
Każdy krok uruchamia jądra i odczytuje wagi raz dla wszystkich użytkowników, a bajty każdego użytkownika dla tego użytkownika. Krok użytkowników trwa więc dłużej niż krok jednego użytkownika tylko o : na RTX 5090 przy rozmowach po 4096 tokenów to 0,28 ms na każdego kolejnego użytkownika wobec kroku trwającego 11,69 ms.
to odczyt wag raz i bajtów każdego użytkownika przy pełnej przepustowości, bez czasu na jądra. to praktyczny krok z kroku Szybkość dla jednego użytkownika dla użytkowników: wagi, jądra, stały koszt uwagi i bezczynność raz na krok oraz stały stan i pamięć podręczna każdego użytkownika, z tymi samymi wartościami , , , , i . Zmierzono je przy jednym użytkowniku i przyjęto dla wielu; Porównanie z pomiarami pokazuje, na ile to się sprawdza.
Maksimum teoretyczne 1792 GB/s ÷ (17,61 GB + 1 × 0,4615 GB) = 99,17 tok./s na każdego; praktycznie, wolniejszy kraniec 1 ÷ 14,98 ms = 66,74 tok./s na każdego, szybszy kraniec 74,21 tok./s na każdego.
Założenia
- Rozmowa każdego użytkownika ma tę samą długość , a każdy użytkownik pisze odpowiedź; prompty przetwarzane w tym samym czasie opisuje krok Od promptu do odpowiedzi.
- Krok to krok z kroku Szybkość dla jednego użytkownika dla użytkowników, z jego przyczynami błędu: szacunek jest za szybki, bardziej przy 2 do 4 użytkownikach na RTX 5090, gdzie biblioteka macierzowa NVIDIA, cuBLAS, wybiera wolniejszą metodę dla jednej małej macierzy (Porównanie z pomiarami).
- Obliczenia mnożeń macierzy rosną z liczbą użytkowników i nie są liczone. Przy wydajnościach z kart katalogowych trwałyby dłużej niż odczyt wag od 29 użytkowników na RTX 3090 i 186 na RTX 5090 dla modelu 4-bitowego; szacunek jest wtedy za szybki.
- Porównano z vLLM do 16 użytkowników naraz.
- Szacunek praktyczny zachowuje wartości zmierzone przy jednym użytkowniku. W porównaniu z vLLM przy 2 do 16 użytkownikach naraz szybkość vLLM mieści się w przedziale w 17 z 35 kroków: na RTX 3090 we wszystkich 11; na RTX 5090 jest od niego niższa o 0,6% do 6,4% przy 2 do 4 użytkownikach modelu Qwen3.8, gdzie cuBLAS wybiera wolniejszą metodę, i wyższa o najwyżej 7,5% od 12 użytkowników oraz z modelem Bielik-11B-v3.0.
Od promptu do odpowiedzi
Ten krok śledzi prompt każdego użytkownika od chwili wysłania do ostatniego tokenu odpowiedzi, w kolejności ustalonej przez vLLM, i pokazuje odpowiedzi w miarę ich powstawania.
Przy wielu użytkownikach kroki opisane wyżej działają razem. Gdy przetwarzany jest prompt jednego użytkownika, użytkownicy, którzy już dostają odpowiedź, czekają na niego: vLLM tworzy ich kolejne tokeny w tym samym kroku, a krok z fragmentem promptu trwa tyle co ten fragment.
vLLM przepuszcza przez kartę w jednym kroku najwyżej 2048 tokenów, na H100 NVL i H200 NVL 8192: najpierw po jednym tokenie dla każdej pisanej odpowiedzi i następny fragment każdego rozpoczętego promptu, potem oczekujące prompty w kolejności nadejścia, dopóki każdy fragment mieści się w całości. Gdy użytkownicy dostają odpowiedzi, w kroku 2048 tokenów jest więc miejsce na jeden fragment o długości 1568 tokenów. Symulacja stosuje te zasady, odczytane z kodu vLLM, a czas każdego kroku bierze z kroków powyżej; wszyscy użytkownicy wysyłają prompt o długości tokenów w tej samej chwili.
Oprócz szacunku krok podaje jeszcze dwa czasy odpowiedzi. Minimum teoretyczne przechodzi te same kroki przy minimum teoretycznym z kroku Przetwarzanie promptu i maksimum teoretycznym z kroku Szybkość dla wielu użytkowników; szacunek praktyczny przechodzi je przy ich krokach praktycznych, jako przedział.
Jak symulacja układa kroki
- Wysyłanie: wszyscy użytkownicy wysyłają prompty w tej samej chwili; trafiają one do vLLM jeden po drugim, więc jego pierwszy krok obejmuje tylko pierwszy.
- Każdy krok: użytkownicy, którzy dostają odpowiedź, otrzymują po jednym tokenie, a każdy rozpoczęty prompt swój następny fragment, jeśli się mieści; potem zaczynają się oczekujące prompty, po kolei, do liczby użytkowników mieszczących się w pamięci, aż fragment któregoś promptu się nie zmieści.
- Czas kroku: z fragmentami promptów to ich czas z kroku Przetwarzanie promptu i bajty użytkowników dostających w nim odpowiedź, jak w kroku Szybkość dla wielu użytkowników; bez fragmentów to krok z kroku Szybkość dla wielu użytkowników.
- Tokeny: pierwszy token użytkownika pojawia się, gdy skończy się ostatni fragment promptu, a potem po jednym tokenie na krok, aż odpowiedź będzie gotowa. Użytkownik, który nie mieści się w pamięci, czeka, aż skończy się któraś odpowiedź.
Symulowane strumienie odpowiedzi
Odpowiedzi pojawiają się w czasie rzeczywistym tak, jak podaje je symulacja; tekst to przykładowa odpowiedź pocięta na tokeny modelu Qwen3.8-27B, z których każdy jest słowem lub jego częścią, powtarzana, gdy odpowiedź jest dłuższa. Polskie słowo zajmuje więcej tokenów niż angielskie, więc przy tej samej liczbie tokenów na sekundę słowa pojawiają się wolniej.
Każdy użytkownik od promptu do odpowiedzi w skali
Wzory
Jeden użytkownik: prompt w 3 fragmentach, pierwszy token po 0,2954 s; następnie 511 tokenów, po jednym na krok, odpowiedź gotowa po 6,266 s; średni czas na token (6,266 s − 0,2954 s) ÷ 511 = 11,68 ms.
Krok, który przetwarza fragmenty promptów, trwa tyle co praca karty nad nimi, , jak w kroku Przetwarzanie promptu, z wagami odczytywanymi raz dla wszystkich, albo czas procesora , zależnie od tego, co dłuższe, potem silnika vLLM, plus dla użytkowników dostających w nim odpowiedź: ich bajty, każdego użytkownika przy udziale przepustowości, jak w kroku Szybkość dla wielu użytkowników.
Na RTX 5090, w profilu z jednym użytkownikiem dostającym odpowiedź, mnożenia macierzy kroku trwały o 13,9 ms dłużej niż sam prompt, bo przy 1025 wierszach biblioteki macierzowe NVIDIA wybierają wolniejsze metody niż przy 1024; kalkulator tego nie liczy. Na RTX 3090 krok trwał tyle co sam prompt, 767 wobec 771 ms.
Średni czas na token, , to czas każdej odpowiedzi od pierwszego do ostatniego tokenu, , podzielony przez jej pozostałe tokenów i uśredniony dla użytkowników. Obejmuje kroki, w których odpowiedź czeka na prompty innych użytkowników, w przeciwieństwie do czasu między tokenami z kroku Szybkość dla wielu użytkowników.
Minimum teoretyczne i szacunek praktyczny przechodzą tę samą symulację z innymi krokami. Krok z fragmentami promptów trwa tyle co minimum albo czas praktyczny z kroku Przetwarzanie promptu, a użytkownicy dostający w nim odpowiedź dodają swoje bajty przy pełnej przepustowości albo swój stały stan przy i pamięć podręczną przy ; krok samych odpowiedzi trwa tyle co krok teoretyczny albo praktyczny z kroku Szybkość dla wielu użytkowników.
Minimum teoretyczne: pierwszy token 0,1550 s, cała odpowiedź 5,305 s, 10,08 ms na token. Praktycznie: pierwszy token 0,4476 do 0,4519 s, cała odpowiedź 7,331 do 8,105 s, 13,47 do 14,98 ms na token.
Założenia
- Wszyscy użytkownicy wysyłają prompty w tej samej chwili, wszystkie o długości tokenów, a wszystkie odpowiedzi mają tokenów; nic nie znajduje się w pamięci podręcznej prefiksów vLLM.
- Użytkownicy naraz to ci, których rozmowy o długości tokenów mieszczą się przez całą swoją długość. vLLM może uruchomić więcej i ich wywłaszczyć; tego nie symulowano.
- Błędy symulacji względem vLLM i ich przyczyny, na ile je ustalono, opisano w części Porównanie z pomiarami.
- Przedział praktyczny przyjmuje wartości jednego modelu, zmierzone przy jednym użytkowniku. W porównaniu z vLLM cała odpowiedź na jeden prompt i 256 tokenów mieści się w nim przy wszystkich 11 promptach modelu Qwen3.8 i 4 z 18 promptów modelu Bielik-11B-v3.0, a pozostałe są do 9,1% krótsze; przy wielu użytkownikach ostatni pierwszy token mieści się w nim w 14 z 35 kroków, a średni czas na token w 7, przeważnie krótszy (Porównanie z pomiarami).
Porównanie z pomiarami
Ta część zestawia wyniki kalkulatora z wynikami samego vLLM na trzech zmierzonych kartach.
W tabelach poniżej „Model wobec vLLM” podaje, o ile szacunek z modelu jest wyższy (+) albo niższy (−) od wartości vLLM, w procentach wartości vLLM. „Szacunek praktyczny wobec vLLM” podaje „w przedziale”, gdy wartość vLLM mieści się w przedziale praktycznym; w przeciwnym razie podaje, o ile bliższy kraniec przedziału odbiega od wartości vLLM, liczone tak samo.
Pamięć i szybkość dla jednego użytkownika
Pamięć na rozmowy jest o 18% większa niż w vLLM na RTX 5090 i o 47% większa na RTX 3090; szacowana szybkość jednego użytkownika jest o 23 do 28% wyższa niż w vLLM na RTX 5090 i o 13 do 14% wyższa na RTX 3090, a szybkość vLLM mieści się w przedziale praktycznym przy 6 z 7 długości. Pamięć na rozmowy i tokeny vLLM mieszczą się w praktycznym przedziale pamięci na obu kartach.
vLLM uruchamiał Qwen3.8-27B NVFP4 na kartach GeForce RTX 5090 i GeForce RTX 3090, na każdej karcie osobno, przy ustawieniach domyślnych, ale z limitem 16 użytkowników naraz, i z 8-bitową pamięcią podręczną. Wartości pamięci pochodzą z dziennika vLLM; szybkości to mediana czasu między dwoma nowymi tokenami, przy jednym żądaniu naraz, po trzy żądania po 256 nowych tokenów dla każdej długości rozmowy. Pamięć kalkulatora, policzoną przy tym samym limicie, i szybkość jednego użytkownika zapisano z kodu vLLM, kart katalogowych i źródeł, zanim zestawiono je z tymi pomiarami; nic w nich nie dopasowano do nich.
| Karta, udział | Wynik | Z modelu | Szacunek praktyczny | vLLM | Model wobec vLLM | Szacunek praktyczny wobec vLLM |
|---|---|---|---|---|---|---|
| RTX 5090, 92% | Pamięć na rozmowy | 7,747 GB | 6,507 do 7,376 GB | 6,582 GB | +17,7% | w przedziale |
| RTX 5090, 92% | Tokeny dla jednego użytkownika | 224 224 | 186 592 do 213 248 | 189 728 | +18,2% | w przedziale |
| RTX 3090, 98% | Pamięć na rozmowy | 1,389 GB | 0,1383 do 1,020 GB | 0,9449 GB | +47,0% | w przedziale |
| RTX 3090, 98% | Tokeny dla jednego użytkownika | 31 360 | 0 do 18 816 | 17 248 | +81,8% | w przedziale |
| RTX 3090, 92% | Mieści się | Nie | Nie | Nie uruchamia się |
| Karta | Rozmowa | Z modelu | Szacunek praktyczny | Limit przepustowości | vLLM | Model wobec vLLM | Szacunek praktyczny wobec vLLM |
|---|---|---|---|---|---|---|---|
| RTX 5090 | 1024 tokeny | 85,98 | 67,06 do 74,52 | 99,71 | 67,34 | +27,7% | w przedziale |
| RTX 5090 | 16 384 tokeny | 83,78 | 65,42 do 72,92 | 96,99 | 66,37 | +26,2% | w przedziale |
| RTX 5090 | 65 536 tokenów | 77,44 | 60,65 do 68,25 | 89,21 | 62,12 | +24,7% | w przedziale |
| RTX 5090 | 131 072 tokeny | 70,35 | 55,27 do 62,88 | 80,60 | 57,36 | +22,6% | w przedziale |
| RTX 3090 | 1024 tokeny | 46,42 | 37,56 do 41,04 | 52,08 | 41,09 | +13,0% | −0,1% |
| RTX 3090 | 8192 tokeny | 45,84 | 37,09 do 40,60 | 51,40 | 40,30 | +13,7% | w przedziale |
| RTX 3090 | 16 000 tokenów | 45,22 | 36,60 do 40,14 | 50,69 | 39,83 | +13,5% | w przedziale |
Kalkulator zostawia na rozmowy o 1,17 GB więcej niż vLLM na RTX 5090 i o 0,45 GB więcej na RTX 3090. Na RTX 3090 po wagach zostaje niewiele, więc mniejszy błąd to 47% pamięci na rozmowy i 82% tokenów. Pamięć robocza vLLM była taka sama przy 92% i 98% na RTX 3090, z dokładnością do 0,01 GB, tak jak pamięć robocza kalkulatora.
Wartości samego vLLM dzielą różnicę na trzy przyczyny. Pamięć dostępna dla programów: RTX 5090 miała o 0,17 GB mniej, niż podaje karta katalogowa po odjęciu rezerwy sterownika; na RTX 3090 sterownik zarezerwował mniej, co dało vLLM o 0,04 GB więcej. Wagi: vLLM wczytał o 1,0% i 1,4% więcej, niż zawierają pliki modelu, 0,22 i 0,30 GB. Pamięć robocza: pamięć vLLM była o 0,79 i 0,19 GB większa niż policzona, głównie przez grafy CUDA, według jego własnego oszacowania 0,54 i 0,19 GiB wobec 0,02 GB policzonych. Razem wyjaśniają różnicę z dokładnością do 0,01 GB; pozostałe 0,2 GB pamięci roboczej na RTX 5090 nie ma ustalonej przyczyny.
Praktyczny przedział pamięci bierze składniki z tych dwóch pomiarów, więc tu sprawdza się go na danych, z których pochodzi: pamięć na rozmowy i tokeny vLLM mieszczą się w nim na obu kartach. Z modelem Bielik-11B-v3.0, który nie brał udziału w jego wyznaczeniu, mieszczą się w nim na RTX 5090, a na RTX 3090 są od niego większe, jak podają założenia kroku Pamięć.
Szacunek dla jednego użytkownika jest za szybki z powodów znalezionych w profilach kroków vLLM, użytych tu tylko do ustalenia przyczyn. Przy 1024 tokenach szacowany krok jest o 3,22 ms krótszy niż w vLLM na RTX 5090 i o 2,80 ms na RTX 3090. Mnożenia macierzy w vLLM odczytują wagi przy 78% i 84% przepustowości, a nie 92%: 1,87 i 2,03 ms. vLLM uruchamiał 1163 i 926 jąder na token, a nie 821 i 756, a jego jądra odczytywały pamięć więcej niż raz: 1,38 i 0,55 ms. Na RTX 3090 stały koszt uwagi dodaje około 0,21 ms. Razem wyjaśniają one różnicę z dokładnością do 0,03 ms na obu kartach. Modelu 8-bitowego nie mierzono.
Przedział praktyczny bierze wartości z profili tego modelu na tych kartach, więc tu sprawdza się go na danych, z których pochodzi: szybkość vLLM mieści się w nim przy 6 z 7 długości, a przy siódmej jest od niego o 0,1% wyższa. Bielik-11B-v3.0, zmierzony osobno i niewykorzystany do jego wyznaczenia, mieści się w nim w 6 z 18 punktów; w pozostałych vLLM był szybszy, do 3,0%, a o 6,3% do 11,0% z wagami 16-bitowymi na RTX 5090.
Czas do pierwszego tokenu
Na RTX 3090 szacunek jest o 1% do 2% za wolny; na RTX 5090 jest o 5% do 14% za szybki od 16 384 tokenów i do 46% za szybki przy krótkich promptach. Powyżej limitu wywłaszczenia vLLM czasu nie modelowano, a na RTX 3090 limit kalkulatora jest mniej więcej dwa razy wyższy niż limit vLLM. Czas vLLM mieści się w przedziale praktycznym przy 10 z 12 promptów.
Te same karty przetwarzały też prompty o długości od 1024 do 180 000 tokenów i obsługiwały do 24 użytkowników, każda karta osobno, z 8-bitową pamięcią podręczną i limitem vLLM użytkowników naraz ustawionym na 16. Każdy prompt był osobnym tekstem, aby nic z niego nie znalazło się w pamięci podręcznej prefiksów vLLM, co potwierdziły jego liczniki. Każdą długość promptu zmierzono trzema promptami, jeden po drugim; wielu użytkowników dwa razy większą liczbą żądań po 256 tokenów niż liczba użytkowników, tylu naraz, ilu użytkowników, tak jak wysyła je vllm bench serve.
| Karta | Prompt, tokeny | Z modelu | Szacunek praktyczny | vLLM | Model wobec vLLM | Szacunek praktyczny wobec vLLM |
|---|---|---|---|---|---|---|
| RTX 5090 | 65 536 | 9,874 | 10,783 do 11,424 | 10,875 | −9,2% | w przedziale |
| RTX 5090 | 1024 | 0,082 | 0,149 do 0,151 | 0,150 | −45,4% | w przedziale |
| RTX 5090 | 4096 | 0,339 | 0,448 do 0,452 | 0,433 | −21,6% | +3,3% |
| RTX 5090 | 16 384 | 1,579 | 1,722 do 1,831 | 1,656 | −4,6% | +4,0% |
| RTX 5090 | 32 768 | 3,751 | 3,962 do 4,252 | 3,979 | −5,7% | w przedziale |
| RTX 5090 | 131 072 | 29,235 | 33,264 do 34,608 | 33,710 | −13,3% | w przedziale |
| RTX 5090 | 180 000 | 49,876 | 57,728 do 59,596 | 58,128 | −14,2% | w przedziale |
| RTX 3090 | 1024 | 0,781 | 0,714 do 0,770 | 0,765 | +2,1% | w przedziale |
| RTX 3090 | 4096 | 3,163 | 2,897 do 3,122 | 3,096 | +2,2% | w przedziale |
| RTX 3090 | 8192 | 6,436 | 5,929 do 6,379 | 6,342 | +1,5% | w przedziale |
| RTX 3090 | 12 000 | 9,575 | 8,862 do 9,520 | 9,444 | +1,4% | w przedziale |
| RTX 3090 | 12 500 | 9,994 | 9,253 do 9,938 | 9,868 | +1,3% | w przedziale |
Szacunki zapisano z kart katalogowych i źródeł, zanim zestawiono je z tymi pomiarami, i nic do nich nie dopasowano. Na RTX 3090, gdzie praca nad fragmentem trwa około 0,7 s, są o 1% do 2% za wolne przy każdej zmierzonej długości.
Krótkie prompty na RTX 5090 trwały do 1,8 raza dłużej niż według szacunku. vLLM wydaje operacje promptu z procesora wolniej, niż wynika z , a gdy praca fragmentu na karcie jest krótka, karta na nie czeka: w profilu jednego promptu o długości 4096 tokenów karta była bezczynna przez 0,208 s z 0,514 s, w 5124 przerwach, z których żadna nie trwała dłużej niż 1 ms, a liczniki czasu samego vLLM umieszczają to oczekiwanie wewnątrz jego przetwarzania promptu, a nie przed nim. Długie prompty na RTX 5090 są o 9% do 14% za szybkie, bo uwaga pełna osiągała tam około 68% wydajności 16-bitowej, a nie 85%.
Przy 16 000 tokenów, powyżej limitu vLLM 12 544, RTX 3090 potrzebowała 24,09 s, bo vLLM wywłaszczał każdy prompt 5 razy; szacunek tego nie modeluje. Kalkulator wyznacza limit na 26 656 tokenów przy ustawieniach z pomiarów, bo jego pamięć na rozmowy jest większa niż w vLLM (Pamięć i szybkość dla jednego użytkownika), więc nie pokazuje tam wywłaszczenia.
Przedział praktyczny bierze wartości z profili tego modelu przy 1024 i 65 536 tokenach na RTX 5090 i 1024 na RTX 3090 oraz z liczników vLLM przy 1024 i 4096 tokenach na RTX 5090. Czas vLLM mieści się w nim przy 10 z 12 promptów, a przy 4096 i 16 384 tokenach na RTX 5090 jest krótszy o 3,2% i 3,9%. Z modelem Bielik-11B-v3.0, który nie brał udziału w wyznaczeniu wartości, mieści się w nim przy 7 z 18 promptów: długie były do 6,2% krótsze, krótkie do 8,6% dłuższe.
Wielu użytkowników
Szybkość każdego użytkownika jest o 13 do 38% wyższa niż w vLLM na RTX 5090 i o 18 do 19% wyższa na RTX 3090, w 21 zmierzonych krokach do 16 użytkowników naraz; szybkość vLLM mieści się w przedziale praktycznym we wszystkich 5 krokach na RTX 3090 i w 4 z 16 kroków na RTX 5090.
| Karta | Rozmowa, tokeny | Użytkownicy naraz | Z modelu | Szacunek praktyczny | vLLM | Model wobec vLLM | Szacunek praktyczny wobec vLLM |
|---|---|---|---|---|---|---|---|
| RTX 5090 | 1024 | 2 | 84,4 | 65,4 do 72,8 | 61,2 | +37,9% | +6,9% |
| RTX 5090 | 1024 | 4 | 81,3 | 62,2 do 69,6 | 61,1 | +33,2% | +1,9% |
| RTX 5090 | 1024 | 8 | 75,9 | 56,8 do 63,9 | 62,3 | +21,8% | w przedziale |
| RTX 5090 | 1024 | 16 | 66,9 | 48,3 do 54,9 | 58,7 | +13,9% | −6,5% |
| RTX 5090 | 16 384 | 2 | 80,2 | 62,3 do 69,8 | 59,3 | +35,3% | +5,1% |
| RTX 5090 | 16 384 | 4 | 74,0 | 56,9 do 64,3 | 56,5 | +30,9% | +0,6% |
| RTX 5090 | 4096 | 3 | 81,6 | 62,9 do 70,3 | 61,0 | +33,8% | +3,0% |
| RTX 5090 | 4096 | 6 | 76,3 | 57,8 do 65,1 | 62,7 | +21,8% | w przedziale |
| RTX 5090 | 4096 | 12 | 67,6 | 49,8 do 56,7 | 58,3 | +15,9% | −2,7% |
| RTX 5090 | 32 768 | 2 | 76,3 | 59,3 do 66,9 | 57,2 | +33,3% | +3,7% |
| RTX 5090 | 32 768 | 3 | 71,6 | 55,5 do 63,0 | 55,1 | +30,0% | +0,8% |
| RTX 5090 | 1024 | 2 | 84,4 | 65,4 do 72,8 | 61,2 | +37,8% | +6,8% |
| RTX 3090 | 1024 | 2 | 45,5 | 36,5 do 40,0 | 38,3 | +18,7% | w przedziale |
| RTX 3090 | 1024 | 4 | 43,8 | 34,7 do 38,2 | 37,0 | +18,3% | w przedziale |
| RTX 3090 | 1024 | 4 | 43,8 | 34,7 do 38,2 | 37,2 | +17,9% | w przedziale |
| RTX 5090 | 1024 | 3 | 82,8 | 63,8 do 71,1 | 61,2 | +35,3% | +4,2% |
| RTX 5090 | 1024 | 5 | 79,9 | 60,8 do 68,0 | 66,0 | +21,0% | w przedziale |
| RTX 5090 | 1024 | 16 | 66,9 | 48,3 do 54,9 | 59,1 | +13,2% | −7,0% |
| RTX 5090 | 16 384 | 6 | 68,6 | 52,4 do 59,6 | 57,7 | +18,9% | w przedziale |
| RTX 3090 | 1024 | 3 | 44,7 | 35,6 do 39,1 | 37,6 | +18,7% | w przedziale |
| RTX 3090 | 2048 | 2 | 45,4 | 36,4 do 39,9 | 38,1 | +19,0% | w przedziale |
Szybkość każdego użytkownika jest za szybka z przyczyn błędu jednego użytkownika, podanych w części Pamięć i szybkość dla jednego użytkownika: vLLM odczytuje wagi przy mniej niż 92% przepustowości i uruchamia więcej jąder, niż policzono. Od 5 użytkowników na RTX 5090 szacunek jest o 13% do 22% za szybki, na RTX 3090 o 18% do 19%. Przy 2 do 4 użytkownikach na RTX 5090 jest o 30% do 38% za szybki, z dodatkowej przyczyny, której kalkulator nie liczy: wolniejszej metody biblioteki macierzowej NVIDIA.
Przyczynę wolniejszej metody znaleziono w profilach obu kart: jedną małą macierz warstw uwagi liniowej, mnożoną 48 razy na krok, biblioteka macierzowa NVIDIA przetwarza szybką metodą przy 1 użytkowniku i od 5 użytkowników, a wolną przy 2 do 4, o około 1,2 ms dłużej na krok na RTX 5090 i o 1,4 ms na RTX 3090.
Przedział praktyczny zachowuje wartości zmierzone przy jednym użytkowniku. Szybkość vLLM mieści się w nim we wszystkich 5 krokach na RTX 3090 i w 4 z 16 na RTX 5090. Na RTX 5090 jest od niego niższa przy 2 do 4 użytkownikach, o 0,6% do 6,4%, z powodu wolniejszej metody cuBLAS, której nie było w profilach jednego użytkownika. Od 12 użytkowników jest od niego wyższa, o 2,8% do 7,5%: przedział liczy stały stan i pamięć podręczną każdego kolejnego użytkownika przy udziałach zmierzonych dla jednego.
Z modelem Bielik-11B-v3.0, który nie brał udziału w wyznaczeniu wartości, szybkość vLLM mieści się w przedziale we wszystkich 5 krokach na RTX 3090 i w 2 z 8 kroków na RTX 5090, a w pozostałych 6 jest od niego wyższa, o najwyżej 4,3%.
Od promptu do odpowiedzi
Symulowany średni czas na token jest do 26% za krótki, tak jak kroki; pierwszy token ostatniego użytkownika mieści się w granicach 14% tam, gdzie karta jest stale zajęta, pojawia się do 56% za wcześnie przy krótkich promptach na RTX 5090 i do 65% za wcześnie tam, gdzie kalkulator uruchamia naraz więcej użytkowników niż vLLM. Przedział praktyczny obejmuje całą odpowiedź na jeden prompt przy wszystkich 11 promptach modelu Qwen3.8.
| Karta | Prompt, tokeny | Użytkownicy (naraz) | Czas na token, z modelu | Czas na token, vLLM | Model wobec vLLM | Ostatni pierwszy token, z modelu | Ostatni pierwszy token, vLLM | Model wobec vLLM |
|---|---|---|---|---|---|---|---|---|
| RTX 5090 | 1024 | 2 | 12,1 | 16,3 | −26,1% | 0,16 | 0,30 | −45,3% |
| RTX 5090 | 1024 | 4 | 12,9 | 16,9 | −23,8% | 0,33 | 0,58 | −43,4% |
| RTX 5090 | 1024 | 8 | 14,6 | 17,8 | −18,0% | 0,66 | 1,14 | −42,0% |
| RTX 5090 | 1024 | 16 | 18,0 | 22,1 | −18,5% | 1,33 | 2,54 | −47,5% |
| RTX 5090 | 16 384 | 2 | 16,7 | 20,5 | −18,4% | 3,16 | 3,51 | −9,8% |
| RTX 5090 | 16 384 | 4 | 26,3 | 30,8 | −14,7% | 6,35 | 7,27 | −12,6% |
| RTX 5090 | 4096 | 3 | 14,0 | 17,6 | −20,1% | 1,02 | 1,32 | −22,4% |
| RTX 5090 | 4096 | 6 | 17,6 | 21,1 | −16,7% | 2,05 | 2,78 | −26,4% |
| RTX 5090 | 4096 | 12 | 24,6 | 28,9 | −15,0% | 4,13 | 5,45 | −24,3% |
| RTX 5090 | 32 768 | 2 | 23,4 | 26,2 | −10,9% | 7,52 | 7,86 | −4,4% |
| RTX 5090 | 32 768 | 3 | 34,5 | 36,5 | −5,7% | 11,31 | 12,21 | −7,4% |
| RTX 5090 | 1024 | 2 | 12,1 | 16,3 | −26,0% | 0,16 | 0,33 | −50,4% |
| RTX 3090 | 1024 | 2 | 24,2 | 26,8 | −9,7% | 1,56 | 1,55 | +1,0% |
| RTX 3090 | 1024 | 4 | 29,5 | 31,0 | −4,7% | 3,13 | 3,09 | +1,2% |
| RTX 3090 | 1024 | 5 (4) | 32,2 | 32,1 | +0,2% | 3,91 | 11,15 | −64,9% |
| RTX 3090 | 2048 | 3* | 30,3 | 31,2 | −3,1% | 4,71 | 11,92 | −60,5% |
| RTX 5090 | 1024 | 3 | 12,5 | 16,7 | −25,1% | 0,25 | 0,55 | −55,5% |
| RTX 5090 | 1024 | 5 | 13,3 | 16,1 | −16,9% | 0,41 | 0,69 | −40,5% |
| RTX 5090 | 1024 | 24 (16) | 18,4 | 22,5 | −18,4% | 5,60 | 7,60 | −26,3% |
| RTX 5090 | 16 384 | 6 | 35,8 | 36,7 | −2,7% | 9,56 | 9,86 | −3,0% |
| RTX 3090 | 1024 | 3 | 26,9 | 28,7 | −6,3% | 2,34 | 2,31 | +1,3% |
| RTX 3090 | 2048 | 2 | 23,9 | 26,6 | −10,1% | 3,14 | 3,06 | +2,4% |
* vLLM uruchomił wszystkich 3 użytkowników i wywłaszczył 2 z nich; kalkulator, z większą pamięcią na rozmowy, uruchamia wszystkich 3 bez wywłaszczenia. W nawiasach liczba użytkowników, których vLLM uruchomił naraz, tam, gdzie uruchomił mniej, niż wysłano; kalkulator uruchamia wszystkich 5 na RTX 3090 i 16 na RTX 5090.
Średni czas na token obejmuje kroki, w których odpowiedź czeka na prompty innych użytkowników; był do dwóch razy dłuższy niż czas między tokenami w tym samym pomiarze. Symulacja podaje go do 26% za krótki: jej kroki to kroki z kroku Szybkość dla wielu użytkowników, za szybkie z podanych tam przyczyn, a na RTX 5090 użytkownik dostający odpowiedź w kroku, który przetwarza prompt, wydłużał w profilach mnożenia macierzy vLLM o 13,9 ms, bo biblioteki macierzowe NVIDIA wybierają wolniejsze metody dla 1025 wierszy niż dla 1024, a kalkulator liczy tylko bajty tego użytkownika.
Ostatni pierwszy token mieści się w granicach 14% wszędzie tam, gdzie karta jest zajęta przez cały fragment, a kalkulator uruchamia naraz tylu użytkowników co vLLM: na RTX 3090, a na RTX 5090 od 16 384 tokenów. Przy promptach od 1024 do 4096 tokenów na RTX 5090 pojawia się o 22% do 56% za wcześnie, z przyczyny błędu krótkich promptów opisanej wyżej: krok, który przetwarza prompt, gdy użytkownicy dostają odpowiedzi, uruchamia od 1974 do 2118 małych programów, wobec 1610 dla samego promptu, i to ich uruchamianie wyznacza jego czas.
Na RTX 3090, przy 5 użytkownikach po 1024 tokeny i 3 po 2048, pojawia się o 65% i 61% za wcześnie. Pamięć vLLM mieściła mniej użytkowników niż pamięć kalkulatora: piąty użytkownik czekał na koniec jednej z odpowiedzi, a dwóch z trzech użytkowników zostało wywłaszczonych i ich prompty przetworzono ponownie. Kalkulator uruchamia ich wszystkich naraz.
| Karta | Prompt, tokeny | Użytkownicy (naraz) | Czas na token, szacunek praktyczny | Czas na token, vLLM | Szacunek praktyczny wobec vLLM | Ostatni pierwszy token, szacunek praktyczny | Ostatni pierwszy token, vLLM | Szacunek praktyczny wobec vLLM |
|---|---|---|---|---|---|---|---|---|
| RTX 5090 | 1024 | 2 | 14,1 do 15,7 | 16,3 | −3,7% | 0,30 do 0,30 | 0,30 | +0,001% |
| RTX 5090 | 1024 | 4 | 15,6 do 17,3 | 16,9 | w przedziale | 0,60 do 0,60 | 0,58 | +3,3% |
| RTX 5090 | 1024 | 8 | 18,4 do 20,4 | 17,8 | +3,5% | 1,20 do 1,22 | 1,14 | +5,9% |
| RTX 5090 | 1024 | 16 | 24,1 do 26,6 | 22,1 | +9,3% | 2,43 do 2,46 | 2,54 | −3,3% |
| RTX 5090 | 16 384 | 2 | 18,9 do 20,9 | 20,5 | w przedziale | 3,45 do 3,67 | 3,51 | w przedziale |
| RTX 5090 | 16 384 | 4 | 29,4 do 32,2 | 30,8 | w przedziale | 6,93 do 7,37 | 7,27 | w przedziale |
| RTX 5090 | 4096 | 3 | 16,6 do 18,3 | 17,6 | w przedziale | 1,35 do 1,36 | 1,32 | +2,3% |
| RTX 5090 | 4096 | 6 | 21,3 do 23,3 | 21,1 | +1,2% | 2,70 do 2,73 | 2,78 | −1,9% |
| RTX 5090 | 4096 | 12 | 30,7 do 33,1 | 28,9 | +6,2% | 5,45 do 5,51 | 5,45 | w przedziale |
| RTX 5090 | 32 768 | 2 | 25,7 do 28,4 | 26,2 | w przedziale | 7,94 do 8,53 | 7,86 | +1,0% |
| RTX 5090 | 32 768 | 3 | 37,4 do 41,0 | 36,5 | +2,3% | 11,94 do 12,83 | 12,21 | w przedziale |
| RTX 5090 | 1024 | 2 | 14,1 do 15,7 | 16,3 | −3,7% | 0,30 do 0,30 | 0,33 | −8,4% |
| RTX 3090 | 1024 | 2 | 27,0 do 29,5 | 26,8 | +0,7% | 1,43 do 1,54 | 1,55 | −0,3% |
| RTX 3090 | 1024 | 4 | 32,3 do 35,4 | 31,0 | +4,2% | 2,86 do 3,09 | 3,09 | −0,1% |
| RTX 3090 | 1024 | 5 (4) | 34,9 do 38,3 | 32,1 | +8,8% | 3,57 do 3,86 | 11,15 | −65,4% |
| RTX 3090 | 2048 | 3* | 32,7 do 35,8 | 31,2 | +4,8% | 4,30 do 4,64 | 11,92 | −61,1% |
| RTX 5090 | 1024 | 3 | 14,9 do 16,5 | 16,7 | −1,1% | 0,45 do 0,45 | 0,55 | −17,9% |
| RTX 5090 | 1024 | 5 | 16,3 do 18,0 | 16,1 | +1,4% | 0,75 do 0,76 | 0,69 | +8,6% |
| RTX 5090 | 1024 | 24 (16) | 24,8 do 27,3 | 22,5 | +10,3% | 8,03 do 8,68 | 7,60 | +5,7% |
| RTX 5090 | 16 384 | 6 | 39,8 do 43,4 | 36,7 | +8,2% | 10,44 do 11,11 | 9,86 | +5,8% |
| RTX 3090 | 1024 | 3 | 29,6 do 32,5 | 28,7 | +3,4% | 2,14 do 2,31 | 2,31 | −0,02% |
| RTX 3090 | 2048 | 2 | 26,7 do 29,3 | 26,6 | +0,6% | 2,86 do 3,09 | 3,06 | w przedziale |
Przedział praktyczny przechodzi tę samą symulację z krokami praktycznymi. W tabeli średni czas na token vLLM mieści się w nim w 5 z 22 kroków, a ostatni pierwszy token w 5; z modelem Bielik-11B-v3.0 w 2 i 9 z 13. Średni czas na token jest przeważnie krótszy niż przedział, o najwyżej 9,3%, tak jak praktyczne kroki wielu użytkowników (Wielu użytkowników).
Ostatni pierwszy token mieści się w granicach 8% od przedziału w 30 z 35 kroków. Pojawił się później przy 2 i 3 użytkownikach po 1024 tokeny na RTX 5090 (o 9,2% i 21,7%), przy 2 użytkownikach 16-bitowego Bielika na RTX 3090 (o 19,8%) i znacznie później tam, gdzie vLLM uruchomił naraz mniej użytkowników niż kalkulator: o 157% i 189% na RTX 3090. Cała odpowiedź na jeden prompt i 256 tokenów mieści się w przedziale przy wszystkich 11 promptach modelu Qwen3.8 i 4 z 18 promptów Bielika, a pozostałe są do 9,1% krótsze.
Jeden z błędów symulacji nie ma ustalonej przyczyny. Pierwszy token pierwszego użytkownika pojawiał się o 0,10 do 0,71 s później niż w symulacji na obu kartach, także tam, gdzie sam prompt trwał mniej więcej tyle, ile szacowano: o 0,37 s później przy 1024 tokenach na RTX 3090. Profile pokazują jego prompt przetwarzany samodzielnie w pierwszym kroku, tak jak w symulacji. Ustalenie przyczyny wymaga pomiaru czasu każdego żądania przez sam vLLM przy wielu użytkownikach, którego nie wykonano.
Bielik-11B-v3.0
Z modelem Bielik-11B-v3.0 pamięć na rozmowy jest o 2% do 7% większa niż w vLLM, o 60% z wagami 16-bitowymi na RTX 3090; szybkość jednego użytkownika jest o 4% do 20% wyższa niż w vLLM; czas do pierwszego tokenu mieści się w granicach 9%, ale jest o 21% krótszy przy 1024 tokenach z wagami 8-bitowymi na RTX 5090; liczba użytkowników naraz zgadza się we wszystkich 13 krokach.
vLLM uruchamiał Bielik-11B-v3.0-Instruct, z wagami w 16 bitach (BF16) i w 8 bitach (FP8-Dynamic), na tych samych dwóch kartach, przy ustawieniach domyślnych, 16-bitowej pamięci podręcznej, 92% pamięci i limicie 16 użytkowników naraz. Wartości kalkulatora dla tego modelu zapisano z plików modelu, jego konfiguracji i kodu vLLM przed pomiarami i żadnej z nich, także w szacunkach praktycznych, nie wzięto z pomiarów. Wagi 16-bitowe mieszczą się na RTX 3090 tylko przy rozmowach do 1968 tokenów, więc zmierzono je tam przy 512 do 1536 tokenach.
| Karta | Wagi | Z modelu | Szacunek praktyczny | vLLM | Model wobec vLLM | Szacunek praktyczny wobec vLLM | Tokeny, z modelu | Tokeny, szacunek praktyczny | Tokeny, vLLM | Model wobec vLLM | Szacunek praktyczny wobec vLLM |
|---|---|---|---|---|---|---|---|---|---|---|---|
| RTX 3090 | 8 bitów | 11,554 GB | 10,449 do 11,283 GB | 11,307 GB | +2,2% | −0,2% | 56 400 | 50 992 do 55 072 | 55 200 | +2,2% | −0,2% |
| RTX 3090 | 16 bitów | 0,6534 GB | 0,0000 do 0,2685 GB | 0,4080 GB | +60,1% | −34,2% | 3168 | 0 do 1280 | 1983 | +59,8% | −35,5% |
| RTX 5090 | 8 bitów | 19,428 GB | 18,322 do 19,157 GB | 18,909 GB | +2,7% | w przedziale | 94 832 | 89 440 do 93 520 | 92 288 | +2,8% | w przedziale |
| RTX 5090 | 16 bitów | 8,527 GB | 7,269 do 8,142 GB | 7,978 GB | +6,9% | w przedziale | 41 616 | 35 472 do 39 728 | 38 960 | +6,8% | w przedziale |
| Karta | Wagi | Rozmowa, tokeny | Z modelu | Szacunek praktyczny | vLLM | Model wobec vLLM | Szacunek praktyczny wobec vLLM |
|---|---|---|---|---|---|---|---|
| RTX 3090 | 8 bitów | 1024 | 72,95 | 56,96 do 62,93 | 64,50 | +13,1% | −2,4% |
| RTX 3090 | 8 bitów | 4096 | 69,26 | 54,19 do 60,27 | 60,12 | +15,2% | w przedziale |
| RTX 3090 | 8 bitów | 8192 | 64,88 | 50,88 do 57,05 | 56,09 | +15,7% | w przedziale |
| RTX 3090 | 8 bitów | 16 384 | 57,60 | 45,35 do 51,54 | 49,55 | +16,2% | w przedziale |
| RTX 3090 | 8 bitów | 24 000 | 52,16 | 41,19 do 47,30 | 45,37 | +15,0% | w przedziale |
| RTX 3090 | 16 bitów | 512 | 38,10 | 30,97 do 33,67 | 34,49 | +10,5% | −2,4% |
| RTX 3090 | 16 bitów | 1024 | 37,93 | 30,82 do 33,54 | 34,36 | +10,4% | −2,4% |
| RTX 3090 | 16 bitów | 1536 | 37,75 | 30,68 do 33,41 | 33,92 | +11,3% | −1,5% |
| RTX 5090 | 8 bitów | 1024 | 134,81 | 98,00 do 110,92 | 114,11 | +18,1% | −2,8% |
| RTX 5090 | 8 bitów | 4096 | 128,21 | 93,69 do 106,58 | 109,74 | +16,8% | −2,9% |
| RTX 5090 | 8 bitów | 8192 | 120,36 | 88,50 do 101,30 | 99,95 | +20,4% | w przedziale |
| RTX 5090 | 8 bitów | 16 384 | 107,23 | 79,67 do 92,17 | 90,18 | +18,9% | w przedziale |
| RTX 5090 | 8 bitów | 24 000 | 97,35 | 72,91 do 85,04 | 85,23 | +14,2% | −0,2% |
| RTX 5090 | 16 bitów | 1024 | 71,50 | 55,93 do 61,65 | 68,41 | +4,5% | −9,9% |
| RTX 5090 | 16 bitów | 4096 | 69,60 | 54,50 do 60,29 | 66,63 | +4,5% | −9,5% |
| RTX 5090 | 16 bitów | 8192 | 67,22 | 52,70 do 58,56 | 63,10 | +6,5% | −7,2% |
| RTX 5090 | 16 bitów | 16 384 | 62,92 | 49,44 do 55,39 | 58,90 | +6,8% | −6,0% |
| RTX 5090 | 16 bitów | 24 000 | 59,38 | 46,75 do 52,73 | 56,86 | +4,4% | −7,3% |
| Karta | Wagi | Prompt, tokeny | Z modelu | Szacunek praktyczny | vLLM | Model wobec vLLM | Szacunek praktyczny wobec vLLM |
|---|---|---|---|---|---|---|---|
| RTX 3090 | 8 bitów | 1024 | 0,347 | 0,318 do 0,341 | 0,335 | +3,8% | w przedziale |
| RTX 3090 | 8 bitów | 4096 | 1,473 | 1,360 do 1,448 | 1,403 | +5,0% | w przedziale |
| RTX 3090 | 8 bitów | 8192 | 3,173 | 3,003 do 3,178 | 3,012 | +5,3% | w przedziale |
| RTX 3090 | 8 bitów | 16 384 | 7,254 | 7,135 do 7,486 | 6,914 | +4,9% | +3,2% |
| RTX 3090 | 8 bitów | 24 000 | 11,864 | 11,991 do 12,506 | 11,358 | +4,5% | +5,6% |
| RTX 3090 | 16 bitów | 512 | 0,172 | 0,167 do 0,173 | 0,188 | −8,5% | −8,0% |
| RTX 3090 | 16 bitów | 1024 | 0,347 | 0,329 do 0,341 | 0,359 | −3,1% | −5,0% |
| RTX 3090 | 16 bitów | 1536 | 0,526 | 0,493 do 0,513 | 0,523 | +0,5% | −2,1% |
| RTX 5090 | 8 bitów | 1024 | 0,064 | 0,076 do 0,078 | 0,081 | −20,7% | −4,6% |
| RTX 5090 | 8 bitów | 4096 | 0,285 | 0,276 do 0,297 | 0,295 | −3,4% | w przedziale |
| RTX 5090 | 8 bitów | 8192 | 0,647 | 0,647 do 0,690 | 0,661 | −2,0% | w przedziale |
| RTX 5090 | 8 bitów | 16 384 | 1,603 | 1,678 do 1,764 | 1,606 | −0,2% | +4,5% |
| RTX 5090 | 8 bitów | 24 000 | 2,769 | 2,983 do 3,109 | 2,798 | −1,0% | +6,6% |
| RTX 5090 | 16 bitów | 1024 | 0,121 | 0,118 do 0,124 | 0,129 | −6,4% | −3,8% |
| RTX 5090 | 16 bitów | 4096 | 0,510 | 0,481 do 0,511 | 0,492 | +3,7% | w przedziale |
| RTX 5090 | 16 bitów | 8192 | 1,096 | 1,054 do 1,119 | 1,066 | +2,8% | w przedziale |
| RTX 5090 | 16 bitów | 16 384 | 2,502 | 2,489 do 2,621 | 2,445 | +2,3% | +1,8% |
| RTX 5090 | 16 bitów | 24 000 | 4,085 | 4,169 do 4,365 | 4,038 | +1,2% | +3,2% |
| Karta | Wagi | Rozmowa, tokeny | Użytkownicy naraz, vLLM (z modelu) | Z modelu | Szacunek praktyczny | vLLM | Model wobec vLLM | Szacunek praktyczny wobec vLLM |
|---|---|---|---|---|---|---|---|---|
| RTX 3090 | 8 bitów | 1024 | 4 (4) | 68,7 | 53,9 do 59,9 | 59,4 | +15,7% | w przedziale |
| RTX 3090 | 8 bitów | 1024 | 8 (8) | 63,7 | 50,2 do 56,4 | 54,5 | +17,0% | w przedziale |
| RTX 3090 | 8 bitów | 1024 | 16 (16) | 55,6 | 44,2 do 50,4 | 46,9 | +18,6% | w przedziale |
| RTX 3090 | 8 bitów | 4096 | 8 (8) | 46,4 | 36,9 do 42,8 | 40,9 | +13,5% | w przedziale |
| RTX 3090 | 16 bitów | 512 | 2 (2) | 37,9 | 30,8 do 33,5 | 33,2 | +14,0% | w przedziale |
| RTX 5090 | 8 bitów | 1024 | 4 (4) | 127,2 | 93,2 do 106,1 | 109,4 | +16,3% | −3,0% |
| RTX 5090 | 8 bitów | 1024 | 8 (8) | 118,3 | 87,4 do 100,2 | 102,3 | +15,6% | −2,0% |
| RTX 5090 | 8 bitów | 1024 | 16 (16) | 103,7 | 77,9 do 90,3 | 91,3 | +13,6% | −1,1% |
| RTX 5090 | 8 bitów | 4096 | 8 (8) | 86,9 | 65,8 do 77,4 | 77,8 | +11,7% | −0,4% |
| RTX 5090 | 16 bitów | 1024 | 4 (4) | 69,3 | 54,3 do 60,1 | 62,7 | +10,6% | −4,1% |
| RTX 5090 | 16 bitów | 1024 | 8 (8) | 66,6 | 52,3 do 58,2 | 58,2 | +14,3% | −0,1% |
| RTX 5090 | 16 bitów | 1024 | 16 (16) | 61,7 | 48,7 do 54,7 | 53,9 | +14,5% | w przedziale |
| RTX 5090 | 16 bitów | 4096 | 8 (8) | 55,3 | 43,7 do 49,7 | 49,5 | +11,9% | w przedziale |
Pamięć na rozmowy jest o 2% do 7% większa niż w vLLM, a o 60% z wagami 16-bitowymi na RTX 3090, gdzie 0,24 GB to dużo wobec 0,41 GB, które zostają po 22,34 GB wag: pamięć robocza vLLM była o 0,13 GiB większa niż w kalkulatorze, jego największy krok większy, niż policzono, a pamięć, którą widział, o około 0,10 GiB mniejsza niż pamięć z karty katalogowej bez rezerwy. vLLM wczytał wagi w takiej postaci, w jakiej zawierają je pliki. Odpowiedź, czy rozmowa danej długości się mieści, była trafna we wszystkich czterech pomiarach.
Szybkość jednego użytkownika jest za wysoka z przyczyn ustalonych dla Qwen3.8: mnożenia macierzy odczytują wagi poniżej 92% przepustowości, a vLLM uruchamia więcej jąder, niż policzono. Najbliżej są wagi 16-bitowe na RTX 5090, odczytywane zwykłymi 16-bitowymi jądrami, o 4% do 7%; najdalej wagi 8-bitowe na RTX 5090, których dane wejściowe kwantyzuje osobne jądro, o 14% do 20%. Bielika nie profilowano, więc podziału na przyczyny nie zmierzono.
Czas do pierwszego tokenu mieści się w granicach 9% wszędzie poza promptem o długości 1024 tokenów z wagami 8-bitowymi na RTX 5090, o 21% krótszym: tak jak przy Qwen3.8 krótki fragment na RTX 5090 czeka na procesor, co szacunek praktyczny uwzględnia. Czas kalkulatora do gotowej odpowiedzi o długości 256 tokenów jest o 1% do 16% krótszy, bo jego szybkość jest za wysoka. Przy wielu użytkownikach liczba użytkowników naraz zgadza się we wszystkich 13 krokach, a szybkość każdego użytkownika jest o 11% do 19% za wysoka, z przyczyn ustalonych dla jednego użytkownika.
Wartości vLLM mieszczą się w przedziałach praktycznych przy 6 z 18 długości dla szybkości jednego użytkownika, 7 z 18 promptów, 7 z 13 kroków wielu użytkowników i 2 z 4 pomiarów pamięci. W pozostałych vLLM był przeważnie szybszy niż przedziały albo zostawiał więcej pamięci: ich wartości pochodzą z profili i pomiarów modelu Qwen3.8.
Arete-27B
Na RTX 3090 szacowana szybkość jednego użytkownika jest o 14% do 16% wyższa niż w vLLM przy sześciu długościach, a szybkość vLLM mieści się w przedziale praktycznym we wszystkich sześciu. Czas do pierwszego tokenu mieści się w granicach 6%, a czas vLLM jest najwyżej o 2,2% dłuższy niż przedział praktyczny. Przy dwóch użytkownikach szacowana szybkość każdego użytkownika jest o 21% wyższa niż w vLLM i mieści się w przedziale praktycznym.
Przy dozwolonych obrazach pamięć na rozmowy jest o 7% i 22% większa niż w vLLM w dwóch startach, a przedział praktyczny obejmuje jeden z nich i do drugiego brakuje mu 2,4%. W trybie tylko tekstu jest o 55% większa, bo pamięć robocza vLLM była o 2,0 GB większa, niż liczy kalkulator, z przyczyny jeszcze nieznanej. Dlatego przedział praktyczny dla trybu tylko tekstu przyjmuje pamięć roboczą zmierzoną w tym starcie.
Arete-27B w wersji 4-bitowej (W4A16) działał na karcie GeForce RTX 3090 z tym samym vLLM. Jego szacunki zapisano przed zestawieniem z tymi pomiarami, z wyjątkiem przedziału praktycznego pamięci w trybie tylko tekstu, który przyjmuje jeden z nich.
| Karta | Ustawienia | Z modelu | Szacunek praktyczny | vLLM | Model wobec vLLM | Szacunek praktyczny wobec vLLM | Tokeny, z modelu | Tokeny, szacunek praktyczny | Tokeny, vLLM | Model wobec vLLM | Szacunek praktyczny wobec vLLM |
|---|---|---|---|---|---|---|---|---|---|---|---|
| RTX 3090 | 95%, pamięć podręczna 16 bitów | 3,525 GB | 2,314 do 3,181 GB | 2,899 GB | +21,6% | w przedziale | 47 824 | 29 792 do 42 336 | 33 981 | +40,7% | w przedziale |
| RTX 3090 | 98,9%, pamięć podręczna 8 bitów, tylko tekst | 6,443 GB | 3,940 do 4,263 GB | 4,155 GB | +55,0% | w przedziale | 185 024 | 108 192 do 117 600 | 108 669 | +70,3% | w przedziale |
| RTX 3090 | 98,9%, pamięć podręczna 8 bitów | 4,097 GB | 2,879 do 3,754 GB | 3,844 GB | +6,6% | −2,3% | 112 896 | 76 832 do 103 488 | 100 519 | +12,3% | w przedziale |
| Karta | Ustawienia | Rozmowa, tokeny | Z modelu | Szacunek praktyczny | vLLM | Model wobec vLLM | Szacunek praktyczny wobec vLLM |
|---|---|---|---|---|---|---|---|
| RTX 3090 | 95%, pamięć podręczna 16 bitów | 1024 | 53,42 | 42,91 do 47,05 | 46,82 | +14,1% | w przedziale |
| RTX 3090 | 95%, pamięć podręczna 16 bitów | 8192 | 51,90 | 41,71 do 45,92 | 44,91 | +15,6% | w przedziale |
| RTX 3090 | 98,9%, pamięć podręczna 8 bitów, tylko tekst | 1024 | 53,54 | 43,01 do 47,14 | 46,85 | +14,3% | w przedziale |
| RTX 3090 | 98,9%, pamięć podręczna 8 bitów, tylko tekst | 8192 | 52,77 | 42,40 do 46,57 | 45,90 | +15,0% | w przedziale |
| RTX 3090 | 98,9%, pamięć podręczna 8 bitów, tylko tekst | 32 768 | 50,29 | 40,42 do 44,70 | 43,90 | +14,5% | w przedziale |
| RTX 3090 | 98,9%, pamięć podręczna 8 bitów, tylko tekst | 65 536 | 47,32 | 38,06 do 42,42 | 41,52 | +14,0% | w przedziale |
| Karta | Ustawienia | Prompt, tokeny | Z modelu | Szacunek praktyczny | vLLM | Model wobec vLLM | Szacunek praktyczny wobec vLLM |
|---|---|---|---|---|---|---|---|
| RTX 3090 | 98,9%, pamięć podręczna 8 bitów, tylko tekst | 1024 | 0,781 | 0,714 do 0,770 | 0,787 | −0,8% | −2,2% |
| RTX 3090 | 98,9%, pamięć podręczna 8 bitów, tylko tekst | 8192 | 6,436 | 5,929 do 6,379 | 6,400 | +0,6% | −0,3% |
| RTX 3090 | 98,9%, pamięć podręczna 8 bitów, tylko tekst | 32 768 | 28,358 | 26,939 do 28,735 | 28,954 | −2,1% | −0,8% |
| RTX 3090 | 98,9%, pamięć podręczna 8 bitów, tylko tekst | 65 536 | 63,695 | 62,547 do 66,139 | 67,188 | −5,2% | −1,6% |
| Karta | Ustawienia | Rozmowa, tokeny | Użytkownicy naraz, vLLM (z modelu) | Z modelu | Szacunek praktyczny | vLLM | Model wobec vLLM | Szacunek praktyczny wobec vLLM |
|---|---|---|---|---|---|---|---|---|
| RTX 3090 | 98,9%, pamięć podręczna 8 bitów, tylko tekst | 16 384 | 2 (2) | 49,3 | 39,3 do 43,6 | 40,8 | +20,8% | w przedziale |
Qwen3.8-27B na H200 NVL
Na H200 NVL szacowany czas do pierwszego tokenu jest o 44% do 52% krótszy niż w vLLM, bo vLLM wykonuje tam uwagę w 8 bitach, wolniej niż w 16 bitach przyjętych w szacunku. Czas vLLM mieści się w przedziale praktycznym albo jest o 1,2% dłuższy niż przedział dla promptów około 4000 tokenów, a od 129 189 tokenów jest dłuższy o 9% do 12%, głównie przez warstwę, która z wyprzedzeniem proponuje kolejne tokeny, a której kalkulator nie modeluje.
8-bitowy wariant Qwen3.8-27B działał na karcie H200 NVL z tym samym vLLM, z 75% pamięci karty, pamięcią podręczną 8 bitów, w trybie tylko tekstu i z dodatkową warstwą, która z wyprzedzeniem proponuje trzy kolejne tokeny (MTP). Każdy czas to pierwsze pytanie do nowego dokumentu, bez innych żądań na karcie.
Z pamięcią podręczną 8 bitów na H100 NVL i H200 NVL vLLM wykonuje uwagę w 8 bitach. Zmierzone osobno przy rozmiarach tych promptów, to jądro osiągnęło 389 TFLOPS, 23% najwyższej wydajności 8-bitowej karty, mniej niż to samo jądro w 16 bitach, 650 do 683 TFLOPS; 8-bitowe mnożenia macierzy osiągnęły 65% do 72% najwyższej wydajności 8-bitowej, niższą wartość wtedy, gdy karta utrzymywała je przy swoim limicie mocy. Przedział praktyczny przyjmuje te wartości. Szacunek z modelu zachowuje 16-bitową uwagę ze źródeł: żadne źródło nie podaje wartości dla tego jądra w 8 bitach.
Warstwa proponująca tokeny z wyprzedzeniem także przetwarza każdy prompt: to jeszcze jedna warstwa uwagi pełnej z jej wagami, około 2,2 s przy 254 332 tokenach. Razem z nią i z jądrami przekształcającymi wejścia 8-bitowych mnożeń macierzy, które na tej karcie działają osobno, około 1,4 s więcej, przedział praktyczny różni się od czasów vLLM o 2% do 9%.
| Karta | Ustawienia | Prompt, tokeny | Z modelu | Szacunek praktyczny | vLLM | Model wobec vLLM | Szacunek praktyczny wobec vLLM |
|---|---|---|---|---|---|---|---|
| H200 NVL | 75%, pamięć podręczna 8 bitów, tylko tekst, MTP | 3845 | 0,150 | 0,298 do 0,320 | 0,303 | −50,3% | w przedziale |
| H200 NVL | 75%, pamięć podręczna 8 bitów, tylko tekst, MTP | 129 189 | 9,494 | 14,497 do 15,320 | 16,965 | −44,0% | −9,7% |
| H200 NVL | 75%, pamięć podręczna 8 bitów, tylko tekst, MTP | 253 763 | 27,403 | 44,406 do 46,028 | 50,804 | −46,1% | −9,4% |
| H200 NVL | 75%, pamięć podręczna 8 bitów, tylko tekst, MTP | 3954 | 0,155 | 0,298 do 0,320 | 0,324 | −52,2% | −1,2% |
| H200 NVL | 75%, pamięć podręczna 8 bitów, tylko tekst, MTP | 129 231 | 9,499 | 14,497 do 15,320 | 17,302 | −45,1% | −11,5% |
| H200 NVL | 75%, pamięć podręczna 8 bitów, tylko tekst, MTP | 254 332 | 27,505 | 44,615 do 46,239 | 50,866 | −45,9% | −9,1% |
Cytowanie: Jacek Garbuliński, Kalkulator LLM na GPU, Blixild, 2026, https://blixild.pl/kalkulator-llm-gpu.html
Pytania i odpowiedzi
Kiedy i po co korzystać z tego kalkulatora?
Przed zakupem albo wynajęciem karty lub wyborem precyzji modelu, aby sprawdzić, czy model mieści się przy potrzebnej liczbie użytkowników i długości rozmów, jak długo każdy użytkownik czeka na pierwszy token i jaką szybkość potem otrzymuje. Kalkulator pokazuje, jak pamięć i szybkość zależą od siebie: dłuższa rozmowa albo więcej użytkowników zajmuje pamięć i spowalnia każdy token, a prompty wielu użytkowników opóźniają nawzajem ich odpowiedzi. Wyniki opierają się na plikach modelu, kartach katalogowych, kodzie vLLM i opublikowanych pomiarach; rozstrzyga test na karcie.
Dlaczego szybkość zależy od przepustowości pamięci, a nie od mocy obliczeniowej karty?
Dla jednego użytkownika każdy nowy token potrzebuje raz każdej wagi, której używa, a każda waga wymaga tylko kilku operacji. Nowoczesna karta wykonuje te operacje szybciej, niż może odczytać wagi ze swojej pamięci, więc tempo wyznacza odczyt. Dlatego limit przepustowości, , ogranicza szybkość i dlatego mniej bitów na wagę sprawia, że model jest nie tylko mniejszy, ale i szybszy.
Czym jest pamięć robocza oprogramowania serwującego i dlaczego różni się między kartami?
To pamięć, której vLLM używa poza wagami i rozmowami: pamięć potrzebna jego największemu krokowi, nagrane grafy CUDA i obszary robocze jego bibliotek. vLLM wyznacza ją przy starcie, a resztę zostawia na rozmowy. Kalkulator liczy ją z kodu vLLM: dla modelu 4-bitowego przy ustawieniach domyślnych vLLM 2,547 GB na RTX 5090 i 2,518 GB na RTX 3090, w większości na krok kodera obrazu. W pomiarach vLLM zajął o 0,79 i 0,19 GB więcej, niż policzono, głównie na grafy CUDA, więc zostawił na rozmowy mniej niż kalkulator.
Dlaczego dłuższa rozmowa spowalnia każdy token?
Bo każdy nowy token odczytuje całą pamięć podręczną warstw uwagi pełnej, która rośnie o z każdym tokenem. Na RTX 5090 jeden użytkownik otrzymywał 67,34 tokenu na sekundę przy 1024 tokenach i 57,36 przy 131 072; szacunek kalkulatora spada z 85,98 do 70,35 i przy obu długościach jest za szybki, z powodów opisanych w części Porównanie z pomiarami. Warstwy uwagi liniowej przechowują zamiast tego stały stan, dlatego spowolnienie jest umiarkowane: pamięć podręczną przechowuje tylko 16 z 64 warstw.
Dlaczego model 4-bitowy działa na RTX 3090, która nie ma obliczeń 4-bitowych?
vLLM przechowuje wagi w pamięci w 4 bitach i w trakcie użycia rozszerza je do 16 bitów. Karta nadal odczytuje 4 bity na wagę, więc odczyt, który wyznacza szybkość, jest taki jak na karcie z natywną obsługą 4 bitów. Zmierzono 41,09 tokenu na sekundę, 79% limitu przepustowości. Ten pomiar wykonano przy udziale pamięci 98%: przy domyślnych 92% wagi i pamięć robocza vLLM nie zostawiają na tej karcie miejsca na rozmowę i vLLM się nie uruchamia.
Czy model 8-bitowy mieści się na tych kartach?
Według kalkulatora nie przy ustawieniach domyślnych vLLM: jego wagi zajmują 30,39 GB, więcej niż 23,24 GB, których vLLM może użyć na RTX 3090, a na RTX 5090 wagom i pamięci roboczej brakuje 1,796 GB; karty RTX 3080, 4080, 5070 i 5080 mają od 10 do 16 GB, mniej niż zajmują wagi. Na kartach A100 80GB PCIe, H100 NVL i H200 NVL mieści się, z miejscem na rozmowę jednego użytkownika o pełnej długości modelu, 262 144 tokeny. Nie zmierzono go.
Ilu użytkowników może korzystać z jednej karty?
Tylu, dla ilu rozmów wystarcza pamięć, co pokazuje krok Pamięć, do limitu vLLM wynoszącego 256 naraz. Każdy kolejny użytkownik kosztuje znacznie mniej niż pierwszy, bo karta w każdym kroku odczytuje wagi raz dla wszystkich użytkowników: na RTX 5090 jeden użytkownik otrzymywał 68,9 tokenu na sekundę, a 16 użytkowników po 58,7, razem 940. Krok Szybkość dla wielu użytkowników szacuje je o 13% do 38% za szybko w zmierzonych krokach, a krok Od promptu do odpowiedzi pokazuje, jak długo każdy użytkownik czeka, gdy przetwarzane są prompty innych.
Dlaczego pierwszy token pojawia się później, gdy kilku użytkowników wysyła prompty w tej samej chwili?
Bo vLLM przetwarza prompty jeden po drugim, mniej więcej jeden fragment o długości 1568 tokenów na krok, gdy pisane są odpowiedzi, więc pierwszy token ostatniego użytkownika pojawia się mniej więcej po czasie wszystkich promptów. Na RTX 5090 16 użytkowników z promptami po 1024 tokeny otrzymało pierwsze tokeny po czasie od 0,36 do 2,54 s. Odpowiedzi już rozpoczęte zwalniają w tym czasie, bo każdy krok z fragmentem promptu trwa tyle co ten fragment; krok Od promptu do odpowiedzi pokazuje jedno i drugie.
Ograniczenia
Kalkulator szacuje pamięć i szybkość z kart katalogowych, plików modelu i kodu oprogramowania serwującego, a rzeczywista konfiguracja może się od niego różnić w opisany niżej sposób.
- Osiągana przepustowość. Przyjęto, że każdy bajt jest przesyłany przy 92% przepustowości podanej przez producenta, czyli udziale osiągniętym w teście pamięci. Mnożenia macierzy, które przy odczycie rozpakowują wagi 4- lub 8-bitowe, zwykle osiągają mniej, w stopniu zależnym od jądra, formatu liczb i karty, i wtedy szybkość jest niższa od szacowanej.
- Jądra. Jądra uruchamiane przy tokenie policzono z kodu oprogramowania serwującego, a operacje, które kompilator ma połączyć, liczono jako jedno. Jeśli połączy ich mniej albo jądro odczytuje pamięć więcej niż raz, każdy token trwa dłużej, o około mikrosekundę na każde dodatkowe jądro.
- Oprogramowanie serwujące. Wartości dotyczą vLLM 0.31.1rc1 przy ustawieniach domyślnych. Inna wersja lub inne oprogramowanie serwujące, praca bez grafów CUDA, dekodowanie spekulacyjne albo inne limity użytkowników i tokenów na krok zmieniają jądra, pamięć roboczą i kolejność obsługi żądań.
- Procesor. Procesor uruchamia jądra promptu jedno po drugim, gdy karta pracuje. Wolniejszy lub zajęty procesor sprawia, że karta czeka, a pierwszy token pojawia się później, niż szacowano.
- Zegary, zasilanie i inne programy. Przepustowość i wydajność obliczeń z karty katalogowej to wartości szczytowe przy zegarze boost. Karta z obniżonym limitem mocy, nagrzana albo współdzielona z innymi programami lub z monitorem osiąga mniej i ma mniej wolnej pamięci.
- Pamięć. Pamięć dostępna dla programów zależy od sterownika i systemu operacyjnego, a pamięć robocza oprogramowania serwującego od jego wersji i ustawień; obie zmieniają liczbę mieszczących się tokenów.
- Obliczenia. Czas nowego tokenu wyznaczono z bajtów, które odczytuje i zapisuje. Przy wielu użytkownikach naraz lub bardzo długich rozmowach obliczenia rosną razem z nimi i mogą trwać dłużej niż odczyt, a wtedy szybkość jest niższa od szacowanej.
- Żądania. Nie liczono czasu, który żądanie spędza poza kartą, w sieci, w tokenizatorze i w kolejce serwera, ani pracy ustawień próbkowania, wyjścia strukturalnego czy zwracanych prawdopodobieństw; każde z nich wydłuża czas oczekiwania użytkownika.
- Modele. Kalkulator obejmuje tylko wymienione modele, na podstawie ich plików i konfiguracji. Model o innej budowie, na przykład tylko z uwagą pełną albo z ekspertami, lub w innym formacie liczb ma inne bajty na token, inną pamięć podręczną i inne jądra.
- Jedna karta. Model podzielony między kilka kart dodaje czas ich komunikacji, którego nie modelowano.
- Porównania. Szacunki zestawiono z pomiarami na dwóch kartach konsumenckich z pamięcią GDDR, RTX 3090 i RTX 5090, dla Qwen3.8-27B w 4 bitach i Bielik-11B-v3.0 w 8 i 16 bitach, a na RTX 3090 także dla Arete-27B, również w trybie tylko tekstu, oraz na H200 NVL dla czasu do pierwszego tokenu 8-bitowego wariantu Qwen3.8-27B. RTX 3080, 4080, 5070 i 5080, A100 80GB PCIe i H100 NVL oraz pozostałe wyniki H200 NVL są szacowane bez porównania.
Źródła
Ghosh, A., Nayak, A., Panwar, A. and Basu, A. (2025). PyGraph: Robust Compiler Support for CUDA Graphs in PyTorch. arXiv:2503.19779v3, §2. https://arxiv.org/
Hoffman, H. and Oh, F. (2024). Constant Time Launch for Straight-Line CUDA Graphs and Other Performance Enhancements. NVIDIA Technical Blog, 11 September 2024. Table 1. https://developer.nvidia.com/
Jarmusch, A., Graddon, N. and Chandrasekaran, S. (2025). Dissecting the NVIDIA Blackwell Architecture with Microbenchmarks. arXiv:2507.10789v2, §IV.D. https://arxiv.org/
Li, H., He, R., Mang, Q., Zhang, Q., Mao, H., Chen, X., Zhou, H., Zhang, H., Cheung, A., Gonzalez, J. and Stoica, I. (2025). Continnum: Efficient and Robust Multi-Turn LLM Agent Scheduling with KV Cache Time-to-Live. arXiv:2511.02230v7, Table 4. https://arxiv.org/
Luo, W., Fan, R., Li, Z., Du, D., Wang, Q. and Chu, X. (2024). Benchmarking and Dissecting the Nvidia Hopper GPU Architecture. IPDPS 2024. arXiv:2402.13499v1, §IV.B and §IV.C. https://arxiv.org/
NVIDIA (2025). NVIDIA RTX Blackwell GPU Architecture, V1.1. Table 1, GeForce RTX 5090 vs GeForce RTX 4090 vs GeForce RTX 3090; Table 4, GeForce RTX 5080 vs GeForce RTX 4080 vs GeForce RTX 3080; Table 6, GeForce RTX 5070 vs GeForce RTX 4070 vs GeForce RTX 3070; GDDR7 Memory Subsystem; Appendix A. https://images.nvidia.com/
NVIDIA (2026). NVIDIA A100, H100 GPU and H200 GPU, product pages, Specifications: A100 80GB PCIe, H100 NVL, H200 NVL. https://www.nvidia.com/
NVIDIA (2026). Qwen3.8-27B-NVFP4, config.json, revision 482ca0f. Hugging Face. https://huggingface.co/
Qwen (2026). Qwen3.8-27B-FP8, config.json, revision 017b9c7. Hugging Face. https://huggingface.co/
NVIDIA (2026). cuBLAS Library, v13.4, §2.4.8. https://docs.nvidia.com/
Zhang, J., Wei, J., Wang, H., Zhang, P., Xu, X., Huang, H., Jiang, K., Chen, J. and Zhu, J. (2025). SageAttention3: Microscaling FP4 Attention for Inference and An Exploration of 8-bit Training. arXiv:2505.11594v3, A.4 and Figure 4. https://arxiv.org/
vLLM (2026). vLLM 0.31.1rc1.dev273, commit 2eb491e18: vllm/
vgerber (2025). IsaacSim 5.x crashes when extension with ogn is disabled while action graph with extension nodes is present. GitHub, isaac-sim/IsaacSim, issue #370, 19 December 2025: nvidia-smi -q of a GeForce RTX 5090, driver 570.195.03. https://github.com/
Wyślij zapytanie
Aby uruchomić model językowy na własnej karcie albo wynająć do tego moc obliczeniową, wyślij zapytanie.
Aby zmierzyć szybkość modeli, które już udostępniamy, zamiast ją szacować, wypróbuj je przez nasze API na ai.blixild.com, płatne za zużyte tokeny.
Prosimy krótko opisać wymagania. Odpowiadamy w ciągu jednego dnia roboczego.
kontakt@blixild.com