SSD Nodes Learn Hosting plans →
கல்வி வழிகாட்டிகள் Matt Connorஆல் Matt Connor · புதுப்பிக்கப்பட்டது 2026-10-26

Local LLM-ல் Tokens Per Second அளவிடுவது எப்படி?

GPU வாடகை லாபகரமானதா என்பதை அறிய உங்கள் LLM-ன் throughput-ஐ துல்லியமாக அளவிடுங்கள். Concurrency sweep மூலம் tokens per second கணக்கிட்டு, API கட்டணத்துடன் ஒப்பிட்டு முடிவெடுங்கள்.

Tokens per second ஏன் ஒரு GPU-ன் லாபத்தை தீர்மானிக்கிறது

Tokens per second என்பது உங்கள் server வெளியீட்டு உரையை உருவாக்கும் வேகமாகும். ஒரு GPU-ஐ வாடகைக்கு எடுப்பது, API மூலம் token-க்கு பணம் செலுத்துவதை விட மலிவானதா என்பதை இந்த எண் தான் தீர்மானிக்கிறது. ஒரு GPU box பயன்பாட்டில் இருந்தாலும் இல்லாவிட்டாலும், மணிநேர அடிப்படையில் கட்டணம் வசூலிக்கப்படும். ஒரு hosted API-க்கு token அடிப்படையில் கட்டணம் வசூலிக்கப்படும். எனவே, நீங்கள் பணம் செலுத்தும் பெரும்பாலான மணிநேரங்களில் அதிக வெளியீட்டு வேகத்தை (output rate) பராமரித்தால் மட்டுமே GPU லாபகரமாக இருக்கும்.

இதற்கு நீங்கள் எங்கோ படித்த ஒரு புள்ளிவிவரத்தை நம்பாமல், நீங்களே அளவீடு செய்ய வேண்டும். இந்தப் பக்கம் பதிவு செய்ய வேண்டிய நான்கு முக்கியமான எண்களை வரையறுக்கிறது, அவற்றை உருவாக்கும் கட்டளைகளை வழங்குகிறது, மேலும் அவற்றை ஒரு முடிவாக மாற்றும் கணக்கீட்டு முறையையும் விளக்குகிறது.

ஒரு வெளியிடப்பட்ட tokens per second எண்ணிக்கை உங்கள் எண்ணிக்கையாக இருப்பதற்கான காரணம் இல்லை

DigitalOcean, July 2026-ல், vLLM-ன் கீழ் FP8 (8-bit floating point)-ல் llama3.3-70b-instruct இயக்கும் ஒரு NVIDIA H200-க்கான throughput எண்ணிக்கைகளை வெளியிட்டது. அந்த எண்ணிக்கைகள் பயனுள்ளவை; ஆனால் அவை உங்கள் எண்ணிக்கைகள் அல்ல.

விளக்கப்படம்Published DigitalOcean H200 figures, llama3.3-70b-instruct FP8, July 2026
இந்த விளக்கப்படத்தின் தரவு
[
  {
    "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"
  }
]

மேலுள்ள ஒவ்வொரு row-உம் அந்தப் பக்கத்திலிருந்து எடுக்கப்பட்டது. அவற்றில் இரண்டு, அந்தப் பக்கம் வழங்கும் range-ன் குறைந்த மதிப்புகள். எனவே, அந்த இரண்டையும் minimum அளவாகக் கருதவும். இந்த chart-ல் உள்ள எந்த எண்ணிக்கையையும் நாங்கள் அளவிடவில்லை.

முதலில் கடைசி இரண்டு row-களைப் பாருங்கள். Headline எண்ணிக்கை 4,071.6 tok/s. Output-only rate 2,036 tok/s. Headline எண்ணிக்கை input மற்றும் output tokens இரண்டையும் சேர்த்துக் கணக்கிடுகிறது. அந்த test-ல் 1,024 input tokens மற்றும் 1,024 output tokens பயன்படுத்தப்பட்டன. எனவே, headline எண்ணிக்கையின் கிட்டத்தட்ட பாதி output ஆகும். இந்தப் பிரிப்பு முக்கியமானது. ஏனெனில் output பகுதியே மெதுவானது. Prefill என்பது prompt-ஐ வாசிக்கும் செயல்முறை. இது அனைத்து input tokens-ஐ ஒரே pass-ல் process செய்கிறது. Decode என்பது பதிலை எழுதும் செயல்முறை. இது ஒவ்வொரு முறையும் ஒரு token-ஐ உருவாக்குகிறது. Total-throughput headline, குறைந்த செலவுடைய ஒன்றையும் அதிக செலவுடைய ஒன்றையும் சராசரியாகக் கணக்கிடுகிறது.

