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.

Kalkulator LLM na GPU: od danych do wynikówSześć kroków z danymi wejściowymi i wynikami, w kolejności, w jakiej przechodzi przez nie prompt: model i karta, pamięć, przetwarzanie promptu, szybkość dla jednego i wielu użytkowników oraz odpowiedzi w miarę ich powstawania.Dane wejścioweKrokiWynikiModel i precyzja wag, karta, precyzjapamięci podręcznej, obrazyModel i kartaWagi W, pamięć podręczna na token K,stały stan S, pamięć karty Mi przepustowość BW, K, S, M, BUżytkownicy naraz, długośćrozmowy (tokeny), udział pamięciu (%)PamięćCzy się mieści; pamięć na rozmowyi tokeny na użytkownika: teoretycznie,z modelu, praktycznieC, U, TDługość promptu (tokeny)PrzetwarzaniepromptuCzas do pierwszego tokenu: teoretyczny,z modelu, praktyczny; najdłuższy promptbez wywłaszczeniapierwszy tokenSzybkość dlajednegoużytkownikaMaksimum teoretyczne, szacunekz modelu i szacunek praktyczny tokenówna sekundękrok jednegoSzybkość dlawieluużytkownikówUżytkownicy naraz, tokeny na sekundękażdego i razem: maksimum, model,praktykakrok wszystkichDługość odpowiedzi (tokeny)Od promptu doodpowiedziPierwszy token i cała odpowiedź:teoretycznie, z modelu, praktycznie;odpowiedzi na bieżąco

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.

Model i karta

Ten krok przyjmuje wagi modelu i jego pamięć rozmowy oraz pamięć i przepustowość karty.

Każdy nowy token jest obliczany z wag modelu, czyli liczb, których model nauczył się podczas treningu, oraz z pamięci rozmowy użytkownika, czyli liczb, które model przechowuje o dotychczasowej rozmowie. Jedne i drugie są odczytywane z pamięci karty przy każdym tokenie, więc ich rozmiar decyduje zarówno o tym, co się mieści, jak i o tym, jak szybko pojawia się odpowiedź. Wagi zmierzono część po części z plików modelu; do czego służy każda część i ile kosztuje, opisano pod schematami poniżej.

Precyzja to liczba bitów, w których zapisano każdą wagę. Mniej bitów zajmuje mniej pamięci i wymaga odczytu mniejszej liczby bajtów przy każdym tokenie, więc model mieści się na mniejszej karcie i odpowiada szybciej. NVFP4 (4 bity) i FP8 (8 bitów) to formaty liczb firmy NVIDIA; W4A16 zapisuje wagi jako 4-bitowe liczby całkowite, a obliczenia wykonuje w 16 bitach. 27B oznacza 27 miliardów wag. Arete-27B to dostrojona wersja Qwen3.8-27B o tych samych warstwach.

Karta graficzna. Jej pamięć decyduje o tym, co się mieści, a przepustowość pamięci, czyli liczba bajtów na sekundę, które karta może odczytać ze swojej pamięci, decyduje o szybkości.

Precyzja pamięci podręcznej rozmowy

Pamięć podręczna (cache) przechowuje dla każdego tokenu rozmowy klucze i wartości obliczone dla niego przez warstwy uwagi pełnej, aby nie obliczać ich ponownie przy każdym nowym tokenie. Mniej bitów na liczbę mieści więcej tokenów w pamięci i szybciej się odczytuje: 8 bitów mieści dwa razy więcej tokenów niż 16.

Obrazy

Qwen3.8-27B i Arete-27B czytają obrazy oraz tekst. W trybie tylko tekstu vLLM nie wczytuje ich kodera obrazu, co zwalnia około 0,9 GB wag, ale jego własny test pamięci rezerwuje wtedy więcej pamięci roboczej: na RTX 3090 rozmowy zyskały tylko około 0,3 GB. Szacunek praktyczny przyjmuje zmierzoną tam pamięć roboczą; szacunek z modelu nie, bo przyczyna nie jest jeszcze znana. Bielik-11B-v3.0 czyta tylko tekst.

Wagi na karcie WW21,07 GBodczyt na token 17,61 GB
Pamięć podręczna na token KK32,77 kBw 16 warstwach uwagi pełnej
Stały stan na użytkownika SS153,9 MBw 48 warstwach uwagi liniowej
Pamięć karty MM33,85 GBprzepustowość 1792 GB/s

Jak Qwen3.8-27B NVFP4 tworzy jeden nowy token

Pełne obramowania działają przy każdym nowym tokenie, przerywane tylko wtedy, gdy są używane. Rozmiary zmierzono z plików modelu.

Do czego służy każda część i ile kosztuje

  • Tablica osadzeń. Po co: warstwy działają na liczbach, więc każdy token jest najpierw zastępowany swoim wierszem w tej tablicy, po jednym wierszu liczb dla każdego z 248 320 tokenów, które zna model. Koszt: 2,543 GB pamięci, ale przy każdym tokenie odczytywany jest tylko jego wiersz, 10,24 kB, więc tablica kosztuje pamięć i prawie nie spowalnia.
  • Koder obrazu. Po co: pozwala modelowi przyjmować obrazy, zamieniając obraz na tokeny, które mogą czytać warstwy. Koszt: 0,9215 GB pamięci; działa tylko wtedy, gdy wysłano obraz, więc nie spowalnia tekstu.
  • Warstwy. Po co: wykonują pracę modelu; każdy token przechodzi kolejno przez wszystkie 64, a każda warstwa uściśla liczby tokenu za pomocą swoich wag i wcześniejszych tokenów. Koszt: ich wagi, 16,89 GB, są odczytywane przy każdym tokenie, to 93,48% bajtów odczytywanych i zapisywanych przez każdy token. Ich części pokazuje następny schemat.
  • Stan ukryty. Lista 5120 liczb tokenu po wyjściu z ostatniej warstwy. Powstaje na karcie, gdy token przechodzi przez warstwy, i nie jest przechowywana dla użytkownika, więc nie kosztuje ani pamięci, ani szybkości wartych uwagi.
  • Warstwa wyjściowa. Po co: zamienia stan ukryty na ocenę dla każdego tokenu, który zna model, a następny token jest wybierany na podstawie tych ocen. Koszt: 0,7152 GB odczytywane przy każdym tokenie, 3,958% bajtów odczytywanych i zapisywanych przez każdy token.
  • Dodatkowa warstwa predykcji. Po co: zgaduje token po następnym, na potrzeby dekodowania spekulatywnego: oprogramowanie serwujące sprawdza przypuszczenie, tworząc następny token, więc jeden odczyt wag może dać dwa tokeny, gdy przypuszczenie jest trafne. Koszt: 0,8494 GB więcej pamięci, gdy jest wczytana; vLLM wczytuje ją tylko po włączeniu dekodowania spekulatywnego, więc kalkulator ją pomija.

Wnętrze jednej warstwy i stały stan jednego użytkownika

