స్థానిక LLMలో tokens per second ఎలా కొలవాలి
రెంటుకు తీసుకున్న GPU, ప్రతి token billing కంటే ఎప్పుడు చౌకగా ఉంటుందో తెలుసుకోండి. concurrency sweepతో tokens per second కొలిచి throughput floor లెక్కించండి.
tokens per second GPU ఖర్చును సమర్థిస్తుందో నిర్ణయిస్తుంది
tokens per second అనేది మీ server output text ను ఉత్పత్తి చేసే రేటు. GPU ను అద్దెకు తీసుకోవడం, ప్రతి token కు APIకి చెల్లించడం కంటే చౌకగా ఉంటుందా అనే విషయాన్ని నిర్ణయించే సంఖ్య ఇదే. GPU box busyగా ఉన్నా idleగా ఉన్నా గంటల ప్రాతిపదికన billing జరుగుతుంది. Hosted APIకి token ప్రాతిపదికన billing జరుగుతుంది. కాబట్టి, మీరు చెల్లించే ఎక్కువ గంటల్లో output rate తగినంతగా ఉంటేనే GPU ఆర్థికంగా ప్రయోజనకరంగా ఉంటుంది.
అందువల్ల, ఎక్కడో చదివిన సంఖ్యపై ఆధారపడకుండా measurement అవసరం. ఈ పేజీ నమోదు చేయాల్సిన నాలుగు ముఖ్యమైన సంఖ్యలను వివరిస్తుంది. వాటిని పొందడానికి అవసరమైన commands ను, ఆ సంఖ్యలను ఉపయోగించి నిర్ణయం తీసుకునే arithmetic ను కూడా అందిస్తుంది.
ప్రచురించిన tokens per second గణాంకం మీ వాస్తవ సంఖ్య ఎందుకు కాదు
DigitalOcean, July 2026లో ఒక NVIDIA H200 పై llama3.3-70b-instruct ను vLLM కింద FP8 (8-bit floating point) లో నడిపినప్పుడు లభించిన throughput గణాంకాలను ప్రచురించింది. ఆ గణాంకాలు ఉపయోగకరమైనవి. కానీ అవి మీ గణాంకాలు కావు.
ఈ చార్ట్ వెనుక ఉన్న డేటా
[
{
"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"
}
]పై పట్టికలోని ప్రతి వరుసను ఆ పేజీ నుంచే తీసుకున్నాం. వాటిలో రెండు ఆ పేజీ ఇచ్చిన పరిధిలోని కనిష్ఠ విలువలు. అందువల్ల ఆ రెండింటిని కనీస స్థాయిగా పరిగణించాలి. ఈ పట్టికలోని ఏ విలువనూ మేము స్వయంగా కొలవలేదు.
చివరి రెండు వరుసలతో ప్రారంభించండి. ప్రధాన గణాంకం 4,071.6 tok/s. Output-only rate 2,036 tok/s. ప్రధాన గణాంకం input మరియు output tokens ను కలిపి లెక్కిస్తుంది. ఆ పరీక్షలో 1,024 input tokens కు 1,024 output tokens ఉపయోగించారు. అందువల్ల ప్రధాన గణాంకంలో దాదాపు సగం మాత్రమే output. ఈ విభజన ముఖ్యమైనది. ఎందుకంటే output భాగం నెమ్మదిగా ఉంటుంది. Prefill, అంటే prompt ను చదవడం, అన్ని input tokens ను ఒకే pass లో process చేస్తుంది. Decode, అంటే సమాధానం రాయడం, ఒక్కసారి ఒక token ను మాత్రమే ఉత్పత్తి చేస్తుంది. Total-throughput గణాంకం తక్కువ ఖర్చున్న పనిని ఎక్కువ ఖర్చున్న పనితో కలిపి సగటు చేస్తుంది.
ఇప్పుడు మొదటి వరుసను చూడండి. అదే H200 ఒకేసారి ఒక request ను serve చేస్తే 47 tok/s ఉత్పత్తి చేస్తుంది. కాబట్టి అదే hardware పై saturated figure 40 రెట్లకంటే ఎక్కువగా ఉంటుంది. ఒక decode step సమయంలో GPU ఎక్కువ సమయం memory కోసం వేచి ఉంటుంది. Concurrent requests ఆ ఖాళీ సమయాన్ని ఉపయోగిస్తాయి. అందువల్ల ఈ తేడా ఏర్పడుతుంది. రెండో వరుసలోని 236 tok/s ఒకే model పై నడిచే single H100 గణాంకం. దీన్ని KV cache పరిమితం చేస్తుంది. KV cache అంటే key and value cache. Serve చేస్తున్న conversation ప్రతి request కోసం card పై ఉంచుకునే memory ఇది. 80 GB card పై 70B model కు తక్కువ concurrent requests మాత్రమే ఉంచగలరు. అందువల్ల అది తక్కువ స్థాయిలో saturate అవుతుంది.
Model ను మార్చినా లేదా input-to-output ratio ను మార్చినా పై గణాంకాలన్నీ మారతాయి. Published figures మీ అంచనాలను నిర్ణయిస్తాయి. మీ budget ను కాదు. Disk మరియు network పై VPS benchmarking ను నిజాయితీగా నిర్వహించడం విషయంలో కూడా ఇదే నియమం వర్తిస్తుంది.
ముఖ్యమైన నాలుగు సంఖ్యలు
- మొదటి token కు పట్టే సమయం, TTFT. అభ్యర్థన పంపినప్పటి నుంచి మొదటి output token వచ్చే వరకు ఉండే ఆలస్యం. ఇందులో prefill సమయం మరియు queue సమయం ఉంటాయి. వినియోగదారుడు దీనిని నేరుగా అనుభవిస్తాడు.
- ప్రతి stream కు సెకనుకు వచ్చే output tokens. సమాధానం ప్రారంభమైన తర్వాత అది ఎంత వేగంగా వ్రాయబడుతుందో ఇది చూపిస్తుంది. సుమారుగా 20 tok/s కంటే ఎక్కువ వేగం ఉంటే, అది ఇప్పటికే చాలామంది చదివే వేగం కంటే ఎక్కువగా ఉంటుంది. అందువల్ల ఇక్కడ అదనపు వేగం వల్ల ప్రయోజనం తక్కువ.
- పూర్తి లోడ్లో మొత్తం output throughput. server పూర్తిగా లోడ్లో ఉన్నప్పుడు, సమాంతరంగా నడుస్తున్న అన్ని streams లోని output వేగాల మొత్తం. ఇది capacity సంఖ్య. GPU ఖర్చును భరించే సామర్థ్యాన్ని నిర్ణయించేది ఇదే.
- సమాంతర అభ్యర్థనల సమయంలో p50 మరియు p99 TTFT. p50 అంటే మధ్యస్థ అభ్యర్థన. p99 అంటే 100 అభ్యర్థనల్లో 99 అభ్యర్థనలు ఈ విలువ కంటే తక్కువ సమయంలో పూర్తయ్యే పరిమితి. Queueing ప్రభావం మొదట p99లో కనిపిస్తుంది.
server ఖాళీగా ఉన్నప్పుడు మొదటి రెండు మెరుగ్గా ఉంటాయి. server busyగా ఉన్నప్పుడు మూడవది మెరుగ్గా ఉంటుంది. ఇవి పరస్పరం వ్యతిరేకంగా ప్రభావితం చేస్తాయి. అందుకే serving box పనితీరును ఒకే సంఖ్యతో వివరించలేం.
మీరు కొలవడానికి ముందు ఇన్పుట్ మరియు అవుట్పుట్ పొడవులను స్థిరపరచండి
Throughput ట్రాఫిక్ ఆకృతిపై ఆధారపడి ఉంటుంది. 4,000-token prompt మరియు 50-token answer ఉన్న పని prefill-heavy. 200-token prompt మరియు 2,000-token answer ఉన్న పని decode-heavy. ఈ రెండు సందర్భాల్లో అదే server సెకనుకు tokens సంఖ్యను చాలా భిన్నంగా చూపిస్తుంది. అందువల్ల ఒకే నిష్పత్తిని ఎంచుకుని, నమోదు చేసే ప్రతి సంఖ్య పక్కన దాన్ని రాయండి. వేర్వేరు నిష్పత్తుల మధ్య ఎప్పుడూ పోల్చవద్దు. 1,024 ఇన్పుట్ మరియు 1,024 అవుట్పుట్ ఒక సమంజసమైన default, ఎందుకంటే అనేక vendors ఆ నిష్పత్తిలో గణాంకాలను ప్రచురిస్తారు. మీ వాస్తవ traffic మీకు తెలిసి ఉంటే, అదే traffic ను ఉపయోగించండి.
అవుట్పుట్ పొడవును కూడా నిర్దిష్టంగా ఉంచండి. ఒక model 60 tokens తర్వాత stop token ను చేరుకుంటే, అది పూర్తి run తో పోల్చలేని చిన్న run అవుతుంది. అందులో TTFT వాటా ఎక్కువగా ఉంటుంది. దాంతో benchmark లెక్కించే output throughput తగ్గుతుంది, అయితే ప్రతి request త్వరగా పూర్తవుతుంది. vLLM benchmark client లోని --ignore-eos flag ప్రతి request ద్వారా కోరిన సంఖ్యలో tokens ను ఖచ్చితంగా generate చేయిస్తుంది. అందువల్ల రెండు runs ను పోల్చగలిగేలా ఉంచవచ్చు. ఈ సంఖ్యలను ఏ flag కంటే model ఎంపిక ఎక్కువగా ప్రభావితం చేస్తుంది: ఒకే VPS GPUలో Qwen 3 model కు సరిపడేలా అమర్చడం ఆ ఎంపికకు సంబంధించిన memory అంశాన్ని వివరిస్తుంది.
ముందుగా ఒక stream ను కొలవండి
అత్యంత సరళమైన పరిస్థితితో ప్రారంభించండి. ఇది sanity check కూడా, గరిష్ఠ పరిమితి కూడా. Ollama తన స్వంత timings ను చూపిస్తుంది.
ollama run llama3.1:8b --verbose "Write 200 words about disk scheduling."చూడాల్సిన line eval rate. ఇది ప్రతి సెకనుకు output tokens సంఖ్య. prompt eval rate prefill rate, load duration model ను VRAM లోకి load చేయడానికి పట్టిన సమయం. cold start తర్వాత చేసే మొదటి call లో load duration పెద్దగా ఉంటుంది. అందువల్ల total duration తప్పుదారి పట్టించవచ్చు. command ను రెండుసార్లు run చేసి, రెండవ result ను చదవండి. డిఫాల్ట్గా idle model ను Ollama ఐదు నిమిషాల తర్వాత unload చేస్తుంది. కాబట్టి runs మధ్య ఎక్కువ విరామం ఉంటే మళ్లీ cold case కు వెళ్తారు.
ఇదే fields API నుంచి కూడా లభిస్తాయి. వీటిని script చేయడం సులభం.
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 nanoseconds లో ఉంటుంది. కాబట్టి దాన్ని 1,000,000,000 తో భాగిస్తే seconds వస్తాయి. tokens per second కోసం Ollama స్వంత API documentation కూడా ఇదే division ను సూచిస్తుంది. server ఇంకా ప్రారంభం కాకపోతే, VPS పై Ollama తో LLM ను self-host చేయడం గురించి Ollama తో VPS పై LLM ను self-host చేయడం లో install మరియు systemd unit వివరాలు ఉన్నాయి.
TTFT కోసం streaming request అవసరం. curl దానికి పట్టే సమయాన్ని మీ కోసం కొలవగలదు.
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 response body లోని మొదటి byte వచ్చిన క్షణం. streaming chat completion లో ఆ byte మొదటి server-sent event కు చెందుతుంది. అది మొదటి content token కావచ్చు లేదా దానికి వెంటనే ముందు పంపే role-only delta కావచ్చు. అందువల్ల ఈ విలువను ఒక event వరకు తేడా ఉండే TTFT గా పరిగణించండి. అదే server పై రెండు runs ను పోల్చడానికి ఇది సరిపడేంత ఖచ్చితంగా ఉంటుంది.
Single-stream సంఖ్యలు server సామర్థ్యాన్ని రెండుసార్లు ఎక్కువగా చూపిస్తాయి. మీకు ముందు ఏదీ queue లో లేకపోవడం వల్ల TTFT ఎప్పటికీ పొందగలిగే ఉత్తమ విలువగా ఉంటుంది. మొత్తం card ఒకే request కు సేవలందించడం వల్ల ప్రతి-stream rate కూడా ఎప్పటికీ పొందగలిగే ఉత్తమ విలువగా ఉంటుంది. ఈ రెండింటిలో ఏదీ server వాస్తవంగా ఎంత load ను నిర్వహించగలదో చెప్పదు.
concurrency sweep ఎలా నిర్వహించాలి?
ఒక sweep లో ఒకే workload ను పెరుగుతున్న concurrency స్థాయులతో అమలు చేసి, ప్రతి దశలో ఏమి జరుగుతుందో నమోదు చేస్తారు. vLLM దీనికోసం client ను అందిస్తుంది. ఇది OpenAI APIతో పనిచేస్తుంది. అందువల్ల Ollama మరియు OpenAI-compatible అయిన ఇతర సేవలపైనా ఇది పనిచేస్తుంది.
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 ప్రస్తుతం అమలులో ఉన్న requests సంఖ్యకు పరిమితి విధిస్తుంది. మీరు sweep చేసేది ఇదే variable. --num-prompts మొత్తం పంపిన requests సంఖ్య. స్థిరమైన average కోసం దీన్ని concurrency కి సుమారు పది రెట్లు ఉంచండి. Summaryలో Output token throughput (tok/s): మరియు Total token throughput (tok/s):, తరువాత Time to First Token heading కింద Mean TTFT (ms):, Median TTFT (ms): మరియు P99 TTFT (ms): కనిపిస్తాయి.
ఆ outputలో ప్రతి stream కు rate విడిగా ఉండదు. కానీ దాన్ని ఒక division తో లెక్కించవచ్చు. మొదటి output token తరువాత ప్రతి token కు సగటు సమయం Mean TPOT (ms):. కాబట్టి ప్రతి token కు 25 ms అంటే ప్రతి stream కు సెకనుకు 40 tokens. Output throughput ను concurrency తో భాగిస్తే అదే ఫలితం వస్తుంది.
తరువాత దీన్ని loopలో అమలు చేసి, ప్రతి run ను save చేయండి.
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"
donesave చేసిన JSON files ను చదవడం
ప్రతి run ఒక file రాస్తుంది. కాబట్టి అవసరమైన fields ను అన్ని files నుంచి ఒకేసారి తీసుకోండి.
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 output tokens per second. total_token_throughput input tokens ను కూడా తిరిగి కలుపుతుంది. అందువల్ల 1:1 ratio వద్ద ఇది దాదాపు రెట్టింపు అవుతుంది. --metric-percentiles లేకపోయినా p99_ttft_ms ఉంటుంది, ఎందుకంటే ఆ flag defaultగా 99. Commandలోని 50, ప్రతి --percentile-metricsలో పేర్కొన్న metric కు సంబంధించిన median_ttft_ms పక్కన p50_ttft_ms ను జోడిస్తుంది. .p90_ttft_ms వంటి మీరు request చేయని percentile ను అడిగితే, jq null ను print చేస్తుంది.
కాంకరెన్సీ sweep వాస్తవంగా ఏమి చూపిస్తుంది?
ఈ చార్ట్ వెనుక ఉన్న డేటా
[
{
"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
}
]ఆ 6 వరుసలు, తక్కువ ధరకు అద్దెకు తీసుకోగల GPU box పై sweep ఎలా కనిపిస్తుందో చూపించే ఉదాహరణ మాత్రమే. ఇవి సాధ్యమైన పరిమాణ స్థాయిల ఆధారంగా ఇచ్చిన విలువలు. ఇవి మీ server పై చేసిన కొలతలు కావు. ఇవి vendor ఇచ్చిన గణాంకాలు కూడా కావు. పై loop ను run చేసి, వాటి స్థానంలో మీ విలువలను పెట్టండి.
ఆకృతిని గమనించండి. సాధారణంగా వర్తించేది ఆ ఆకృతే. ఒక stream వద్ద మొత్తం box ప్రతి సెకనుకు 92 tokens ను ఉత్పత్తి చేస్తుంది. p99 TTFT 61 ms గా ఉంటుంది. 128 streams వద్ద మొత్తం throughput ప్రతి సెకనుకు 2304 tokens కు చేరుతుంది. ఇది ఇరవై ఐదు రెట్లు ఎక్కువ. అయితే ప్రతి stream వేగం ప్రతి సెకనుకు 18 tokens కు తగ్గుతుంది. p99 TTFT 3820 ms కు చేరుతుంది. Batching వల్ల idle memory waits ఉపయోగకరమైన పనిగా మారుతుంది కాబట్టి మొత్తం throughput పెరుగుతుంది. అదే compute ఇప్పుడు అనేక streams మధ్య పంచబడుతుంది కాబట్టి ప్రతి stream వేగం తగ్గుతుంది.
చివరి doubling ముఖ్యమైన సూచన. 64 streams నుంచి 128 streams కు పెంచినప్పుడు మొత్తం throughput కు ఆరు శాతానికి తక్కువ మాత్రమే పెరుగుదల ఉంటుంది. అదే సమయంలో p99 TTFT సుమారు మూడు రెట్లు పెరుగుతుంది. దీనర్థం requests అమలు కాకుండా queue లో వేచి ఉంటున్నాయి. దీనికి కారణం KV cache నిండిపోవడం కావచ్చు. లేదా vLLM యొక్క max_num_seqs వంటి scheduling cap ను server చేరుకోవడం కావచ్చు. ఉపయోగకరమైన operating point అంతకంటే ముందే ఉంటుంది. 32 streams వద్ద కూడా box ప్రతి సెకనుకు 1728 tokens ను తిరిగి ఇస్తుంది. ఇది peak లో 75 శాతం. ప్రతి stream వేగం ప్రతి సెకనుకు 54 tokens గా ఉంటుంది. p99 TTFT 498 ms గా ఉంటుంది. ఆ point ను మీ capacity గా report చేయండి. Curve లోని peak ఆధారంగా users కు మీరు service అందించలేరు.
Ollama మరియు vLLM ఒకే విషయాన్ని కొలవవు
ఆ sweep ను default Ollama server పై అమలు చేస్తే మొత్తం విలువలో చాలా స్వల్ప మార్పు మాత్రమే కనిపిస్తుంది. OLLAMA_NUM_PARALLEL default గా 1 ఉంటుంది. అందువల్ల ఒక request మాత్రమే నడుస్తుంది, మిగతావి వేచి ఉంటాయి. ఈ queue కారణంగానే p99 TTFT పెరుగుతుంది, అయితే మొత్తం output స్థిరంగా ఉంటుంది. ఏదైనా కొలిచే ముందు దీని విలువను పెంచండి.
sudo systemctl edit ollama.service[Service]
Environment="OLLAMA_NUM_PARALLEL=8"sudo systemctl restart ollama తో restart చేసి, model ఇప్పటికీ సరిపోతుందో నిర్ధారించండి. ప్రతి parallel slot కు context window లో ప్రత్యేక భాగం కేటాయించబడుతుంది. అందుకే 4 parallel requests కోసం 2K context ను 8K గా కేటాయిస్తారని Ollama documentation పేర్కొంటుంది. Slot count ను ఎక్కువగా పెంచితే model VRAM పరిమితిని దాటి బయటకు వస్తుంది. ollama ps ను పరిశీలించండి: PROCESSOR column లో 48%/52% CPU/GPU వంటి విలువ కనిపిస్తే, model లోని కొంత భాగం CPU పై నడుస్తోందని అర్థం. అప్పుడు concurrency పెంచిన కొద్దీ throughput పెరగకుండా తగ్గుతుంది. Parallel slots పూర్తైన తరువాత requests OLLAMA_MAX_QUEUE వరకు queue అవుతాయి. దీని default విలువ 512. ఆ పరిమితి దాటిన తరువాత server 503 ను పంపుతుంది.
vLLM continuous batching ను ఉపయోగిస్తుంది. అందువల్ల slots ఖాళీ అయినప్పుడు కొత్త requests ను నడుస్తున్న batch లోకి చేర్చుతుంది. ఏదో ఒక వనరు పూర్తయ్యే వరకు దాని curve పెరుగుతూనే ఉంటుంది. సాధారణంగా ఆ వనరు KV cache. అయితే max_num_seqs వంటి configured cap లేదా CPU scheduling overhead కారణంగా curve ఇంకా ముందే స్థిరపడవచ్చు. Ollama ఒక model, ఒక machine, తక్కువ setup cost కోసం optimize చేయబడుతుంది. అందువల్ల ఒకే sweep కు ఈ రెండు engines వేర్వేరు ఫలితాలను ఇస్తాయి. ఇదే Ollama మరియు vLLM ను serving engines గా పోల్చడం యొక్క అసలు విషయం. ప్రతి సంఖ్యను ఏ engine, ఏ version ఉత్పత్తి చేసిందో నమోదు చేయండి.
తప్పు విషయాన్ని కొలిచే ఐదు విధానాలు
- Client చాలా దూరంలో ఉంది. Internet ద్వారా మీ laptop నుంచి benchmark చేస్తే, ప్రతి TTFTలో మీ round trip కూడా చేరుతుంది. అప్పుడు మీరు మీ home connection పనితీరును కొలుస్తారు. Client ను server ఉన్న regionలోనే నడపండి.
- Model coldగా ఉంది. మొదటి requestలో weights loading సమయం పడుతుంది. vLLMలో graph capture సమయం కూడా పడవచ్చు. Warmup batchను పంపి, వచ్చిన resultను విస్మరించండి.
- Prefix caching మీ తరఫున సమాధానం ఇచ్చింది. vLLMలో automatic prefix caching defaultగా enabledగా ఉంటుంది. అందువల్ల అదే promptను పదేపదే పంపితే prefillకు బదులుగా cacheను కొలుస్తారు. TTFT వాస్తవ విలువలోని చిన్న భాగానికి పడిపోతుంది.
--dataset-name randomప్రతి promptను భిన్నంగా ఉంచుతుంది కాబట్టి ఈ సమస్యను నివారిస్తుంది. నిర్ధారించుకోవడానికి serverను--no-enable-prefix-cachingతో ప్రారంభించండి. - Outputs చిన్నవిగా ఉన్నాయి. 32-token answersతో ప్రతి requestలో TTFT ఆధిపత్యం చూపుతుంది. మీరు కొలిచే tokens per second వాస్తవానికి prefillను వివరిస్తుంది. వాస్తవిక output lengthతో
--ignore-eosఉపయోగించండి. - Concurrency 1 మాత్రమే నివేదించారు. ఇది పట్టికలో అత్యంత అనుకూలమైన TTFTను ఇస్తుంది. మీ వాస్తవ requests ఎప్పుడూ overlap కాకపోతే మాత్రమే ఇది సరైన cost input. అవి overlap అయితే, మీ traffic వాస్తవంగా సృష్టించే concurrency వద్ద మీరు కొనసాగించగల throughputపై cost ఆధారపడి ఉంటుంది. కాబట్టి ఆ స్థాయిలో కూడా కొలవండి.
మీ కొలిచిన సంఖ్యను నిర్ణయంగా మార్చడం
మీ వాస్తవ traffic చేరుకునే concurrency వద్ద sweep చూపించిన output throughput ను per-token pricing తో పోల్చండి. Batch నిండుగా ఉండేలా తగినన్ని requests overlap అయినప్పుడే అది saturated figure అవుతుంది. ఒక workload ఒకేసారి ఒక request మాత్రమే పంపితే, single-stream rate ను ఉపయోగించాలి. ప్రతి output token తో వచ్చే input tokens ధరను లెక్కలోకి తీసుకున్న తరువాత break-even ను ఒక divisionతో కనుగొనవచ్చు:
cost_per_million_output = price_out + price_in * (input_tokens / output_tokens)
break_even_tok_s = (price_per_hour / cost_per_million_output) * 1000000 / 3600DigitalOcean యొక్క July 2026 ధరలతో దీన్ని లెక్కిద్దాం. వారి H200 dedicated inference endpoint ధర గంటకు $4.47. Serverless Llama 3.3 70B ధర inputకు million tokens కు $0.65, outputకు million tokens కు $0.65. పైన ఉపయోగించిన 1:1 ratio వద్ద ప్రతి million output tokens తో ఒక million input tokens కూడా వస్తాయి. అందువల్ల effective price ప్రతి million output tokens కు $1.30. కాబట్టి 4.47 ను 1.30తో భాగిస్తే గంటకు సుమారు 3.44 million output tokens వస్తాయి. 3,600 secondsతో భాగిస్తే సెకనుకు సుమారు 955 output tokens, input మరియు output రెండింటినీ కలిపితే సెకనుకు సుమారు 1,910 tokens వస్తాయి. ఈ ధరలు వారివి. ఈ division మనది. 25 October 2026న మేము పరిశీలించినప్పుడు H200 endpoint ధర ఇంకా గంటకు $4.47గానే ఉంది. అయితే DigitalOcean, serverless Llama 3.3 70Bను 18 August 2026న deprecated చేసి, usersను Llama 4 Maverick వైపు మళ్లించింది. దాని ధర million input tokens కు $0.25, million output tokens కు $0.87గా ఉంది. అది వేరే model. కాబట్టి comparisonకు అర్థం రావాలంటే దానిపై ప్రత్యేక sweep అవసరం.
ఈ నిర్ణయాన్ని ప్రభావితం చేసే పదం sustained. Saturation వద్ద రోజుకు రెండు గంటలు సెకనుకు 955 output tokens సాధించడం అంటే sustainedగా సెకనుకు 955 output tokens అని కాదు. మిగిలిన ఇరవై రెండు గంటలకు కూడా మీరు చెల్లించాలి. Cardను GPU Dropletగా అద్దెకు తీసుకోవడం వల్ల కూడా ఈ పరిమితి తగ్గదు. 25 October 2026న DigitalOcean Droplet pricingలో H200 on-demand ధర గంటకు $4.47గా ఉంది. ఇది endpoint ధరతో సమానం. వారి చవకైన NVIDIA Droplets అయిన RTX 4000 గంటకు $0.76, L40S లేదా RTX 6000 గంటకు $1.57 ధరలకు లభిస్తాయి. కానీ అవి 70B modelను FP8లో ఉంచడానికి చాలా చిన్నవి. కాబట్టి పై సంఖ్యల ప్రకారం, saturation వద్ద సెకనుకు 2,036 output tokens ఇచ్చే H200, input మరియు output రెండింటికీ million tokens కు $0.65 ధరతో సమానం కావాలంటే, మీరు చెల్లించే ప్రతి గంటలో దాని peakలో సగటున సుమారు 47 శాతం సాధించాలి. దానికంటే తక్కువైతే per-token ధరే ప్రయోజనకరం. సాధారణంగా self-hostingను నష్టపరిచేది slow tokens కాదు; ఉపయోగించని GPU hours.
కాబట్టి మీ నిర్ణయానికి రెండు inputs ఉన్నాయి. Sweep మీకు ceilingను ఇస్తుంది. మీ traffic patternలో ఆ ceilingలో వాస్తవంగా మీరు పొందే fraction తెలుస్తుంది. వాటిని గుణించి, ఆ ఫలితాన్ని per-token API break-evenతో GPU VPSను పోల్చండి అనే అంశానికి తీసుకెళ్లి, మీ volumeకు సరైన సమాధానాన్ని గుర్తించండి.
FAQ
self-hosted LLM కు సెకనుకు ఎన్ని tokens మంచి throughput గా పరిగణించాలి?
దీనికి రెండు సమాధానాలు ఉన్నాయి, ఎందుకంటే ఈ metric రెండు పనులు చేస్తుంది. Output ను ఒక వ్యక్తి చదువుతున్నప్పుడు, ప్రతి stream కు సెకనుకు సుమారు 20 output tokens కంటే ఎక్కువ ఉంటే చదివే వేగం కంటే ఇప్పటికే ఎక్కువగా ఉంటుంది. కాబట్టి దానికంటే ఎక్కువ వేగం ఉపయోగకరంగా ఉండదు. ఖర్చు విషయానికి వస్తే, మీ వాస్తవ load లో నిరంతరం నిర్వహించగలిగే మొత్తం output throughput ముఖ్యం. Break-even స్థాయిని దాటించగలిగే throughput ఏదైనా సరిపోతుంది. Input మరియు output రెండింటికీ ప్రతి million tokens కు $0.65, అలాగే గంటకు $4.47 ఖర్చయ్యే server ను పరిగణిస్తే, July 2026 ధరల వద్ద 1:1 నిష్పత్తిలో నిరంతరంగా సెకనుకు సుమారు 955 output tokens అవసరం. పెద్ద model పై ఒక stream ఈ స్థాయిని చేరదు. అందుకే batching అవసరం.
concurrent requests జోడించినప్పుడు నా Ollama throughput స్థిరంగానే ఎందుకు ఉంటుంది?
OLLAMA_NUM_PARALLEL default విలువ 1. కాబట్టి server ప్రతి model కు ఒకేసారి ఒక request మాత్రమే నడుపుతుంది. మిగిలిన requests ను queue లో ఉంచుతుంది. ఈ queue పరిమితి OLLAMA_MAX_QUEUE వరకు ఉంటుంది. Default గా అది 512. పరిమితి దాటితే server 503 ను తిరిగి ఇస్తుంది. p99 TTFT పెరుగుతున్నప్పటికీ మొత్తం output స్థిరంగా ఉంటే, GPU busyగా ఉండటం కంటే queue ఏర్పడిందనేది సాధారణ కారణం. systemd drop-in లో ఈ variable ను సెట్ చేసి service ను restart చేయండి. తరువాత ollama ps ను పరిశీలించండి. ప్రతి parallel slot కేటాయించిన context ను గుణిస్తుంది. దాంతో model లో కొంత భాగం CPU పైకి వెళ్లవచ్చు.
time to first token ను కొలవాలా, లేక tokens per second ను కొలవాలా?
రెండింటినీ కొలవాలి, ఎందుకంటే load పెరిగే కొద్దీ అవి వ్యతిరేక దిశల్లో మారతాయి. వినియోగదారుడు అనుభవించే latency ను TTFT నిర్ణయిస్తుంది. మీ invoice పై ప్రభావం చూపేది saturated output throughput. ప్రతి concurrency దశలో p50 మరియు p99 TTFT ను నమోదు చేయండి. తరువాత p99 TTFT మీకు ఇంకా ఆమోదయోగ్యంగా ఉన్న గరిష్ఠ concurrency ను ఎంచుకోండి. ఆ దశలోని throughput ను మీ capacity గా report చేయండి. Curve లోని గరిష్ఠ throughput ను capacity గా ఉపయోగించవద్దు.
tokens per second సంఖ్య ఎక్కువగా ఉంటే cost per token ఎల్లప్పుడూ తక్కువగా ఉంటుందా?
లేదు. Cost per token అనేది గంటకు server ధరను, ఆ గంటలో server వాస్తవంగా ఉత్పత్తి చేసిన tokens సంఖ్యతో భాగించిన విలువ. కాబట్టి రోజులో ఎక్కువ సమయం idle గా ఉండే వేగవంతమైన server కు కూడా cost per token ఎక్కువగా ఉంటుంది. Peak speed కాదు, utilisation దీనిని నిర్ణయిస్తుంది. Units ను కూడా జాగ్రత్తగా పరిశీలించండి. Quoted total token throughput లో input tokens కూడా ఉంటాయి. Input మరియు output నిష్పత్తి 1:1 అయితే, అది output rate కు దాదాపు రెట్టింపుగా ఉంటుంది. మీరు పోల్చుతున్న API input tokens తో పాటు output tokens కు కూడా bill చేస్తే, పోల్చే ముందు రెండు భాగాల ధరను లెక్కించండి.