இப்போது முதல் row-ஐப் பாருங்கள். அதே H200, ஒரே நேரத்தில் ஒரு request-ஐ மட்டும் serve செய்யும்போது 47 tok/s வழங்குகிறது. எனவே, identical hardware-ல் saturated figure நாற்பது மடங்குக்கும் அதிகமாக உள்ளது. இதற்குக் காரணம், ஒரே decode step-ல் GPU-ன் பெரும்பாலான நேரம் memory-க்காக காத்திருக்கிறது. Concurrent requests அந்த idle time-ஐ பயன்படுத்துகின்றன. இரண்டாவது row-ன் எண்ணிக்கையான 236 tok/s, அதே model-ல் பயன்படுத்தப்படும் ஒரு H100-ன் எண்ணிக்கை. இதை KV cache கட்டுப்படுத்துகிறது. KV cache என்பது key மற்றும் value cache ஆகும். Served conversation ஒன்று card-ல் வைத்திருக்கும் per-request memory இதுவாகும். 70B model-க்கு 80 GB card-ல் குறைவான concurrent requests-ஐ மட்டுமே வைத்திருக்க முடியும். எனவே, அது குறைந்த saturation நிலையை அடைகிறது.

Model-ஐ மாற்றினாலும் அல்லது input-to-output ratio-வை மாற்றினாலும் மேலுள்ள ஒவ்வொரு எண்ணிக்கையும் மாறும். Published figures உங்கள் எதிர்பார்ப்புகளை அமைக்கின்றன; உங்கள் budget-ஐ அல்ல. Disk மற்றும் network-ல் ஒரு VPS-ஐ நேர்மையாக benchmark செய்வதற்கும் இதே விதிதான் பொருந்தும்.

கவனிக்க வேண்டிய நான்கு எண்கள்

  • Time to first token, TTFT. ஒரு கோரிக்கையை (request) அனுப்பியதற்கும், முதல் வெளியீட்டு டோக்கன் (output token) வந்தடைவதற்கும் இடைப்பட்ட தாமதம். இது prefill நேரம் மற்றும் queue நேரத்தின் கூட்டுத்தொகை. பயனர் இதை நேரடியாக உணர முடியும்.
  • Output tokens per second, per stream. ஒரு பதில் எழுதத் தொடங்கிய பிறகு, அது எவ்வளவு வேகமாக உருவாகிறது என்பது. வினாடிக்கு சுமார் 20 tokens-க்கு மேல் இருந்தால், அது பெரும்பாலானோர் படிக்கும் வேகத்தை விட அதிகம் என்பதால், கூடுதல் வேகம் பெரிய பயனைத் தராது.
  • Saturated total output throughput. சர்வர் முழுமையாகச் செயல்படும்போது, அனைத்து ஒரேநேர stream-களின் மொத்த வெளியீடு. இதுவே கொள்ளளவு (capacity) எண்; GPU செலவுகளைத் தீர்மானிப்பது இதுவே.
  • p50 and p99 TTFT under concurrency. p50 என்பது நடுத்தரமான கோரிக்கை. p99 என்பது 100-ல் 99 கோரிக்கைகள் முடிவடையும் கால அளவு. வரிசையில் காத்திருப்பு (queueing) ஏற்படும்போது, அது முதலில் p99-ல் தான் வெளிப்படும்.

சர்வர் குறைவாகப் பயன்படுத்தப்படும்போது முதல் இரண்டு எண்கள் சிறப்பாக இருக்கும். சர்வர் அதிகப் பயன்பாட்டில் இருக்கும்போது மூன்றாவது எண் சிறப்பாக இருக்கும். இவை ஒன்றுக்கொன்று முரணானவை என்பதால், ஒரு சர்வர் பெட்டியின் செயல்திறனை ஒரே ஒரு எண்ணால் மட்டும் விவரிக்க முடியாது.

அளவீடு செய்வதற்கு முன் input மற்றும் output lengths-ஐ நிலைப்படுத்தவும்