Do czego służy każda część i ile kosztuje

  • Uwaga pełna. Po co: pozwala tokenowi dokładnie sięgnąć do każdego wcześniejszego tokenu rozmowy przez klucz i wartość zachowane dla każdego z nich, czyli pamięć podręczną. Koszt: pamięć podręczna rośnie o 2048 B na token w każdej z 16 warstw uwagi pełnej, łącznie o 32,77 kB na token, a każdy nowy token odczytuje ją całą: przy 4096 tokenach to 134,2 MB, 0,7428% bajtów odczytywanych i zapisywanych przez każdy token. Im dłuższa rozmowa, tym więcej pamięci i tym wolniej powstaje każdy token.
  • Uwaga liniowa. Po co: zamiast pamięci podręcznej przechowuje jedno podsumowanie o stałym rozmiarze, stały stan, więc jej pamięć i odczyty nie rosną wraz z rozmową; podsumowanie o stałym rozmiarze nie może zachować każdego szczegółu długiej rozmowy, który dokładnie zachowują warstwy uwagi pełnej. Koszt: 3,207 MB na warstwę i użytkownika przy dowolnej długości; model ma 48 takich warstw na 16 warstw uwagi pełnej.
  • Głowice. Po co: uwaga jest podzielona na głowice, równoległe części, z których każda śledzi rozmowę na swój sposób. Koszt: pamięć podręczna i stały stan rosną wraz z liczbą głowic i ich rozmiarem, czyli liczbą liczb w każdym kluczu lub wartości.
  • Krótki splot. Po co: przed uwagą liniową mały filtr łączy liczby każdego tokenu z liczbami 3 poprzedzających go tokenów, aby sąsiednie słowa były brane razem. Koszt: przechowuje te tokeny, 61 440 B na warstwę i użytkownika, mało w porównaniu ze stałym stanem.
  • MLP (perceptron wielowarstwowy). Po co: przetwarza liczby każdego tokenu osobno, rozszerzając jego 5120 liczb do 17 408 i zwężając je z powrotem; zawiera większość wag modelu. Koszt: 0,1504 GB na warstwę, 9,626 GB łącznie, odczytywane przy każdym tokenie, 53,27% bajtów odczytywanych i zapisywanych przez każdy token; nie przechowuje niczego dla użytkownika.

Jak działa stały stan

Warstwa uwagi liniowej nie przechowuje pamięci podręcznej minionych tokenów. Każda z jej 48 głowic przechowuje jedną tablicę 128 × 128 liczb, swój stały stan, który podsumowuje dotychczasową rozmowę. Przy każdym nowym tokenie głowica zamienia token na trzy listy po 128 liczb, klucz (czego dotyczy token), wartość (co wnosi) i zapytanie (czego szuka), i przetwarza swoją tablicę w trzech krokach:

  1. Wygaszanie: każda liczba w tablicy jest mnożona przez ten sam czynnik, nieco mniejszy od 1, który warstwa wyznacza z tokenu, więc starsza treść liczy się trochę mniej.
  2. Zapis: to, co tablica przechowuje pod kluczem, jest przesuwane w stronę wartości o udział, który warstwa również wyznacza z tokenu; wartość zastępuje część tego, co tam było, zamiast być dodawana na wierzch.
  3. Odczyt: zapytanie jest mnożone przez tablicę, co daje wynik głowicy; najbardziej liczą się zapisane wartości, których klucze są najbardziej podobne do zapytania.

Tablica ma ten sam rozmiar niezależnie od długości rozmowy: 48 × 128 × 128 liczb po 4 bajty (zapisanych w 32 bitach) = 3,146 MB na warstwę dla każdego użytkownika. Razem ze stanem krótkiego splotu warstwy, czyli ostatnimi 3 tokenami jej 10 240 kanałów, po 2 bajty każdy, warstwa przechowuje 3,207 MB na użytkownika, a 48 warstw uwagi liniowej przechowuje SS = 153,9 MB. Warstwa uwagi pełnej przechowuje natomiast klucz i wartość każdego tokenu, więc jej pamięć podręczna rośnie o KK z każdym tokenem.

Wzory

K=2LfullnkvdbK = 2\, L_{\mathrm{full}}\, n_{\mathrm{kv}}\, d\, b S=Llin(nvdlin2bs+c(k−1)bf)S = L_{\mathrm{lin}}\, (n_v\, d_{\mathrm{lin}}^2\, b_s + c\, (k - 1)\, b_f)

gdzie KK to pamięć podręczna na token w bajtach; 2 liczy klucz i wartość; LfullL_{\mathrm{full}} to liczba warstw uwagi pełnej, nkvn_{\mathrm{kv}} ich głowice przechowujące klucze i wartości, a dd liczba liczb w każdym kluczu lub wartości; bb to liczba bajtów na zapisaną wartość, 1 lub 2; SS to stały stan na użytkownika w bajtach; LlinL_{\mathrm{lin}} to liczba warstw uwagi liniowej, nvn_v ich głowice, a dlind_{\mathrm{lin}} rozmiar głowicy; bsb_s, 4 bajty, to liczba bajtów na liczbę stanu; cc to liczba liczb na token, które przechowuje krótki splot, kk liczba tokenów, które obejmuje, a bfb_f, 2 bajty, liczba bajtów na liczbę jego stanu.

Pamięć podręczna na token 2 × 16 × 4 × 256 × 1 B = 32 768 B = 32,77 kB; stały stan 48 × (48 × 128² × 4 B + 10 240 × 3 × 2 B) = 153,9 MB na użytkownika.

Wread=W−Wemb−WimgW_{\mathrm{read}} = W - W_{\mathrm{emb}} - W_{\mathrm{img}} c=(2nk+nv)dlinc = (2\, n_k + n_v)\, d_{\mathrm{lin}}

WW to wszystko, co wczytuje oprogramowanie serwujące: każda część plików modelu oprócz dodatkowej warstwy predykcji, której vLLM nie wczytuje, jeśli nie włączono dekodowania spekulatywnego. WreadW_{\mathrm{read}} to część odczytywana przy każdym nowym tokenie: WW bez tablicy osadzeń WembW_{\mathrm{emb}}, z której odczytywany jest tylko wiersz tokenu, i bez kodera obrazu WimgW_{\mathrm{img}}, który działa tylko przy obrazie.

cc to liczba kanałów krótkiego splotu warstw uwagi liniowej: klucz i zapytanie dla każdej z nkn_k głowic kluczy oraz wartość dla każdej z nvn_v głowic wartości, każde o długości dlind_{\mathrm{lin}} liczb. Splot przechowuje ostatnie k−1k - 1 tokenów każdego kanału.

Założenia

  • Wagi pochodzą z plików modelu w jednej ustalonej wersji; vLLM zajął 1,0% (RTX 5090) i 1,4% (RTX 3090) więcej, czego kalkulator nie liczy.
  • Pamięć karty MM to pamięć z karty katalogowej pomniejszona o rezerwę sterownika, 488 MiB, jak wyjaśnia krok Pamięć.
  • Pamięć, przepustowość i wydajność rdzeni tensorowych kart A100 80GB PCIe, H100 NVL i H200 NVL pochodzą ze stron produktowych NVIDII; każda wydajność obliczeń gęstych to połowa podanej tam wydajności z rzadkością (sparsity). Żadnej z tych kart nie zmierzono (Ograniczenia).

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ł uu 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ł.

Rozmowy, które karta obsługuje w tym samym czasie.

Tokeny jednej rozmowy do tej pory: prompt, dokumenty w nim i odpowiedzi. Nazywa się ją też długością kontekstu.

Domyślnie w vLLM to 92%. Na RTX 3090 model 4-bitowy potrzebuje 98%: przy 92% vLLM się nie uruchamia.

Mieści sięTak24,06 GB z 31,14 GB
Maksimum teoretyczne, tokeny na użytkownika Tfit,maxT_{\mathrm{fit},\mathrm{max}}262 14410,54 GB na rozmowy; maksimum modelu, zmieściłoby się 312 226
Szacunek z modelu, tokeny na użytkownika TfitT_{\mathrm{fit}}217 9527,521 GB na rozmowy; 220 131 przed zaokrągleniem do bloków
Szacunek praktyczny, tokeny na użytkownika Tfit,pracT_{\mathrm{fit},\mathrm{prac}}180 320 do 206 9766,281 do 7,150 GB na rozmowy

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 MM 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 RR.
  • 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 RR.
  • 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 RR.
  • 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 RR. 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

