Tokens per seconde meten op een lokale LLM
Ontdek wanneer een gehuurde GPU goedkoper is dan betalen per token. Meet tokens per seconde met een concurrency-sweep en bepaal uw rendementsdrempel.
Waarom tokens per seconde bepalen of een GPU rendabel is
Tokens per seconde is de snelheid waarmee uw server tekst genereert. Dit getal bepaalt of het huren van een GPU goedkoper is dan betalen per token via een API. Voor een GPU-server betaalt u per uur, ongeacht of deze in gebruik is of stilstaat. Een gehoste API wordt per token afgerekend. De GPU is daarom alleen rendabel als u gedurende het grootste deel van de betaalde uren een voldoende hoge output behaalt.
Dit betekent dat u zelf een meting moet uitvoeren in plaats van te vertrouwen op algemene cijfers. Deze pagina definieert de vier getallen die u moet registreren, geeft de commando's om deze te produceren en toont de berekening waarmee u een beslissing neemt.
Waarom een gepubliceerd aantal tokens per seconde niet uw getal is
DigitalOcean publiceerde in juli 2026 doorvoersnelheden voor een enkele NVIDIA H200 die llama3.3-70b-instruct draait in FP8 (8-bit floating point) onder vLLM. De cijfers zijn nuttig, maar ze zijn niet van u.
De gegevens achter deze grafiek
[
{
"config": "H200, one stream",
"tok_s": "47"
},
{
"config": "H100, saturated",
"tok_s": "236"
},
{
"config": "H200, saturated",
"tok_s": "2,036"
},
{
"config": "H200, saturated, in+out",
"tok_s": "4,071.6"
}
]Elke rij hierboven is geciteerd van die pagina, en twee daarvan vormen de ondergrens van het opgegeven bereik; lees die twee dus als een minimum. Niets in deze tabel is door ons gemeten.
Begin bij de laatste twee rijen. De koptekst is 4,071.6 tok/s, terwijl de snelheid voor alleen output 2,036 tok/s is. De koptekst telt input- en output-tokens bij elkaar op. Die test gebruikte 1.024 input-tokens tegenover 1.024 output-tokens, dus bijna precies de helft van de koptekst is output. De verdeling is van belang omdat output de langzame helft is. Prefill (het lezen van de prompt) verwerkt alle input-tokens in één pass. Decode (het schrijven van het antwoord) produceert één token per keer. Een totale doorvoersnelheid in de koptekst middelt een goedkoop getal met een duur getal.
Kijk nu naar de eerste rij. Dezelfde H200 die één verzoek tegelijk bedient, produceert 47 tok/s, dus het verzadigde cijfer is meer dan veertig keer hoger op identieke hardware. Dat gat bestaat omdat een enkele decode-stap de GPU het grootste deel van de tijd laat wachten op het geheugen, en gelijktijdige verzoeken vullen die inactieve tijd op. De tweede rij, 236 tok/s, is een enkele H100 op hetzelfde model, die wordt tegengehouden door de KV cache (de key and value cache, het geheugen per verzoek dat een bediend gesprek op de kaart vasthoudt). Een kaart van 80 GB houdt minder gelijktijdige verzoeken vast voor een 70B-model, waardoor deze eerder verzadigd raakt.
Verander het model of verander de verhouding tussen input en output en elk getal hierboven verandert. Gepubliceerde cijfers bepalen uw verwachtingen, niet uw budget; dit is dezelfde regel die geldt voor het eerlijk benchmarken van een VPS op schijf en netwerk.
De vier relevante getallen
- Time to first token, TTFT. De vertraging tussen het verzenden van een verzoek en het arriveren van het eerste output-token. Dit is de som van de prefill-tijd en de wachtrijtijd. Een gebruiker ervaart dit direct.
- Output tokens per second, per stream. Hoe snel één antwoord wordt geschreven zodra het is begonnen. Boven ongeveer 20 tok/s is het al sneller dan de meeste mensen kunnen lezen, dus extra snelheid levert hier weinig op.
- Saturated total output throughput. De som van alle gelijktijdige streams wanneer de server volledig belast is. Dit is het capaciteitsgetal en dit getal bepaalt de GPU-kosten.
- p50 and p99 TTFT under concurrency. p50 is het middelste verzoek. p99 is de waarde waar 99 van de 100 verzoeken onder blijven. Wachtrijvorming is altijd als eerste zichtbaar in de p99.
De eerste twee getallen verbeteren wanneer de server rustig is. Het derde getal verbetert wanneer de server druk is. Ze werken elkaar tegen, en daarom is er geen enkel getal dat een server volledig beschrijft.
Corrigeer de invoer- en uitvoerlengtes voordat u gaat meten
De doorvoer is afhankelijk van het type verkeer. Een prompt van 4.000 tokens met een antwoord van 50 tokens is een taak die zwaar leunt op prefill. Een prompt van 200 tokens met een antwoord van 2.000 tokens is een taak die zwaar leunt op decode. Dezelfde server rapporteert zeer verschillende waarden voor tokens per seconde voor deze twee scenario's. Kies daarom één verhouding, noteer deze bij elk getal dat u vastlegt en vergelijk nooit resultaten met verschillende verhoudingen. Een verhouding van 1.024 in tegenover 1.024 uit is een redelijke standaard, omdat diverse leveranciers publiceren op basis van deze verhouding. Gebruik uw eigen werkelijke verkeer als u weet hoe dit eruitziet.
Forceer ook de uitvoerlengte. Een model dat na 60 tokens zijn stop-token bereikt, levert een kortere run op die niet vergelijkbaar is met een volledige run: TTFT vormt dan een groter aandeel van de totale tijd, wat de uitvoerdoorvoer omlaag haalt zoals de benchmark deze berekent, ook al is elk verzoek sneller voltooid. De --ignore-eos-vlag in de vLLM-benchmarkclient zorgt ervoor dat elk verzoek exact het gevraagde aantal genereert, waardoor twee runs vergelijkbaar blijven. De keuze voor een model heeft meer invloed op deze getallen dan welke vlag dan ook: een Qwen 3-model op een enkele VPS GPU plaatsen behandelt de geheugenkant van die keuze.
Meet eerst één stream
Begin met het eenvoudigste scenario. Dit is een sanity check en vormt het maximum. Ollama geeft zijn eigen timing weer.
ollama run llama3.1:8b --verbose "Write 200 words about disk scheduling."De regel die u moet lezen is eval rate, dit is het aantal output-tokens per seconde. prompt eval rate is de prefill-snelheid en load duration is de tijd die nodig is om het model in VRAM te laden. Bij de eerste aanroep na een koude start is load duration groot, waardoor total duration misleidend is. Voer het commando twee keer uit en lees het tweede resultaat. Ollama ontlaadt een inactief model standaard na vijf minuten, dus een lange pauze tussen runs brengt u terug naar de koude start.
Dezelfde velden zijn beschikbaar via de API, wat eenvoudiger is om te scripten.
curl -s http://127.0.0.1:11434/api/generate -d '{
"model": "llama3.1:8b",
"prompt": "Write 200 words about disk scheduling.",
"stream": false
}' | jq '{eval_count, eval_duration,
tok_s: (.eval_count / (.eval_duration / 1000000000))}'eval_duration is in nanoseconden, dus delen door 1.000.000.000 geeft seconden. Die deling is precies wat de API-documentatie van Ollama voorschrijft voor tokens per seconde. Als de server nog niet draait, behandelt het zelf hosten van een LLM met Ollama op een VPS de installatie en de systemd-unit.
TTFT vereist een streaming-verzoek, en curl kan dit voor u timen.
curl -s -o /dev/null -N \
-w 'ttfb=%{time_starttransfer}s total=%{time_total}s\n' \
http://127.0.0.1:8000/v1/chat/completions \
-H 'Content-Type: application/json' \
-d '{"model":"Qwen/Qwen3-8B",
"messages":[{"role":"user","content":"Write 200 words about disk scheduling."}],
"stream":true,"max_tokens":256}'time_starttransfer is het moment waarop de eerste byte van de response body arriveert. Bij een streaming chat-completion hoort die byte bij het eerste server-sent event, wat ofwel het eerste inhoudelijke token is, of een delta met alleen de rol die vlak daarvoor wordt verzonden. Beschouw de waarde daarom als TTFT, plus of min één event. Het is nauwkeurig genoeg om twee runs op dezelfde server te vergelijken.
Cijfers voor een enkele stream geven een te rooskleurig beeld van de hardware. De TTFT is op zijn best, omdat er niets in de wachtrij staat. De snelheid per stream is op zijn best, omdat de volledige kaart één verzoek bedient. Geen van beide zegt iets over de capaciteit van de server.
Hoe voert u een concurrency sweep uit?
Een sweep voert één vaste workload uit bij een stijgende concurrency en registreert wat er bij elke stap gebeurt. vLLM levert de client hiervoor mee, en aangezien deze de OpenAI API spreekt, werkt deze ook met Ollama en elke andere OpenAI-compatibele service.
vllm bench serve \
--backend openai-chat \
--base-url http://127.0.0.1:8000 \
--endpoint /v1/chat/completions \
--model Qwen/Qwen3-8B \
--dataset-name random \
--random-input-len 1024 \
--random-output-len 1024 \
--ignore-eos \
--num-prompts 160 \
--max-concurrency 16 \
--percentile-metrics ttft,tpot,itl,e2el \
--metric-percentiles 50,99--max-concurrency beperkt het aantal gelijktijdige verzoeken, en dit is de variabele die u aan het sweepen bent. --num-prompts is het totaal aantal verzonden verzoeken; houd dit in de buurt van tien keer de concurrency om een stabiel gemiddelde te krijgen. De samenvatting toont Output token throughput (tok/s): en Total token throughput (tok/s):, gevolgd door Mean TTFT (ms):, Median TTFT (ms): en P99 TTFT (ms): onder een Time to First Token kop.
Er is geen rate per stream in die output aanwezig, maar dit is met één deling te berekenen. Mean TPOT (ms): is de gemiddelde tijd per output-token na de eerste; 25 ms per token staat dus gelijk aan 40 tokens per seconde per stream. Het delen van de output-throughput door de concurrency levert hetzelfde resultaat op.
Voer dit vervolgens uit in een lus en sla elke run op.
for C in 1 4 16 32 64 128; do
vllm bench serve \
--backend openai-chat \
--base-url http://127.0.0.1:8000 \
--endpoint /v1/chat/completions \
--model Qwen/Qwen3-8B \
--dataset-name random \
--random-input-len 1024 \
--random-output-len 1024 \
--ignore-eos \
--num-prompts $(( C * 10 )) \
--max-concurrency "$C" \
--percentile-metrics ttft,tpot,itl,e2el \
--metric-percentiles 50,99 \
--save-result --result-filename "sweep-c$C.json"
doneDe opgeslagen JSON-bestanden lezen
Elke run schrijft één bestand, dus extraheer de velden die voor u van belang zijn in één keer uit alle bestanden.
for f in sweep-c*.json; do
jq -r --arg f "$f" \
'[$f, .output_throughput, .total_token_throughput,
.median_ttft_ms, .p99_ttft_ms] | @tsv' "$f"
doneoutput_throughput staat voor output-tokens per seconde. total_token_throughput telt de input-tokens er weer bij op, dus bij een 1:1 ratio is dit bijna het dubbele. p99_ttft_ms zou ook aanwezig zijn zonder --metric-percentiles, omdat die flag standaard op 99 staat. De 50 in het commando is wat p50_ttft_ms toevoegt naast de median_ttft_ms die elke metriek genoemd in --percentile-metrics krijgt. Vraag om een percentiel dat u niet heeft opgevraagd, zoals .p90_ttft_ms, en jq print null.
Wat toont een concurrency sweep nu eigenlijk aan?
De gegevens achter deze grafiek
[
{
"label": "1 stream",
"per_stream_tok_s": 92,
"total_tok_s": 92,
"ttft_p50_ms": 48,
"ttft_p99_ms": 61
},
{
"label": "4 streams",
"per_stream_tok_s": 88,
"total_tok_s": 352,
"ttft_p50_ms": 71,
"ttft_p99_ms": 96
},
{
"label": "16 streams",
"per_stream_tok_s": 71,
"total_tok_s": 1136,
"ttft_p50_ms": 152,
"ttft_p99_ms": 244
},
{
"label": "32 streams",
"per_stream_tok_s": 54,
"total_tok_s": 1728,
"ttft_p50_ms": 287,
"ttft_p99_ms": 498
},
{
"label": "64 streams",
"per_stream_tok_s": 34,
"total_tok_s": 2176,
"ttft_p50_ms": 611,
"ttft_p99_ms": 1240
},
{
"label": "128 streams",
"per_stream_tok_s": 18,
"total_tok_s": 2304,
"ttft_p50_ms": 1490,
"ttft_p99_ms": 3820
}
]Die 6 rijen zijn een illustratie van het verloop dat een sweep genereert op een kleine, huurbare GPU-server, met aannemelijke grootteordes. Het zijn geen metingen van uw eigen server en het zijn geen cijfers van de leverancier. Voer de bovenstaande loop uit en vervang deze door uw eigen waarden.
Bestudeer het verloop, want het verloop is wat generaliseert. Bij één stream produceert de hele box 92 tokens per seconde met een p99 TTFT van 61 ms. Bij 128 streams bereikt het totaal 2304 tokens per seconde, vijfentwintig keer hoger, terwijl elke individuele stream daalt naar 18 tokens per seconde en de p99 TTFT 3820 ms bereikt. De totale doorvoer stijgt omdat batching inactieve geheugenwachttijden omzet in nuttig werk. De snelheid per stream daalt omdat dezelfde rekenkracht nu wordt gedeeld.
De laatste verdubbeling is de indicator. De overgang van 64 naar 128 streams voegt minder dan zes procent toe aan het totaal, terwijl de p99 TTFT ruwweg verdrievoudigt. Dit betekent dat verzoeken in de wachtrij staan in plaats van worden uitgevoerd, ofwel omdat de KV-cache vol is, ofwel omdat de server een planningslimiet heeft bereikt, zoals max_num_seqs van vLLM. Het nuttige werkpunt ligt eerder: bij 32 streams levert de box nog steeds 1728 tokens per seconde, 75 procent van de piek, bij 54 tokens per seconde per stream en een p99 TTFT van 498 ms. Rapporteer dat punt als uw capaciteit. De piek van de curve is een waarde waarmee u geen gebruikers kunt bedienen.
Ollama en vLLM meten niet hetzelfde
Voer die sweep uit op een standaard Ollama-server en het totaal zal nauwelijks veranderen. OLLAMA_NUM_PARALLEL staat standaard op 1, waardoor één verzoek wordt uitgevoerd terwijl de rest wacht. De wachtrij zorgt ervoor dat de p99 TTFT stijgt terwijl de totale output gelijk blijft. Verhoog dit getal voordat u metingen verricht.
sudo systemctl edit ollama.service[Service]
Environment="OLLAMA_NUM_PARALLEL=8"Start opnieuw met sudo systemctl restart ollama en bevestig daarna dat het model nog steeds in het geheugen past. Elke parallelle slot krijgt een eigen deel van het contextvenster. De documentatie van Ollama vermeldt daarom dat een 2K-context met 4 parallelle verzoeken 8K toewijst. Verhoog het aantal slots ver genoeg en het model loopt uit het VRAM. Controleer ollama ps: een PROCESSOR-kolom die zoiets aangeeft als 48%/52% CPU/GPU betekent dat een deel van het model zich op de CPU bevindt. De doorvoer zal nu dalen naarmate u meer gelijktijdigheid toevoegt, in plaats van stijgen. Voorbij de parallelle slots worden verzoeken in de wachtrij geplaatst tot OLLAMA_MAX_QUEUE, standaard 512, waarna de server een 503-foutmelding geeft.
vLLM gebruikt continuous batching, waardoor nieuwe verzoeken aan de actieve batch worden toegevoegd zodra er slots vrijkomen. De curve blijft stijgen totdat een limiet wordt bereikt: meestal de KV-cache, hoewel een geconfigureerde limiet zoals max_num_seqs of overhead van CPU-scheduling de curve eerder kan afvlakken. Ollama is geoptimaliseerd voor één model, één machine en lage installatiekosten. De twee engines geven daarom verschillende antwoorden op dezelfde sweep, wat het eigenlijke onderwerp is van Ollama en vLLM vergeleken als serving engines. Noteer welke engine en welke versie elk getal heeft gegenereerd.
Vijf manieren om de verkeerde zaken te meten
- De client bevindt zich op grote afstand. Benchmarking vanaf uw laptop via het internet voegt uw eigen round-trip tijd toe aan elke TTFT, waardoor u in feite uw eigen internetverbinding meet. Voer de client uit in dezelfde regio als de server.
- Het model was koud. De eerste aanvraag omvat het laden van de gewichten, en bij vLLM kan dit ook het vastleggen van de graaf (graph capture) inhouden. Verstuur een opwarmingsbatch en negeer het resultaat daarvan.
- Prefix caching gaf antwoord voor u. vLLM schakelt standaard automatische prefix caching in. Het herhaaldelijk versturen van dezelfde prompt meet daarom de cache in plaats van de prefill, waardoor de TTFT daalt tot een fractie van de werkelijke waarde.
--dataset-name randomvoorkomt dit omdat elke prompt verschilt. Start voor de zekerheid de server met--no-enable-prefix-caching. - De output was te kort. Bij antwoorden van 32 tokens domineert de TTFT elk verzoek en beschrijft uw tokens per seconde in feite de prefill. Gebruik
--ignore-eosmet een realistische outputlengte. - U rapporteerde alleen concurrency 1. Dit levert de gunstigste TTFT op in het overzicht, en is alleen de juiste kosteninput als uw werkelijke verzoeken nooit overlappen. Als ze wel overlappen, hangen de kosten af van de doorvoer die u behaalt bij de concurrency die uw verkeer daadwerkelijk genereert; meet daarom ook op dat niveau.
Uw gemeten getallen omzetten in een besluit
Neem de output-throughput die uw sweep laat zien bij de concurrency van uw werkelijke verkeer en vergelijk deze met de prijs per token. Dit is alleen het verzadigingscijfer als er voldoende verzoeken overlappen om de batch vol te houden; een workload die één verzoek per keer verstuurt, moet de single-stream rate gebruiken. Het break-evenpunt is een kwestie van delen, zodra u de prijs berekent van de input-tokens die bij elk output-token horen:
cost_per_million_output = price_out + price_in * (input_tokens / output_tokens)
break_even_tok_s = (price_per_hour / cost_per_million_output) * 1000000 / 3600Reken dit door met de prijzen van DigitalOcean van juli 2026. Hun H200 dedicated inference endpoint kostte $4.47 per uur, en serverless Llama 3.3 70B kostte $0.65 per miljoen tokens voor input en $0.65 per miljoen voor output. Bij de hierboven gebruikte 1:1-verhouding brengt elke miljoen output-tokens een miljoen input-tokens met zich mee, dus de effectieve prijs is $1.30 per miljoen output-tokens. 4.47 gedeeld door 1.30 is ongeveer 3.44 miljoen output-tokens per uur; delen door 3.600 seconden geeft ongeveer 955 output-tokens per seconde, of ongeveer 1.910 tokens per seconde inclusief input en output. De prijzen zijn van hen. De deling is van ons. Toen we op 25 oktober 2026 keken, was het H200-endpoint nog steeds $4.47 per uur, maar DigitalOcean beëindigde serverless Llama 3.3 70B op 18 augustus 2026 en verwijst gebruikers naar Llama 4 Maverick, geprijsd op $0.25 per miljoen input-tokens en $0.87 per miljoen output-tokens. Dat is een ander model, dus daarvoor is een eigen sweep nodig voordat de vergelijking zinvol is.
Het woord dat hierbij de doorslag geeft is duurzaam. Het bereiken van 955 output-tokens per seconde bij verzadiging gedurende twee uur per dag is geen 955 output-tokens per seconde duurzaam, omdat u ook voor de overige tweeëntwintig uur betaalt. Het huren van de kaart als een GPU Droplet verlaagt de drempel niet: op 25 oktober 2026 vermeldde de Droplet-prijslijst van DigitalOcean de H200 op $4.47 per uur on-demand, hetzelfde als het endpoint. De goedkoopste NVIDIA Droplets, de RTX 4000 voor $0.76 per uur en de L40S of RTX 6000 voor $1.57 per uur, zijn te klein om een 70B-model in FP8 te laden. Op basis van de bovenstaande cijfers moet een H200 die verzadigt bij 2.036 output-tokens per seconde gemiddeld ongeveer 47 procent van die piek halen over elk uur waarvoor u betaalt om de $0.65 per miljoen tokens in en uit te evenaren; daaronder wint de prijs per token. Inactieve GPU-uren, niet trage tokens, zijn meestal de reden waarom zelf-hosting niet rendabel is.
Uw besluit heeft dus twee inputs. De sweep geeft u het plafond. Uw verkeerspatroon geeft u het percentage van dat plafond dat u daadwerkelijk benut. Vermenigvuldig deze, neem het resultaat naar de GPU VPS versus break-even per token API en lees het antwoord voor uw volume af.
FAQ
Wat is een goed aantal tokens per seconde voor een zelfgehoste LLM?
Er zijn twee antwoorden mogelijk, omdat de metriek twee doelen dient. Voor één persoon die de output leest, is alles boven ongeveer 20 output-tokens per seconde per stream al sneller dan de leessnelheid, dus meer levert geen voordeel op. Voor de kosten is het relevante getal de totale output-doorvoer die u onder uw werkelijke belasting kunt volhouden; "goed" betekent hierbij alles wat uw break-evenpunt haalt. Bij een prijs van $0,65 per miljoen tokens, zowel input als output, op een server die $4,47 per uur kost, ligt die ondergrens rond de 955 output-tokens per seconde bij een 1:1 verhouding en prijzen van juli 2026. Eén stream op een groot model haalt dit nooit, wat de reden is dat batching bestaat.
Waarom blijft mijn Ollama-doorvoer gelijk wanneer ik gelijktijdige verzoeken toevoeg?
OLLAMA_NUM_PARALLEL staat standaard op 1, waardoor de server per model één verzoek tegelijk verwerkt en de rest in de wachtrij plaatst, tot een maximum van OLLAMA_MAX_QUEUE (standaard 512) voordat een 503-fout wordt geretourneerd. De totale output blijft gelijk terwijl de p99 TTFT stijgt; dit is het kenmerk van een wachtrij in plaats van een overbelaste GPU. Stel de variabele in via een systemd drop-in en herstart de service, controleer daarna ollama ps, omdat elk parallel slot de toegewezen context vermenigvuldigt en een deel van het model naar de CPU kan dwingen.
Moet ik de tijd tot het eerste token (TTFT) of de tokens per seconde meten?
Beide, aangezien ze in tegengestelde richting bewegen naarmate de belasting toeneemt. TTFT is wat een gebruiker ervaart, en de verzadigde output-doorvoer is wat uw factuur bepaalt. Registreer de p50 en p99 TTFT bij elke stap in gelijktijdigheid en kies vervolgens de hoogste gelijktijdigheid waarbij de p99 TTFT voor u nog acceptabel is. Rapporteer de doorvoer op dat punt als uw capaciteit, niet het maximum aan de top van de curve.
Betekent een hoger aantal tokens per seconde altijd lagere kosten per token?
Nee. De kosten per token zijn de uurprijs gedeeld door het aantal tokens dat de server in dat uur daadwerkelijk heeft geproduceerd; een snelle server die het grootste deel van de dag niets doet, heeft dus nog steeds hoge kosten per token. De bezettingsgraad bepaalt dit, niet de pieksnelheid. Let ook op de eenheden: een opgegeven totale token-doorvoer telt input-tokens mee, dus bij een 1:1 verhouding tussen input en output is dit bijna het dubbele van de output-snelheid. Als de API waarmee u vergelijkt zowel input- als output-tokens factureert, bereken dan de prijs van beide helften voordat u vergelijkt.