Throughput, traffic-ன் அமைப்பைப் பொறுத்தது. 4,000-token prompt மற்றும் 50-token answer கொண்ட workload prefill-heavy ஆகும். 200-token prompt மற்றும் 2,000-token answer கொண்ட workload decode-heavy ஆகும். ஒரே server-ல் இந்த இரண்டுக்கும் tokens per second மதிப்பு மிகவும் வேறுபடும். எனவே, ஒரு ratio-ஐத் தேர்ந்தெடுத்து, பதிவு செய்யும் ஒவ்வொரு எண்ணுக்கும் அருகில் அதை எழுதவும். வேறுபட்ட ratios-க்கு இடையில் ஒருபோதும் ஒப்பிட வேண்டாம். 1,024 input மற்றும் 1,024 output என்பது பொருத்தமான default ஆகும், ஏனெனில் பல vendors அந்த ratio-வில் வெளியிடுகின்றனர். உங்கள் உண்மையான traffic தெரிந்தால், அதையே பயன்படுத்தவும்.

Output length-ஐயும் கட்டாயமாக நிர்ணயிக்கவும். ஒரு model 60 tokens-க்கு பிறகு stop token-ஐ அடைந்தால், அது முழுமையான run-உடன் ஒப்பிட முடியாத குறுகிய run ஆகும். இதில் TTFT-ன் பங்கு அதிகமாகும். இதனால் ஒவ்வொரு request-உம் விரைவாக முடிந்தாலும், benchmark கணக்கிடும் output throughput குறையும். vLLM benchmark client-இல் உள்ள --ignore-eos flag, ஒவ்வொரு request-உம் கோரப்பட்ட எண்ணிக்கையிலான tokens-ஐத் துல்லியமாக generate செய்யச் செய்கிறது. இதனால் இரண்டு runs-உம் ஒப்பிடக்கூடியதாக இருக்கும். எந்த flag-ஐவிடவும் model தேர்வு இந்த எண்ணிக்கைகளை அதிகமாக மாற்றும்: ஒரே VPS GPU-ல் Qwen 3 model-ஐ பொருத்துதல் இந்தத் தேர்வின் memory தொடர்பான பகுதியை விளக்குகிறது.

ஒரு stream-ஐ முதலில் அளவிடுதல்

மிக எளிமையான சூழலில் இருந்து தொடங்கவும். இது ஒரு sanity check மற்றும் இதுவே அதிகபட்ச செயல்திறன் (ceiling). Ollama தனது சொந்த நேர அளவீடுகளை வெளியிடுகிறது.

ollama run llama3.1:8b --verbose "Write 200 words about disk scheduling."

நீங்கள் கவனிக்க வேண்டிய வரி eval rate, இது ஒரு வினாடிக்கு வெளியாகும் tokens-ன் எண்ணிக்கை ஆகும். prompt eval rate என்பது prefill rate, மற்றும் load duration என்பது model-ஐ VRAM-ல் ஏற்ற எடுத்துக்கொள்ளும் நேரம். cold start-க்கு பிறகு முதல் முறை அழைக்கும்போது load duration அதிகமாக இருக்கும், எனவே total duration தவறான புரிதலைத் தரலாம். கட்டளையை இரண்டு முறை இயக்கவும், இரண்டாவது முடிவைப் பார்க்கவும். Ollama இயங்காத model-ஐ முன்னிருப்பாக ஐந்து நிமிடங்களுக்குப் பிறகு நீக்கிவிடும், எனவே இரண்டு இயக்கங்களுக்கு இடையே நீண்ட இடைவெளி இருந்தால், அது மீண்டும் cold case நிலைக்குச் சென்றுவிடும்.

இதே தரவுகள் 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-ஆல் வகுத்தால் வினாடிகள் கிடைக்கும். அந்த வகுத்தல் முறையே Ollama-வின் சொந்த API ஆவணத்தில் ஒரு வினாடிக்கான tokens-ஐக் கணக்கிட பரிந்துரைக்கப்படுகிறது. server இன்னும் இயங்கவில்லை என்றால், Ollama மூலம் VPS-ல் LLM-ஐ self-host செய்தல் என்ற பகுதி நிறுவல் மற்றும் 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-வாகவோ இருக்கலாம். எனவே, இந்த மதிப்பை TTFT-ஆகக் கருதலாம் (சிறிய மாற்றங்கள் இருக்கலாம்). ஒரே server-ல் இரண்டு இயக்கங்களை ஒப்பிட்டுப் பார்க்க இது போதுமான துல்லியமானது.