Cm=nsS+TKC_m = n_s\, S + T\, K W+R+UCm≤uMW + R + U\, C_m \le u\, M Tfit=(uM−W−R)/U−2SKT_{\mathrm{fit}} = \frac{(u\, M - W - R)/U - 2\,S}{K}

gdzie CmC_m to pamięć zajmowana przez rozmowę jednego użytkownika, nsn_s liczba kopii stałego stanu SS, które przechowuje vLLM, 1 dopóki rozmowa mieści się w pierwszym bloku btb_t tokenów i 2 później, TT długość rozmowy w tokenach, a KK pamięć podręczna na token; WW to wagi na karcie, RR pamięć robocza oprogramowania serwującego, UU liczba użytkowników naraz, uu udział pamięci dostępny dla oprogramowania serwującego, a MM pamięć karty; TfitT_{\mathrm{fit}} 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.

bt=16⌈Sl/(16Kl)⌉b_t = 16\, \lceil S_l/(16\, K_l) \rceil n=⌊(uM−W−R)/(LfullbtKl)⌋n = \lfloor (u\, M - W - R)/(L_{\mathrm{full}}\, b_t\, K_l) \rfloor TvLLM=bt(⌊(n−1)/U⌋−2Llin/Lfull)T_{\mathrm{vLLM}} = b_t\, (\lfloor (n - 1)/U \rfloor - 2\, L_{\mathrm{lin}}/L_{\mathrm{full}})

CmC_m to pamięć zajmowana przez jedną rozmowę: jej stały stan SS, dwukrotnie, gdy rozmowa jest dłuższa niż jeden blok, oraz pamięć podręczna warstw uwagi pełnej, KK na każdy z jej TT tokenów. Model się mieści, gdy jego wagi WW, pamięć robocza oprogramowania serwującego RR i rozmowy UU użytkowników zajmują razem nie więcej niż udział uu pamięci karty MM. Rozwiązanie tej samej sumy względem TT daje najdłuższą rozmowę, jaką może mieć każdy użytkownik, TfitT_{\mathrm{fit}}.

vLLM liczy w blokach po btb_t tokenów: najmniejszej wielokrotności 16, której pamięć podręczna w jednej warstwie, btKlb_t K_l, gdzie KlK_l to pamięć podręczna na token w jednej warstwie, mieści stały stan jednej warstwy SlS_l. Blok obejmuje LfullL_{\mathrm{full}} warstw uwagi pełnej; w pozostałej pamięci mieści się nn bloków. Jeden jest trzymany w zapasie, a stały stan każdego użytkownika zajmuje dwa bloki w każdej grupie LfullL_{\mathrm{full}} warstw uwagi liniowej, więc każdy użytkownik może mieć TvLLMT_{\mathrm{vLLM}} tokenów, czyli pokazany wynik. Rozmowa o długości najwyżej btb_t 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.

M=Msheet−MresM = M_{\mathrm{sheet}} - M_{\mathrm{res}} R=Rlib+Rws+max(Renc,Rfwd,Rsmp)+RgrR = R_{\mathrm{lib}} + R_{\mathrm{ws}} + \max(R_{\mathrm{enc}},\ R_{\mathrm{fwd}},\ R_{\mathrm{smp}}) + R_{\mathrm{gr}}

MM to pamięć karty z jej karty katalogowej, MsheetM_{\mathrm{sheet}}, pomniejszona o rezerwę sterownika, MresM_{\mathrm{res}} = 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.

RR 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. RlibR_{\mathrm{lib}} to obszar roboczy cuBLAS, a RwsR_{\mathrm{ws}} obszar roboczy FlashInfer, tylko przy 8-bitowej pamięci podręcznej.

Największy krok to największa z wartości: RencR_{\mathrm{enc}}, koder obrazu na obrazie największego rozmiaru, 0 dla modelu bez kodera; RfwdR_{\mathrm{fwd}}, krok 2048 tokenów promptu z zachowanym wynikiem kodera obrazu; i RsmpR_{\mathrm{smp}}, 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. RgrR_{\mathrm{gr}} 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.

Mc,max=uMsheet−WM_{c,\mathrm{max}} = u\, M_{\mathrm{sheet}} - W Mc,prac=u(M+ΔM)−W(1+w)−(R+ΔR)M_{c,\mathrm{prac}} = u\,(M + \Delta M) - W\,(1 + w) - (R + \Delta R)

Mc,maxM_{c,\mathrm{max}} to maksimum teoretyczne pamięci na rozmowy: udział uu pamięci z karty katalogowej bez wag w takiej postaci, w jakiej zawierają je pliki; tokeny na użytkownika, Tfit,maxT_{\mathrm{fit},\mathrm{max}}, wynikają z niej tak jak TfitT_{\mathrm{fit}}, przed zaokrągleniem do całych bloków vLLM.

Mc,pracM_{c,\mathrm{prac}} 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 MM, ΔM\Delta M = −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, ww = 1,05% i 1,40% WW; oraz pamięć robocza vLLM ponad RR, ΔR\Delta R = 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 RR 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 btb_t = 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.

Tokeny, które model przetwarza, zanim odpowie: instrukcje, pytanie i wysłane z nimi dokumenty.

Minimum teoretyczne tfirst,mint_{\mathrm{first},\mathrm{min}}0,1550 sprompt: 23 127 tok./s
Szacunek z modelu tfirstt_{\mathrm{first}}0,2954 s3 fragmenty po najwyżej 1568 tokenów; prompt: 12 133 tok./s
Szacunek praktyczny tfirst,pract_{\mathrm{first},\mathrm{prac}}0,4476 do 0,4519 sprompt: 7930 do 8008 tok./s
Najdłuższy prompt bez wywłaszczenia213 248 tokenówprzy tej pamięci na rozmowy

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: FF = 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: FlinF_{\mathrm{lin}} = 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: EE = 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

ci=max(niFεgRg,WreadηB)+Ai+niFlinεaR16+niEηBc_i = \max\Big( \frac{n_i\, F}{\varepsilon_g R_g},\ \frac{W_{\mathrm{read}}}{\eta\, B} \Big) + \frac{A_i + n_i F_{\mathrm{lin}}}{\varepsilon_a R_{16}} + \frac{n_i\, E}{\eta\, B} tfirst=∑i[max(ci,Nptop)+tstep]t_{\mathrm{first}} = \sum\nolimits_i \Big[ \max\big( c_i,\ N_p\, t_{\mathrm{op}} \big) + t_{\mathrm{step}} \Big] TPSprompt=Ptfirst\mathrm{TPS}_{\mathrm{prompt}} = \frac{P}{t_{\mathrm{first}}}

gdzie tfirstt_{\mathrm{first}} to czas do pierwszego tokenu; suma obejmuje fragmenty promptu ii o długości nin_i tokenów; cic_i to praca karty nad fragmentem; FF to liczba operacji mnożeń macierzy na token, RgR_g wydajność rdzeni tensorowych karty dla formatów liczb modelu, a εg\varepsilon_g osiągany jej udział; Wread/(ηB)W_{\mathrm{read}}/(\eta\, B) to odczyt wag, tak jak w kroku Szybkość dla jednego użytkownika; AiA_i to liczba operacji uwagi pełnej we fragmencie, a FlinF_{\mathrm{lin}} uwagi liniowej na token, przy wydajności 16-bitowej R16R_{16} × εa\varepsilon_a; EE to bajty małych jąder na token; NpN_p to liczba jąder fragmentu, a topt_{\mathrm{op}} czas procesora na jedno jądro; tstept_{\mathrm{step}} to czas silnika vLLM na krok; TPSprompt\mathrm{TPS}_{\mathrm{prompt}} 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.

F=2∑jajbjkjF = 2 \sum\nolimits_j a_j\, b_j\, k_j Ai=4Lfullnqdni(si+ni2)A_i = 4\, L_{\mathrm{full}}\, n_q\, d\, n_i \Big(s_i + \frac{n_i}{2}\Big) ni=min(bt,P−si)n_i = \min(b_t,\ P - s_i)

FF liczy dwie operacje, mnożenie i dodawanie, na każdą wagę, której mnożenia macierzy używają na token: kjk_j macierzy o aja_j wierszach i bjb_j kolumnach każdego rodzaju, w każdej warstwie i w warstwie wyjściowej. Dla Qwen3.8-27B to 48,70 miliarda. RgR_g 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.

AiA_i to liczba operacji uwagi pełnej dla fragmentu o długości nin_i tokenów, który zaczyna się po sis_i tokenach: zapytanie każdego tokenu jest mnożone przez klucz każdego tokenu przed nim, średnio si+ni/2s_i + n_i/2, a wyniki przez ich wartości, po dwie operacje, dla jego nqn_q głowic zapytań po dd liczb w każdej z LfullL_{\mathrm{full}} warstw uwagi pełnej.

Fragmenty to bloki po btb_t 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, FlinF_{\mathrm{lin}} = 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ą EE = 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: NpN_p = 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 tstept_{\mathrm{step}} przed następnym krokiem.

εg\varepsilon_g = 95,5%: 16-bitowe mnożenie macierzy osiągnęło około 200 z 209,5 TFLOPS karty RTX 5090 (Zhang i in., 2025). εa\varepsilon_a = 85,0%: FlashAttention osiągnęło od 147 do 209 TFLOPS na RTX 5090, 178 w środku tego zakresu (ta sama praca). topt_{\mathrm{op}} = 14,3 µs: 743 jądra trwały 14 ms bez grafu CUDA i 3,4 ms z grafem (Ghosh i in., 2025). tstept_{\mathrm{step}} = 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).

tfirst,min=∑i[max(niFRgpeak,WreadB)+Ai+niFlinR16peak]t_{\mathrm{first},\mathrm{min}} = \sum\nolimits_i \Big[ \max\Big( \frac{n_i\, F}{R_g^{\mathrm{peak}}},\ \frac{W_{\mathrm{read}}}{B} \Big) + \frac{A_i + n_i F_{\mathrm{lin}}}{R_{16}^{\mathrm{peak}}} \Big] tfirst,prac=∑i[max(ciprac,Nptp)+tg]t_{\mathrm{first},\mathrm{prac}} = \sum\nolimits_i \big[ \max\big( c_i^{\mathrm{prac}},\ N_p\, t_p \big) + t_g \big] ciprac=max(niFgRg,WreadeWB)+AiaR16+niFlinlR16+niEsBc_i^{\mathrm{prac}} = \max\Big( \frac{n_i\, F}{g\, R_g},\ \frac{W_{\mathrm{read}}}{e_W\, B} \Big) + \frac{A_i}{a\, R_{16}} + \frac{n_i\, F_{\mathrm{lin}}}{l\, R_{16}} + \frac{n_i\, E}{s\, B}

tfirst,mint_{\mathrm{first},\mathrm{min}} to minimum teoretyczne. RgpeakR_g^{\mathrm{peak}} i R16peakR_{16}^{\mathrm{peak}} 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.

tfirst,pract_{\mathrm{first},\mathrm{prac}} 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 gg = 106,0% (RTX 5090) i 99,9% (RTX 3090), uwaga pełna aa = 68,4% (RTX 5090, przy 65 536 tokenach), uwaga liniowa ll = 20,7% i 24,4%, a małe jądra ss = 220% i 129%: przesyłały mniej bajtów, niż liczy EE. Wagi są odczytywane przy eWe_W 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 aa = 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ł tpt_p = 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 tgt_g = 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.
  • εg\varepsilon_g, εa\varepsilon_a, topt_{\mathrm{op}} i tstept_{\mathrm{step}} 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 topt_{\mathrm{op}}. 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.

Maksimum teoretyczne TPSmax\mathrm{TPS}_{\mathrm{max}}99,17 tok./ssam odczyt przy pełnej przepustowości
Szacunek z modelu TPS\mathrm{TPS}85,55 tok./sodczyt przy 92% przepustowości
Szacunek praktyczny TPSprac\mathrm{TPS}_{\mathrm{prac}}66,74 do 74,21 tok./sz wartościami zmierzonymi w krokach samego vLLM

Czas na token w skali

Wzory

TPS=1Nk(λ+τ)+(Wread+C)/(ηB)\mathrm{TPS} = \frac{1}{N_k\,(\lambda + \tau) + (W_{\mathrm{read}} + C)/(\eta\, B)} TPSmax=BWread+C\mathrm{TPS}_{\mathrm{max}} = \frac{B}{W_{\mathrm{read}} + C}

gdzie TPS\mathrm{TPS} to szacowana liczba tokenów na sekundę; NkN_k to liczba jąder uruchamianych przy każdym tokenie; λ\lambda to czas startu jądra, a τ\tau czas, zanim dotrze jego pierwszy odczyt z pamięci; WreadW_{\mathrm{read}} to wagi odczytywane przy każdym tokenie, a C=2S+a+TKC = 2S + a + T K bajty użytkownika: stały stan odczytywany i zapisywany, aktywacje i logity aa oraz odczytywana pamięć podręczna, w bajtach; η\eta to osiągany udział przepustowości; BB to przepustowość pamięci karty w bajtach na sekundę; TPSmax\mathrm{TPS}_{\mathrm{max}} 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 NkN_k jąder, odczytuje WreadW_{\mathrm{read}} wag oraz odczytuje i zapisuje CC bajtów użytkownika. Każde jądro potrzebuje λ\lambda na start i τ\tau, zanim dotrze jego pierwszy odczyt, a bajty są przesyłane przy udziale η\eta przepustowości BB; razem dają TPS\mathrm{TPS} jednego użytkownika. Odczyt wszystkiego przy pełnej przepustowości, bez czasu na jądra, dałby TPSmax\mathrm{TPS}_{\mathrm{max}}: żadna karta i żadne oprogramowanie serwujące nie mogą zrobić tego szybciej.

Warstwy uwagi liniowej aktualizują stały stan SS każdego użytkownika w miejscu, więc każdy token go odczytuje i zapisuje z powrotem, 2S2S. 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 aa, 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, TKT K.

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.

η\eta = 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). λ\lambda = 0,553 µs: 1025 pustych jąder w jednym grafie CUDA zajęło 567 µs na karcie GeForce RTX 3060 (Hoffman i Oh, 2024). τ\tau = 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.

TPSprac=1Wread/(eWB)+Nkk+Lfulla0+2S/(eSB)+TK/(eCB)+ti\mathrm{TPS}_{\mathrm{prac}} = \frac{1}{W_{\mathrm{read}}/(e_W\, B) + N_k\, k + L_{\mathrm{full}}\, a_0 + 2S/(e_S\, B) + T K/(e_C\, B) + t_i}

TPSprac\mathrm{TPS}_{\mathrm{prac}} 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 eWe_W = 78,2% i 83,6% przepustowości. Małe jądra, przerwy między jądrami i wybór tokenu zajmowały kk = 1,98 i 1,38 µs na każde jądro liczone przez kalkulator, a uwaga stały czas a0a_0 = 18,2 i 12,9 µs w każdej warstwie uwagi pełnej.