Single-stream எண்கள் server-ன் திறனை மிகைப்படுத்திக் காட்டும். TTFT மிகச் சிறந்த நிலையில் இருக்கும், ஏனெனில் உங்களுக்கு முன்னால் எந்த request-ம் வரிசையில் இல்லை. ஒவ்வொரு stream-க்கான வேகமும் மிகச் சிறந்த நிலையில் இருக்கும், ஏனெனில் முழு card-ம் ஒரு request-ஐ மட்டுமே கையாள்கிறது. இவை இரண்டும் அந்த server-ன் உண்மையான கொள்ளளவை (capacity) குறிக்காது.

Concurrency sweep-ஐ எவ்வாறு இயக்குவது?

ஒரு sweep என்பது நிலையான பணிச்சுமையை (workload) அதிகரித்துக்கொண்டே செல்லும் concurrency-ல் இயக்கி, ஒவ்வொரு நிலையிலும் என்ன நடக்கிறது என்பதைப் பதிவு செய்வதாகும். vLLM இதற்கான client-ஐ வழங்குகிறது; இது OpenAI API-ஐப் பயன்படுத்துவதால், Ollama மற்றும் OpenAI-க்கு இணக்கமான பிற சேவைகளிலும் இது வேலை செய்யும்.

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 in flight) எண்ணிக்கையைக் கட்டுப்படுத்துகிறது; இதுவே நீங்கள் sweep செய்யும் மாறியாகும். --num-prompts என்பது அனுப்பப்பட்ட மொத்த கோரிக்கைகள்; நிலையான சராசரியைப் பெற, இதை concurrency-ஐ விட பத்து மடங்கு அதிகமாக வைத்திருக்கவும். சுருக்கமானது Output token throughput (tok/s): மற்றும் Total token throughput (tok/s):-ஐ அச்சிடும், பின்னர் Time to First Token தலைப்பின் கீழ் Mean TTFT (ms):, Median TTFT (ms): மற்றும் P99 TTFT (ms):-ஐக் காட்டும்.

அந்த வெளியீட்டில் per-stream rate இல்லை, ஆனால் ஒரு வகுத்தல் மூலம் அதைக் கண்டறியலாம். Mean TPOT (ms): என்பது முதல் token-க்கு பிறகு ஒரு output token-க்கு ஆகும் சராசரி நேரம்; எனவே 25 ms per token என்பது ஒரு stream-க்கு வினாடிக்கு 40 tokens ஆகும். Output throughput-ஐ concurrency-ஆல் வகுப்பதும் அதே விடையைத் தரும்.

பின்னர், ஒவ்வொரு run-ஐயும் சேமித்து, அதை loop செய்யவும்.

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"
done
சேமிக்கப்பட்ட JSON கோப்புகளை வாசித்தல்

ஒவ்வொரு run-உம் ஒரு கோப்பை எழுதுகிறது, எனவே உங்களுக்குத் தேவையான புலங்களை (fields) அனைத்திலிருந்தும் ஒரே நேரத்தில் எடுக்கவும்.

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"
done

output_throughput என்பது வினாடிக்கு வெளியாகும் tokens ஆகும். total_token_throughput என்பது input tokens-ஐயும் சேர்த்து கணக்கிடுகிறது; எனவே 1:1 விகிதத்தில் இது கிட்டத்தட்ட இருமடங்காக இருக்கும். p99_ttft_ms என்பது --metric-percentiles இல்லாமலும் அங்கு இருக்கும், ஏனெனில் அந்த flag-ன் default மதிப்பு 99 ஆகும். கட்டளையில் உள்ள 50 என்பது --percentile-metrics-ல் பெயரிடப்பட்ட ஒவ்வொரு metric-க்கும் அருகில் median_ttft_ms-ஐத் தொடர்ந்து p50_ttft_ms-ஐச் சேர்க்கிறது. நீங்கள் கோராத ஒரு percentile-ஐக் கேட்டால், உதாரணமாக .p90_ttft_ms, jq null-ஐ அச்சிடும்.

concurrency sweep உண்மையில் எதை காட்டுகிறது?