Stały stan był odczytywany i zapisywany przy eSe_S = 47,9% i 57,9% przepustowości, pamięć podręczna odczytywana przy eCe_C = 95,7% i 74,8%, a karta była bezczynna przez tit_i = 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.
  • η\eta, λ\lambda i τ\tau są takie same dla każdej karty, ze źródeł podanych wyżej.
  • Wagi są odczytywane przy η\eta, 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 UU i długość rozmowy TT pochodzą z kroku Pamięć.

Użytkownicy naraz UrU_r1jedyny zgłoszony
Maksimum teoretyczne, każdy użytkownik TPSeach,max\mathrm{TPS}_{\mathrm{each},\mathrm{max}}99,17 tok./swszyscy razem 99,17 tok./s
Szacunek z modelu, każdy użytkownik TPSeach\mathrm{TPS}_{\mathrm{each}}85,55 tok./sjeden krok 11,69 ms; wszyscy razem 85,55 tok./s
Szacunek praktyczny, każdy użytkownik TPSeach,prac\mathrm{TPS}_{\mathrm{each},\mathrm{prac}}66,74 do 74,21 tok./swszyscy razem 66,74 do 74,21 tok./s

Jeden krok dla wszystkich użytkowników w skali

Wzory

tstep=Nk(λ+τ)+Wread+UrCηBt_{\mathrm{step}} = N_k\,(\lambda + \tau) + \frac{W_{\mathrm{read}} + U_r\, C}{\eta\, B} TPSeach=1tstep\mathrm{TPS}_{\mathrm{each}} = \frac{1}{t_{\mathrm{step}}} TPSall=Urtstep\mathrm{TPS}_{\mathrm{all}} = \frac{U_r}{t_{\mathrm{step}}}

gdzie tstept_{\mathrm{step}} to czas jednego kroku, który tworzy po jednym tokenie dla każdego użytkownika; UrU_r to liczba użytkowników naraz; NkN_k, λ\lambda, τ\tau, WreadW_{\mathrm{read}}, η\eta i BB jak w kroku Szybkość dla jednego użytkownika, a CC to bajty jednego użytkownika przy długości rozmowy TT; TPSeach\mathrm{TPS}_{\mathrm{each}} i TPSall\mathrm{TPS}_{\mathrm{all}} 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.

Ur=max{k≤min(U,256):TvLLM(k)≥T}U_r = \max\{ k \le \min(U, 256) : T_{\mathrm{vLLM}}(k) \ge T \}

Użytkownicy naraz, UrU_r, to największa liczba użytkowników, najwyżej UU i limit vLLM wynoszący 256 naraz, których rozmowy o długości TT tokenów mieszczą się przez całą swoją długość: TvLLM(k)T_{\mathrm{vLLM}}(k) to tokeny na użytkownika z kroku Pamięć dla kk 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 CC każdego użytkownika dla tego użytkownika. Krok UrU_r użytkowników trwa więc dłużej niż krok jednego użytkownika tylko o (Ur−1)C/(ηB)(U_r - 1)\, C/(\eta B): 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.

TPSeach,max=BWread+UrC\mathrm{TPS}_{\mathrm{each},\mathrm{max}} = \frac{B}{W_{\mathrm{read}} + U_r\, C} TPSeach,prac=1Wread/(eWB)+Nkk+Lfulla0+Ur(2S/(eSB)+TK/(eCB))+ti\mathrm{TPS}_{\mathrm{each},\mathrm{prac}} = \frac{1}{W_{\mathrm{read}}/(e_W\, B) + N_k\, k + L_{\mathrm{full}}\, a_0 + U_r\,(2S/(e_S\, B) + T K/(e_C\, B)) + t_i}

TPSeach,max\mathrm{TPS}_{\mathrm{each},\mathrm{max}} to odczyt wag raz i bajtów każdego użytkownika przy pełnej przepustowości, bez czasu na jądra. TPSeach,prac\mathrm{TPS}_{\mathrm{each},\mathrm{prac}} to praktyczny krok z kroku Szybkość dla jednego użytkownika dla UrU_r 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 eWe_W, kk, a0a_0, eSe_S, eCe_C i tit_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ść TT, 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 UrU_r 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 UU wysyłają prompt o długości PP 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ł.

Tokeny każdej odpowiedzi. Razem z promptem tworzą rozmowę, P+AP + A tokenów, która musi się zmieścić w pamięci dla każdego użytkownika.

Minimum teoretyczne, cała odpowiedź5,305 spierwszy token 0,1550 s; 10,08 ms na token
Szacunek z modelu, cała odpowiedź6,266 spierwszy token 0,2954 s; 11,68 ms na token
Szacunek praktyczny, cała odpowiedź7,331 do 8,105 spierwszy token 0,4476 do 0,4519 s; 13,47 do 14,98 ms na token

Jak symulacja układa kroki

  1. 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.
  2. 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.
  3. 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.
  4. 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

0.0 s

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.

tmixed=max(c,Nptop)+tstep+twt_{\mathrm{mixed}} = \max\big( c,\ N_p\, t_{\mathrm{op}} \big) + t_{\mathrm{step}} + t_w tmean=1U∑ktend,k−tfirst,kA−1t_{\mathrm{mean}} = \frac{1}{U} \sum\nolimits_k \frac{t_{\mathrm{end},k} - t_{\mathrm{first},k}}{A - 1}

Krok, który przetwarza fragmenty promptów, trwa tyle co praca karty nad nimi, cc, jak w kroku Przetwarzanie promptu, z wagami odczytywanymi raz dla wszystkich, albo czas procesora NptopN_p\, t_{\mathrm{op}}, zależnie od tego, co dłuższe, potem tstept_{\mathrm{step}} silnika vLLM, plus twt_w dla użytkowników dostających w nim odpowiedź: ich bajty, CC każdego użytkownika przy udziale η\eta 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, tmeant_{\mathrm{mean}}, to czas każdej odpowiedzi od pierwszego do ostatniego tokenu, tend,k−tfirst,kt_{\mathrm{end},k} - t_{\mathrm{first},k}, podzielony przez jej pozostałe A−1A - 1 tokenów i uśredniony dla UU 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 eSe_S i pamięć podręczną przy eCe_C; 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 PP tokenów, a wszystkie odpowiedzi mają AA 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 P+AP + A 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.

Pamięć: kalkulator obok vLLM
Karta, udział uuWynikZ modeluSzacunek praktycznyvLLMModel wobec vLLMSzacunek praktyczny wobec vLLM
RTX 5090, 92%Pamięć na rozmowy7,747 GB6,507 do 7,376 GB6,582 GB+17,7%w przedziale
RTX 5090, 92%Tokeny dla jednego użytkownika224 224186 592 do 213 248189 728+18,2%w przedziale
RTX 3090, 98%Pamięć na rozmowy1,389 GB0,1383 do 1,020 GB0,9449 GB+47,0%w przedziale
RTX 3090, 98%Tokeny dla jednego użytkownika31 3600 do 18 81617 248+81,8%w przedziale
RTX 3090, 92%Mieści sięNieNieNie uruchamia się
Szybkość dla jednego użytkownika w tokenach na sekundę
KartaRozmowaZ modeluSzacunek praktycznyLimit przepustowościvLLMModel wobec vLLMSzacunek praktyczny wobec vLLM
RTX 50901024 tokeny85,9867,06 do 74,5299,7167,34+27,7%w przedziale
RTX 509016 384 tokeny83,7865,42 do 72,9296,9966,37+26,2%w przedziale
RTX 509065 536 tokenów77,4460,65 do 68,2589,2162,12+24,7%w przedziale
RTX 5090131 072 tokeny70,3555,27 do 62,8880,6057,36+22,6%w przedziale
RTX 30901024 tokeny46,4237,56 do 41,0452,0841,09+13,0%−0,1%
RTX 30908192 tokeny45,8437,09 do 40,6051,4040,30+13,7%w przedziale
RTX 309016 000 tokenów45,2236,60 do 40,1450,6939,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.

Czas do pierwszego tokenu dla jednego promptu w sekundach
KartaPrompt, tokenyZ modeluSzacunek praktycznyvLLMModel wobec vLLMSzacunek praktyczny wobec vLLM
RTX 509065 5369,87410,783 do 11,42410,875−9,2%w przedziale
RTX 509010240,0820,149 do 0,1510,150−45,4%w przedziale
RTX 509040960,3390,448 do 0,4520,433−21,6%+3,3%
RTX 509016 3841,5791,722 do 1,8311,656−4,6%+4,0%
RTX 509032 7683,7513,962 do 4,2523,979−5,7%w przedziale
RTX 5090131 07229,23533,264 do 34,60833,710−13,3%w przedziale
RTX 5090180 00049,87657,728 do 59,59658,128−14,2%w przedziale
RTX 309010240,7810,714 do 0,7700,765+2,1%w przedziale
RTX 309040963,1632,897 do 3,1223,096+2,2%w przedziale
RTX 309081926,4365,929 do 6,3796,342+1,5%w przedziale
RTX 309012 0009,5758,862 do 9,5209,444+1,4%w przedziale
RTX 309012 5009,9949,253 do 9,9389,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 topt_{\mathrm{op}}, 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.
Szybkość każdego użytkownika przy wielu użytkownikach w tokenach na sekundę
KartaRozmowa, tokenyUżytkownicy narazZ modeluSzacunek praktycznyvLLMModel wobec vLLMSzacunek praktyczny wobec vLLM
RTX 50901024284,465,4 do 72,861,2+37,9%+6,9%
RTX 50901024481,362,2 do 69,661,1+33,2%+1,9%
RTX 50901024875,956,8 do 63,962,3+21,8%w przedziale
RTX 509010241666,948,3 do 54,958,7+13,9%−6,5%
RTX 509016 384280,262,3 do 69,859,3+35,3%+5,1%
RTX 509016 384474,056,9 do 64,356,5+30,9%+0,6%
RTX 50904096381,662,9 do 70,361,0+33,8%+3,0%
RTX 50904096676,357,8 do 65,162,7+21,8%w przedziale
RTX 509040961267,649,8 do 56,758,3+15,9%−2,7%
RTX 509032 768276,359,3 do 66,957,2+33,3%+3,7%
RTX 509032 768371,655,5 do 63,055,1+30,0%+0,8%
RTX 50901024284,465,4 do 72,861,2+37,8%+6,8%
RTX 30901024245,536,5 do 40,038,3+18,7%w przedziale
RTX 30901024443,834,7 do 38,237,0+18,3%w przedziale
RTX 30901024443,834,7 do 38,237,2+17,9%w przedziale
RTX 50901024382,863,8 do 71,161,2+35,3%+4,2%
RTX 50901024579,960,8 do 68,066,0+21,0%w przedziale
RTX 509010241666,948,3 do 54,959,1+13,2%−7,0%
RTX 509016 384668,652,4 do 59,657,7+18,9%w przedziale
RTX 30901024344,735,6 do 39,137,6+18,7%w przedziale
RTX 30902048245,436,4 do 39,938,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.
Od promptu do odpowiedzi: średni czas na token w ms i ostatni pierwszy token użytkowników, którzy wysłali prompty razem, w sekundach
KartaPrompt, tokenyUżytkownicy (naraz)Czas na token, z modeluCzas na token, vLLMModel wobec vLLMOstatni pierwszy token, z modeluOstatni pierwszy token, vLLMModel wobec vLLM
RTX 50901024212,116,3−26,1%0,160,30−45,3%
RTX 50901024412,916,9−23,8%0,330,58−43,4%
RTX 50901024814,617,8−18,0%0,661,14−42,0%
RTX 509010241618,022,1−18,5%1,332,54−47,5%
RTX 509016 384216,720,5−18,4%3,163,51−9,8%
RTX 509016 384426,330,8−14,7%6,357,27−12,6%
RTX 50904096314,017,6−20,1%1,021,32−22,4%
RTX 50904096617,621,1−16,7%2,052,78−26,4%
RTX 509040961224,628,9−15,0%4,135,45−24,3%
RTX 509032 768223,426,2−10,9%7,527,86−4,4%
RTX 509032 768334,536,5−5,7%11,3112,21−7,4%
RTX 50901024212,116,3−26,0%0,160,33−50,4%
RTX 30901024224,226,8−9,7%1,561,55+1,0%
RTX 30901024429,531,0−4,7%3,133,09+1,2%
RTX 309010245 (4)32,232,1+0,2%3,9111,15−64,9%
RTX 309020483*30,331,2−3,1%4,7111,92−60,5%
RTX 50901024312,516,7−25,1%0,250,55−55,5%
RTX 50901024513,316,1−16,9%0,410,69−40,5%
RTX 5090102424 (16)18,422,5−18,4%5,607,60−26,3%
RTX 509016 384635,836,7−2,7%9,569,86−3,0%
RTX 30901024326,928,7−6,3%2,342,31+1,3%
RTX 30902048223,926,6−10,1%3,143,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.

Od promptu do odpowiedzi, przedział praktyczny: średni czas na token w ms i ostatni pierwszy token użytkowników, którzy wysłali prompty razem, w sekundach
KartaPrompt, tokenyUżytkownicy (naraz)Czas na token, szacunek praktycznyCzas na token, vLLMSzacunek praktyczny wobec vLLMOstatni pierwszy token, szacunek praktycznyOstatni pierwszy token, vLLMSzacunek praktyczny wobec vLLM
RTX 50901024214,1 do 15,716,3−3,7%0,30 do 0,300,30+0,001%
RTX 50901024415,6 do 17,316,9w przedziale0,60 do 0,600,58+3,3%
RTX 50901024818,4 do 20,417,8+3,5%1,20 do 1,221,14+5,9%
RTX 509010241624,1 do 26,622,1+9,3%2,43 do 2,462,54−3,3%
RTX 509016 384218,9 do 20,920,5w przedziale3,45 do 3,673,51w przedziale
RTX 509016 384429,4 do 32,230,8w przedziale6,93 do 7,377,27w przedziale
RTX 50904096316,6 do 18,317,6w przedziale1,35 do 1,361,32+2,3%
RTX 50904096621,3 do 23,321,1+1,2%2,70 do 2,732,78−1,9%
RTX 509040961230,7 do 33,128,9+6,2%5,45 do 5,515,45w przedziale
RTX 509032 768225,7 do 28,426,2w przedziale7,94 do 8,537,86+1,0%
RTX 509032 768337,4 do 41,036,5+2,3%11,94 do 12,8312,21w przedziale
RTX 50901024214,1 do 15,716,3−3,7%0,30 do 0,300,33−8,4%
RTX 30901024227,0 do 29,526,8+0,7%1,43 do 1,541,55−0,3%
RTX 30901024432,3 do 35,431,0+4,2%2,86 do 3,093,09−0,1%
RTX 309010245 (4)34,9 do 38,332,1+8,8%3,57 do 3,8611,15−65,4%
RTX 309020483*32,7 do 35,831,2+4,8%4,30 do 4,6411,92−61,1%
RTX 50901024314,9 do 16,516,7−1,1%0,45 do 0,450,55−17,9%
RTX 50901024516,3 do 18,016,1+1,4%0,75 do 0,760,69+8,6%
RTX 5090102424 (16)24,8 do 27,322,5+10,3%8,03 do 8,687,60+5,7%
RTX 509016 384639,8 do 43,436,7+8,2%10,44 do 11,119,86+5,8%
RTX 30901024329,6 do 32,528,7+3,4%2,14 do 2,312,31−0,02%
RTX 30902048226,7 do 29,326,6+0,6%2,86 do 3,093,06w 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.