விளக்கப்படம்Illustrative sweep shape: 8B model, one 24 GB GPU, 1024 in / 1024 out
இந்த விளக்கப்படத்தின் தரவு
[
  {
    "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 rows, சிறிய வாடகை GPU box-ல் sweep உருவாக்கும் வடிவத்தை, நியாயமான அளவுகோலில் விளக்குகின்றன. அவை உங்கள் server-ன் measurement அல்ல; vendor figure-உம் அல்ல. மேலுள்ள loop-ஐ இயக்கி, அவற்றுக்குப் பதிலாக உங்கள் values-ஐ இடவும்.

இந்த வடிவத்தைப் புரிந்துகொள்ளுங்கள்; பொதுவாகப் பயன்படுத்தக்கூடியது இந்த வடிவமே. ஒரு stream-ல் முழு box, ஒரு second-க்கு 92 tokens-ஐ உருவாக்குகிறது; p99 TTFT 61 ms ஆகும். 128 streams streams-ல் மொத்த throughput, ஒரு second-க்கு 2304 tokens ஆகிறது; இது இருபத்தைந்து மடங்கு அதிகம். ஆனால் ஒவ்வொரு stream-ன் வேகம் ஒரு second-க்கு 18 tokens ஆகக் குறைகிறது; p99 TTFT 3820 ms ஆகிறது. Batching, idle memory waits-ஐ பயனுள்ள வேலைகளாக மாற்றுவதால் total throughput அதிகரிக்கிறது. அதே compute இப்போது பகிரப்படுவதால், ஒவ்வொரு stream-ன் வேகம் குறைகிறது.

கடைசி doubling முக்கியமான அறிகுறியை வழங்குகிறது. 64 streams-இலிருந்து 128 streams-க்கு அதிகரிக்கும்போது total throughput ஆறு சதவீதத்திற்கும் குறைவாகவே அதிகரிக்கிறது; ஆனால் p99 TTFT ஏறத்தாழ மூன்று மடங்காகிறது. இதன் பொருள் requests இயக்கப்படுவதற்குப் பதிலாக queue-ல் காத்திருக்கின்றன. இதற்குக் காரணம் KV cache நிரம்பியிருப்பதாகவோ, அல்லது server vLLM-ன் max_num_seqs போன்ற scheduling cap-ஐ அடைந்திருப்பதாகவோ இருக்கலாம். பயனுள்ள operating point அதற்கு முன்பே உள்ளது: 32 streams-ல், box இன்னும் ஒரு second-க்கு 1728 tokens-ஐ வழங்குகிறது. இது peak-ன் 75 சதவீதம். ஒவ்வொரு stream-க்கும் ஒரு second-க்கு 54 tokens கிடைக்கின்றன; p99 TTFT 498 ms ஆகும். அந்த point-ஐ உங்கள் capacity ஆக report செய்யுங்கள். Curve-ன் peak value-ஐ வைத்து users-க்கு சேவை வழங்க முடியாது.

Ollama மற்றும் vLLM ஒரே விஷயத்தை அளவிடுவதில்லை

இந்த sweep-ஐ default Ollama server-க்கு இயக்கினால், total மதிப்பு கிட்டத்தட்ட மாறாது. OLLAMA_NUM_PARALLEL-ன் default மதிப்பு 1. எனவே ஒரு request இயங்கும்; மீதமுள்ளவை காத்திருக்கும். இந்த queue காரணமாக p99 TTFT அதிகரிக்கும்; ஆனால் total output மாறாமல் இருக்கும். எதையும் அளவிடுவதற்கு முன் இதன் மதிப்பை உயர்த்தவும்.

sudo systemctl edit ollama.service
[Service]
Environment="OLLAMA_NUM_PARALLEL=8"

sudo systemctl restart ollama உடன் restart செய்து, model இன்னும் memory-க்குள் பொருந்துகிறதா என்பதை உறுதிப்படுத்தவும். ஒவ்வொரு 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 காலியாகும்போது, இயங்கிக்கொண்டிருக்கும் batch-ல் புதிய requests-ஐ சேர்க்கிறது. ஏதேனும் resource தீரும் வரை அதன் curve தொடர்ந்து உயரும். பொதுவாக KV cache முதலில் தீரும். ஆனால் max_num_seqs போன்ற configured cap அல்லது CPU scheduling overhead காரணமாக அதற்கு முன்பே curve சமமாகலாம். Ollama ஒரு model, ஒரு machine, குறைந்த setup cost ஆகியவற்றுக்காக optimises செய்கிறது. ஆகவே ஒரே sweep-க்கு இரண்டு engines-ம் வேறுபட்ட முடிவுகளைத் தரும். இதுவே Ollama மற்றும் vLLM-ஐ serving engines ஆக ஒப்பிடுதல் என்பதன் உண்மையான பொருள். ஒவ்வொரு எண்ணையும் உருவாக்கிய engine மற்றும் version-ஐப் பதிவு செய்யவும்.

தவறான அளவீட்டைச் செய்யும் 5 வழிகள்

  • Client வெகு தொலைவில் உள்ளது. Internet வழியாக உங்கள் laptop-லிருந்து benchmark செய்யும்போது, ஒவ்வொரு TTFT-க்கும் உங்கள் round trip நேரம் சேரும். ஆகவே, நீங்கள் server-ஐ அல்ல, உங்கள் home connection-ஐ அளவிடுகிறீர்கள். Client-ஐ server இருக்கும் அதே region-ல் இயக்கவும்.
  • Model cold நிலையில் இருந்தது. முதல் request-ல் weights load செய்யும் நேரம் சேரும். vLLM-ல் graph capture-க்கான நேரமும் சேரலாம். ஒரு warmup batch-ஐ அனுப்பி, அதன் result-ஐ புறக்கணிக்கவும்.
  • Prefix caching உங்கள் சார்பாக பதிலளித்தது. vLLM இயல்பாகவே automatic prefix caching-ஐ 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 ஆகும். Requests overlap ஆனால், உங்கள் traffic உருவாக்கும் concurrency நிலையில் நீங்கள் தொடர்ந்து பெறும் throughput-ஐப் பொறுத்தே cost அமையும். எனவே, அந்த நிலையிலும் அளவிடவும்.

அளவிடப்பட்ட எண்ணை முடிவாக மாற்றுவது எப்படி

உங்கள் sweep காட்டும் output throughput-ஐ, உங்கள் உண்மையான traffic அடையும் concurrency-ல் எடுத்துக்கொண்டு, அதை per-token விலையுடன் ஒப்பிடவும். போதுமான கோரிக்கைகள் ஒன்றுடன் ஒன்று இணைந்து batch-ஐ முழுமையாக வைத்திருந்தால் மட்டுமே இது saturated figure ஆகும்; ஒரு நேரத்தில் ஒரு கோரிக்கையை அனுப்பும் பணிச்சுமை அதன் single-stream rate-ஐ மட்டுமே பயன்படுத்த முடியும். ஒவ்வொரு output token-உடனும் வரும் input tokens-க்கு விலை நிர்ணயம் செய்தவுடன், break-even-ஐ ஒரு வகுத்தல் மூலம் கண்டறியலாம்:

cost_per_million_output = price_out + price_in * (input_tokens / output_tokens)
break_even_tok_s = (price_per_hour / cost_per_million_output) * 1000000 / 3600

DigitalOcean-ன் ஜூலை 2026 விலைகளை வைத்து இதைக் கணக்கிடுவோம். அவர்களின் H200 dedicated inference endpoint ஒரு மணி நேரத்திற்கு $4.47, மற்றும் serverless Llama 3.3 70B-ன் விலை ஒரு மில்லியன் input tokens-க்கு $0.65 மற்றும் ஒரு மில்லியன் output tokens-க்கு $0.65 ஆகும். மேலே குறிப்பிட்ட 1:1 விகிதத்தில், ஒவ்வொரு மில்லியன் output tokens-உடனும் ஒரு மில்லியன் input tokens வருவதால், பயனுள்ள விலை (effective price) ஒரு மில்லியன் output tokens-க்கு $1.30 ஆகும். எனவே 4.47-ஐ 1.30-ஆல் வகுத்தால் ஒரு மணி நேரத்திற்கு சுமார் 3.44 மில்லியன் output tokens கிடைக்கும்; அதை 3,600 வினாடிகளால் வகுத்தால் வினாடிக்கு சுமார் 955 output tokens கிடைக்கும், அல்லது input மற்றும் output இரண்டையும் சேர்த்தால் வினாடிக்கு சுமார் 1,910 tokens கிடைக்கும். விலைகள் அவர்களுடையது. வகுத்தல் நம்முடையது. அக்டோபர் 25, 2026 அன்று நாங்கள் சரிபார்த்தபோது, H200 endpoint விலை இன்னும் ஒரு மணி நேரத்திற்கு $4.47 ஆக இருந்தது, ஆனால் DigitalOcean ஆகஸ்ட் 18, 2026 அன்று serverless Llama 3.3 70B-ஐ நிறுத்திவிட்டு, பயனர்களை Llama 4 Maverick-க்கு மாற்றியது; அதன் விலை ஒரு மில்லியன் input tokens-க்கு $0.25 மற்றும் ஒரு மில்லியன் output tokens-க்கு $0.87 ஆகும். அது வேறொரு model என்பதால், ஒப்பீடு அர்த்தமுள்ளதாக இருக்க அதற்குத் தனி sweep தேவை.

இதை முடிவு செய்யும் சொல் sustained (தொடர்ச்சியானது) என்பதாகும். ஒரு நாளைக்கு இரண்டு மணி நேரம் மட்டும் saturation-ல் வினாடிக்கு 955 output tokens-ஐ அடைவது என்பது வினாடிக்கு 955 output tokens sustained கிடையாது, ஏனெனில் நீங்கள் மற்ற இருபத்தி இரண்டு மணி நேரத்திற்கும் பணம் செலுத்துகிறீர்கள். GPU Droplet-ஆக கார்டை வாடகைக்கு எடுப்பது இந்த நிலையை மாற்றாது: அக்டோபர் 25, 2026 அன்று DigitalOcean-ன் Droplet விலைப்பட்டியலில் H200 ஒரு மணி நேரத்திற்கு $4.47 என இருந்தது, இது endpoint விலைக்குச் சமம். அதன் மலிவான NVIDIA Droplets-ஆன RTX 4000 ($0.76/மணி) மற்றும் L40S அல்லது RTX 6000 ($1.57/மணி) ஆகியவை 70B model-ஐ FP8-ல் வைத்திருக்கப் போதாது. எனவே மேலே உள்ள புள்ளிவிவரங்களின்படி, 2,036 output tokens per second-ல் saturate ஆகும் ஒரு H200, நீங்கள் பணம் செலுத்தும் ஒவ்வொரு மணி நேரத்திலும் அந்த உச்சத்தில் சுமார் 47 சதவீதத்தை சராசரியாகக் கொண்டிருந்தால் மட்டுமே அது ஒரு மில்லியன் tokens-க்கு $0.65 என்ற விலைக்குச் சமமாகும்; அதற்கு கீழே இருந்தால் per-token விலையே சிறந்தது. பொதுவாக self-hosting-ஐத் தோல்வியடையச் செய்வது மெதுவான tokens அல்ல, பயன்படுத்தப்படாத GPU மணிநேரங்களே ஆகும்.

எனவே உங்கள் முடிவுக்கு இரண்டு உள்ளீடுகள் உள்ளன. Sweep உங்களுக்கு உச்சவரம்பைத் (ceiling) தருகிறது. உங்கள் traffic pattern அந்த உச்சவரம்பில் நீங்கள் உண்மையில் பயன்படுத்தும் பகுதியைத் தருகிறது. அவற்றை ஒன்றாகப் பெருக்கி, அதன் முடிவை GPU VPS மற்றும் per-token API break-even ஒப்பீடு பகுதிக்கு எடுத்துச் சென்று உங்கள் பயன்பாட்டிற்கான விடையைப் பார்க்கவும்.

FAQ

self-hosted LLM-க்கு ஒரு நல்ல tokens per second அளவு என்ன?

இதற்கு இரண்டு பதில்கள் உள்ளன; ஏனெனில் இந்த metric இரண்டு விதமான பணிகளைச் செய்கிறது. ஒருவர் output-ஐ வாசிக்கும் நிலையில், ஒரு stream-க்கு சுமார் 20 output tokens per second-ஐ விட அதிகமான வேகம் ஏற்கனவே வாசிக்கும் வேகத்தை விட அதிகமாகும். எனவே அதற்கு மேல் வேகம் அதிகரித்தாலும் பயன் இல்லை. செலவைப் பொறுத்தவரை, உங்கள் உண்மையான load-இல் தொடர்ந்து வழங்கக்கூடிய மொத்த output throughput-தான் முக்கியம். உங்கள் break-even அளவை மீறினால் அது போதுமானது. ஒரு மணி நேரத்திற்கு $4.47 செலவாகும் box-ல், input மற்றும் output இரண்டுக்கும் million tokens-க்கு $0.65 என்ற விலையை ஒப்பிடும்போது, July 2026 விலைகளில் 1:1 ratio-க்கு sustained வேகம் சுமார் 955 output tokens per second ஆக இருக்க வேண்டும். ஒரு பெரிய model-ல் ஒரு stream மட்டும் இந்த அளவை எட்டாது. அதனால்தான் batching பயன்படுத்தப்படுகிறது.

concurrent requests சேர்க்கும்போது எனது Ollama throughput ஏன் மாறாமல் இருக்கிறது?

OLLAMA_NUM_PARALLEL-ன் default மதிப்பு 1. எனவே server ஒவ்வொரு model-க்கும் ஒரே நேரத்தில் ஒரு request-ஐ மட்டுமே இயக்கி, மீதமுள்ளவற்றை queue-ல் வைக்கிறது. OLLAMA_MAX_QUEUE வரம்பை (default-ஆக 512) கடந்ததும் 503-ஐத் திருப்பி அனுப்புகிறது. p99 TTFT அதிகரித்தாலும் மொத்த output மாறாமல் இருந்தால், GPU busy ஆக இருப்பதற்குப் பதிலாக queue உருவாகியுள்ளது என்பதே அதன் அறிகுறி. systemd drop-in-ல் இந்த variable-ஐ அமைத்து server-ஐ restart செய்யவும். பின்னர் ollama ps-ஐ சரிபார்க்கவும். ஒவ்வொரு parallel slot-உம் ஒதுக்கப்படும் context-ஐ பெருக்குவதால், model-ன் ஒரு பகுதி CPU-க்கு மாற்றப்படலாம்.

time to first token-ஐ அளவிட வேண்டுமா, அல்லது tokens per second-ஐ அளவிட வேண்டுமா?

இரண்டையும் அளவிட வேண்டும்; load அதிகரிக்கும்போது அவை எதிர்திசைகளில் மாறுகின்றன. TTFT-ஐ user நேரடியாக உணர்கிறார். Saturated output throughput உங்கள் invoice-ல் பிரதிபலிக்கும் அளவு. ஒவ்வொரு concurrency step-லும் p50 மற்றும் p99 TTFT-ஐ பதிவு செய்யவும். பின்னர் p99 TTFT உங்களுக்கு ஏற்றதாகத் தொடரும் அதிகபட்ச concurrency-ஐ தேர்ந்தெடுக்கவும். அந்த நிலையில் கிடைக்கும் throughput-ஐ உங்கள் capacity-ஆக அறிக்கையிடவும். Curve-ன் உச்சியில் கிடைக்கும் maximum-ஐப் பயன்படுத்த வேண்டாம்.

அதிக tokens per second என்றால் எப்போதும் குறைந்த cost per token என்று பொருளா?

இல்லை. Cost per token என்பது ஒரு மணி நேர விலையை, அந்த ஒரு மணி நேரத்தில் box உண்மையில் உருவாக்கிய tokens எண்ணிக்கையால் வகுத்த மதிப்பு. எனவே அதிக வேகமுள்ள server நாள் முழுவதும் பெரும்பாலும் idle நிலையில் இருந்தால், அதன் cost per token அதிகமாகவே இருக்கும். Peak speed அல்ல, utilisation-தான் இதைத் தீர்மானிக்கிறது. Units-ஐயும் கவனிக்கவும். Quoted total token throughput input tokens-ஐ உள்ளடக்கும். எனவே 1:1 input to output ratio-வில் அது output rate-ஐ விட சுமார் இருமடங்காக இருக்கும். நீங்கள் ஒப்பிடும் API input tokens-க்கும் output tokens-க்கும் கட்டணம் வசூலித்தால், ஒப்பிடுவதற்கு முன் இரு பகுதிகளுக்கும் விலையை கணக்கிடவும்.

இந்தக் கட்டுரை பயனுள்ளதாக இருந்ததா?

#benchmarking#tokens-per-second#vllm#ollama#gpu-vps