Bielik-11B-v3.0: pamięć na rozmowy i tokeny dla jednego użytkownika
KartaWagiZ modeluSzacunek praktycznyvLLMModel wobec vLLMSzacunek praktyczny wobec vLLMTokeny, z modeluTokeny, szacunek praktycznyTokeny, vLLMModel wobec vLLMSzacunek praktyczny wobec vLLM
RTX 30908 bitów11,554 GB10,449 do 11,283 GB11,307 GB+2,2%−0,2%56 40050 992 do 55 07255 200+2,2%−0,2%
RTX 309016 bitów0,6534 GB0,0000 do 0,2685 GB0,4080 GB+60,1%−34,2%31680 do 12801983+59,8%−35,5%
RTX 50908 bitów19,428 GB18,322 do 19,157 GB18,909 GB+2,7%w przedziale94 83289 440 do 93 52092 288+2,8%w przedziale
RTX 509016 bitów8,527 GB7,269 do 8,142 GB7,978 GB+6,9%w przedziale41 61635 472 do 39 72838 960+6,8%w przedziale
Bielik-11B-v3.0: szybkość dla jednego użytkownika w tokenach na sekundę
KartaWagiRozmowa, tokenyZ modeluSzacunek praktycznyvLLMModel wobec vLLMSzacunek praktyczny wobec vLLM
RTX 30908 bitów102472,9556,96 do 62,9364,50+13,1%−2,4%
RTX 30908 bitów409669,2654,19 do 60,2760,12+15,2%w przedziale
RTX 30908 bitów819264,8850,88 do 57,0556,09+15,7%w przedziale
RTX 30908 bitów16 38457,6045,35 do 51,5449,55+16,2%w przedziale
RTX 30908 bitów24 00052,1641,19 do 47,3045,37+15,0%w przedziale
RTX 309016 bitów51238,1030,97 do 33,6734,49+10,5%−2,4%
RTX 309016 bitów102437,9330,82 do 33,5434,36+10,4%−2,4%
RTX 309016 bitów153637,7530,68 do 33,4133,92+11,3%−1,5%
RTX 50908 bitów1024134,8198,00 do 110,92114,11+18,1%−2,8%
RTX 50908 bitów4096128,2193,69 do 106,58109,74+16,8%−2,9%
RTX 50908 bitów8192120,3688,50 do 101,3099,95+20,4%w przedziale
RTX 50908 bitów16 384107,2379,67 do 92,1790,18+18,9%w przedziale
RTX 50908 bitów24 00097,3572,91 do 85,0485,23+14,2%−0,2%
RTX 509016 bitów102471,5055,93 do 61,6568,41+4,5%−9,9%
RTX 509016 bitów409669,6054,50 do 60,2966,63+4,5%−9,5%
RTX 509016 bitów819267,2252,70 do 58,5663,10+6,5%−7,2%
RTX 509016 bitów16 38462,9249,44 do 55,3958,90+6,8%−6,0%
RTX 509016 bitów24 00059,3846,75 do 52,7356,86+4,4%−7,3%
Bielik-11B-v3.0: czas do pierwszego tokenu dla jednego promptu w sekundach
KartaWagiPrompt, tokenyZ modeluSzacunek praktycznyvLLMModel wobec vLLMSzacunek praktyczny wobec vLLM
RTX 30908 bitów10240,3470,318 do 0,3410,335+3,8%w przedziale
RTX 30908 bitów40961,4731,360 do 1,4481,403+5,0%w przedziale
RTX 30908 bitów81923,1733,003 do 3,1783,012+5,3%w przedziale
RTX 30908 bitów16 3847,2547,135 do 7,4866,914+4,9%+3,2%
RTX 30908 bitów24 00011,86411,991 do 12,50611,358+4,5%+5,6%
RTX 309016 bitów5120,1720,167 do 0,1730,188−8,5%−8,0%
RTX 309016 bitów10240,3470,329 do 0,3410,359−3,1%−5,0%
RTX 309016 bitów15360,5260,493 do 0,5130,523+0,5%−2,1%
RTX 50908 bitów10240,0640,076 do 0,0780,081−20,7%−4,6%
RTX 50908 bitów40960,2850,276 do 0,2970,295−3,4%w przedziale
RTX 50908 bitów81920,6470,647 do 0,6900,661−2,0%w przedziale
RTX 50908 bitów16 3841,6031,678 do 1,7641,606−0,2%+4,5%
RTX 50908 bitów24 0002,7692,983 do 3,1092,798−1,0%+6,6%
RTX 509016 bitów10240,1210,118 do 0,1240,129−6,4%−3,8%
RTX 509016 bitów40960,5100,481 do 0,5110,492+3,7%w przedziale
RTX 509016 bitów81921,0961,054 do 1,1191,066+2,8%w przedziale
RTX 509016 bitów16 3842,5022,489 do 2,6212,445+2,3%+1,8%
RTX 509016 bitów24 0004,0854,169 do 4,3654,038+1,2%+3,2%
Bielik-11B-v3.0: szybkość każdego użytkownika przy wielu użytkownikach w tokenach na sekundę
KartaWagiRozmowa, tokenyUżytkownicy naraz, vLLM (z modelu)Z modeluSzacunek praktycznyvLLMModel wobec vLLMSzacunek praktyczny wobec vLLM
RTX 30908 bitów10244 (4)68,753,9 do 59,959,4+15,7%w przedziale
RTX 30908 bitów10248 (8)63,750,2 do 56,454,5+17,0%w przedziale
RTX 30908 bitów102416 (16)55,644,2 do 50,446,9+18,6%w przedziale
RTX 30908 bitów40968 (8)46,436,9 do 42,840,9+13,5%w przedziale
RTX 309016 bitów5122 (2)37,930,8 do 33,533,2+14,0%w przedziale
RTX 50908 bitów10244 (4)127,293,2 do 106,1109,4+16,3%−3,0%
RTX 50908 bitów10248 (8)118,387,4 do 100,2102,3+15,6%−2,0%
RTX 50908 bitów102416 (16)103,777,9 do 90,391,3+13,6%−1,1%
RTX 50908 bitów40968 (8)86,965,8 do 77,477,8+11,7%−0,4%
RTX 509016 bitów10244 (4)69,354,3 do 60,162,7+10,6%−4,1%
RTX 509016 bitów10248 (8)66,652,3 do 58,258,2+14,3%−0,1%
RTX 509016 bitów102416 (16)61,748,7 do 54,753,9+14,5%w przedziale
RTX 509016 bitów40968 (8)55,343,7 do 49,749,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.

Arete-27B: pamięć na rozmowy i tokeny dla jednego użytkownika
KartaUstawieniaZ modeluSzacunek praktycznyvLLMModel wobec vLLMSzacunek praktyczny wobec vLLMTokeny, z modeluTokeny, szacunek praktycznyTokeny, vLLMModel wobec vLLMSzacunek praktyczny wobec vLLM
RTX 309095%, pamięć podręczna 16 bitów3,525 GB2,314 do 3,181 GB2,899 GB+21,6%w przedziale47 82429 792 do 42 33633 981+40,7%w przedziale
RTX 309098,9%, pamięć podręczna 8 bitów, tylko tekst6,443 GB3,940 do 4,263 GB4,155 GB+55,0%w przedziale185 024108 192 do 117 600108 669+70,3%w przedziale
RTX 309098,9%, pamięć podręczna 8 bitów4,097 GB2,879 do 3,754 GB3,844 GB+6,6%−2,3%112 89676 832 do 103 488100 519+12,3%w przedziale
Arete-27B: szybkość dla jednego użytkownika w tokenach na sekundę
KartaUstawieniaRozmowa, tokenyZ modeluSzacunek praktycznyvLLMModel wobec vLLMSzacunek praktyczny wobec vLLM
RTX 309095%, pamięć podręczna 16 bitów102453,4242,91 do 47,0546,82+14,1%w przedziale
RTX 309095%, pamięć podręczna 16 bitów819251,9041,71 do 45,9244,91+15,6%w przedziale
RTX 309098,9%, pamięć podręczna 8 bitów, tylko tekst102453,5443,01 do 47,1446,85+14,3%w przedziale
RTX 309098,9%, pamięć podręczna 8 bitów, tylko tekst819252,7742,40 do 46,5745,90+15,0%w przedziale
RTX 309098,9%, pamięć podręczna 8 bitów, tylko tekst32 76850,2940,42 do 44,7043,90+14,5%w przedziale
RTX 309098,9%, pamięć podręczna 8 bitów, tylko tekst65 53647,3238,06 do 42,4241,52+14,0%w przedziale
Arete-27B: czas do pierwszego tokenu dla jednego promptu w sekundach
KartaUstawieniaPrompt, tokenyZ modeluSzacunek praktycznyvLLMModel wobec vLLMSzacunek praktyczny wobec vLLM
RTX 309098,9%, pamięć podręczna 8 bitów, tylko tekst10240,7810,714 do 0,7700,787−0,8%−2,2%
RTX 309098,9%, pamięć podręczna 8 bitów, tylko tekst81926,4365,929 do 6,3796,400+0,6%−0,3%
RTX 309098,9%, pamięć podręczna 8 bitów, tylko tekst32 76828,35826,939 do 28,73528,954−2,1%−0,8%
RTX 309098,9%, pamięć podręczna 8 bitów, tylko tekst65 53663,69562,547 do 66,13967,188−5,2%−1,6%
Arete-27B: szybkość każdego użytkownika przy wielu użytkownikach w tokenach na sekundę
KartaUstawieniaRozmowa, tokenyUżytkownicy naraz, vLLM (z modelu)Z modeluSzacunek praktycznyvLLMModel wobec vLLMSzacunek praktyczny wobec vLLM
RTX 309098,9%, pamięć podręczna 8 bitów, tylko tekst16 3842 (2)49,339,3 do 43,640,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%.

Qwen3.8-27B w 8 bitach na H200 NVL: czas do pierwszego tokenu dla jednego promptu w sekundach
KartaUstawieniaPrompt, tokenyZ modeluSzacunek praktycznyvLLMModel wobec vLLMSzacunek praktyczny wobec vLLM
H200 NVL75%, pamięć podręczna 8 bitów, tylko tekst, MTP38450,1500,298 do 0,3200,303−50,3%w przedziale
H200 NVL75%, pamięć podręczna 8 bitów, tylko tekst, MTP129 1899,49414,497 do 15,32016,965−44,0%−9,7%
H200 NVL75%, pamięć podręczna 8 bitów, tylko tekst, MTP253 76327,40344,406 do 46,02850,804−46,1%−9,4%
H200 NVL75%, pamięć podręczna 8 bitów, tylko tekst, MTP39540,1550,298 do 0,3200,324−52,2%−1,2%
H200 NVL75%, pamięć podręczna 8 bitów, tylko tekst, MTP129 2319,49914,497 do 15,32017,302−45,1%−11,5%
H200 NVL75%, pamięć podręczna 8 bitów, tylko tekst, MTP254 33227,50544,615 do 46,23950,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, B/(Wread+C)B/(W_{\mathrm{read}} + C), 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 KK 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/abs/2503.19779v3

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/blog/constant-time-launch-for-straight-line-cuda-graphs-and-other-performance-enhancements/

Jarmusch, A., Graddon, N. and Chandrasekaran, S. (2025). Dissecting the NVIDIA Blackwell Architecture with Microbenchmarks. arXiv:2507.10789v2, §IV.D. https://arxiv.org/abs/2507.10789v2

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/abs/2511.02230v7

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/abs/2402.13499v1

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/aem-dam/Solutions/geforce/blackwell/nvidia-rtx-blackwell-gpu-architecture.pdf

NVIDIA (2026). NVIDIA A100, H100 GPU and H200 GPU, product pages, Specifications: A100 80GB PCIe, H100 NVL, H200 NVL. https://www.nvidia.com/en-us/data-center/a100/, https://www.nvidia.com/en-us/data-center/h100/, https://www.nvidia.com/en-us/data-center/h200/

NVIDIA (2026). Qwen3.8-27B-NVFP4, config.json, revision 482ca0f. Hugging Face. https://huggingface.co/nvidia/Qwen3.8-27B-NVFP4/blob/482ca0f3832238542f8f5295dde86b5f22711d80/config.json

Qwen (2026). Qwen3.8-27B-FP8, config.json, revision 017b9c7. Hugging Face. https://huggingface.co/Qwen/Qwen3.8-27B-FP8/blob/017b9c7af6b5689d5dd426a76e0bc077eb5ca20a/config.json

NVIDIA (2026). cuBLAS Library, v13.4, §2.4.8. https://docs.nvidia.com/cuda/cublas/index.html

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/abs/2505.11594v3

vLLM (2026). vLLM 0.31.1rc1.dev273, commit 2eb491e18: vllm/config/cache.py, vllm/v1/worker/gpu_worker.py and gpu_model_runner.py, vllm/v1/core/kv_cache_utils.py, vllm/v1/kv_cache_interface.py, vllm/v1/core/block_pool.py, vllm/platforms/interface.py, vllm/model_executor/models/qwen3_5.py, vllm/model_executor/layers/quantization/utils/marlin_utils_fp4.py, vllm/third_party/flash_linear_attention/ops/fused_recurrent.py and fused_sigmoid_gating.py, vllm/v1/core/sched/scheduler.py, vllm/config/scheduler.py, vllm/engine/arg_utils.py, vllm/v1/core/single_type_kv_cache_manager.py, vllm/config/vllm.py, vllm/envs.py, vllm/model_executor/models/qwen3_next.py, vllm/model_executor/layers/mamba/gdn/qwen_gdn_linear_attn.py, vllm/model_executor/layers/quantization/compressed_tensors/schemes/compressed_tensors_w8a8_fp8.py, vllm/third_party/flash_linear_attention/ops/utils.py and chunk.py, vllm/model_executor/layers/quantization/compressed_tensors/compressed_tensors.py, vllm/model_executor/kernels/linear/__init__.py and nvfp4/cutlass.py, flashinfer.py and marlin.py, csrc/libtorch_stable/quantization/fp4/nvfp4_scaled_mm_entry.cu and marlin/marlin_mma.h. https://github.com/vllm-project/vllm/tree/2eb491e18

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/isaac-sim/IsaacSim/issues/370

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

Wysłanie formularza oznacza zgodę na kontakt w sprawie zapytania.