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

LLM-ல் Prefill மற்றும் Decode ஏன் மெதுவாகிறது?

Prefill என்பது compute bound, இது time to first token-ஐ தீர்மானிக்கிறது. Decode என்பது memory bandwidth bound, இது tokens per second-ஐ தீர்மானிக்கிறது. இவற்றைத் தனித்தனியாக அளவிடுங்கள்.

Prefill மற்றும் decode ஒப்பீடு

Self-hosted LLM-ல் ஏற்படும் பெரும்பாலான latency சிக்கல்களைப் புரிந்துகொள்ள Prefill மற்றும் decode ஆகியவற்றுக்கு இடையேயான வேறுபாடு மிக முக்கியமானது. Prefill என்பது கொடுக்கப்பட்ட prompt முழுவதையும் ஒரே நேரத்தில் வாசிக்கும் செயல்முறை; இது compute திறனைச் சார்ந்தது. Decode என்பது பதிலை ஒவ்வொரு token-ஆக உருவாக்கும் செயல்முறை; இது memory bandwidth-ஐச் சார்ந்தது. Time to first token என்பது Prefill-ஐக் குறிக்கும் அளவீடு, Tokens per second என்பது decode-ஐக் குறிக்கும் அளவீடு. இவை இரண்டும் ஒரே GPU-வில், ஒரே weights-ஐப் பயன்படுத்தி, ஒரே process-க்குள் இயங்குவதால், இவற்றை ஒரே workload-ஆகக் கருதுவது இயல்பானது. ஆனால், இவை ஒரே சாதனத்தைப் பகிர்ந்து கொள்ளும் இரண்டு வெவ்வேறு நிரல்களைப் போலச் செயல்படுகின்றன. இவற்றைத் தனித்தனியாகப் பிரித்துப் பார்த்தால், குழப்பமான முடிவுகள் அனைத்தும் தெளிவாகிவிடும்.

Prefill ஏன் compute bound ஆக உள்ளது?

Prefill, முழு prompt-ஐயும் ஒவ்வொரு layer வழியாகவும் ஒருமுறை செலுத்துகிறது. 2,000 token கொண்ட ஒரு prompt, ஒவ்வொரு matrix multiply-க்கும் 2,000 rows வேலைகளை வழங்குகிறது. எனவே, GPU தான் ஏற்றும் ஒவ்வொரு byte weight-க்கும் அதிகப்படியான கணிதச் செயல்பாடுகளைச் செய்கிறது. நகர்த்தப்படும் ஒவ்வொரு byte-க்கும் செய்யப்படும் கணிதச் செயல்பாடுகளின் இந்த விகிதம், arithmetic intensity என்று அழைக்கப்படுகிறது; prefill-க்கு இந்த விகிதம் அதிகம். சாதனம் அதன் compute limit-க்கு அருகில் இயங்குகிறது, மேலும் memory bus-ல் போதிய காலியிடம் உள்ளது.

Prefill இரண்டு விஷயங்களை உருவாக்குகிறது: ஒவ்வொரு prompt token-க்கும் தேவையான KV cache (key மற்றும் value tensors) மற்றும் முதல் output token. அந்த pass முடியும் வரை எந்தத் தகவலும் பயனரைச் சென்றடையாது. இதனால்தான், idle நிலையில் உள்ள server-ல், TTFT (time to first token)-ன் பெரும்பகுதி prefill-க்குச் செலவாகிறது. NVIDIA-வின் benchmarking வழிகாட்டி வரையறுப்பது போல, TTFT-ல் request queuing மற்றும் network latency ஆகியவையும் அடங்கும். எனவே, busy server-ல் prompt-ஐ விட queue-வில் காத்திருக்கும் நேரம் முக்கியமானது.

Prefill-ன் செலவு prompt-ன் நீளத்தைப் பொறுத்து அதிகரிக்கிறது. இதில் linear பகுதி என்பது ஒவ்வொரு layer-லும் நடக்கும் matrix வேலை. Quadratic பகுதி என்பது attention ஆகும்; இதில் ஒவ்வொரு token-ம் அதற்கு முந்தைய அனைத்து token-களையும் கவனிக்கிறது (attend). நீண்ட context-ல் இது முக்கியத்துவம் பெறுகிறது. எனவே, prompt-ன் அளவை இரட்டிப்பாக்குவது, TTFT-ன் prefill பகுதியை குறைந்தபட்சம் இரண்டு மடங்காக்குகிறது.

இதை நீங்கள் ஒரு நிமிடத்தில் கவனிக்கலாம். உங்கள் server-க்கு 200 token கொண்ட ஒரு prompt-ஐயும், பின்னர் 2,000 token கொண்ட ஒரு prompt-ஐயும் அனுப்பிப் பாருங்கள். இரண்டிற்கும் ஒரே எண்ணிக்கையிலான output token-களைக் கேளுங்கள். TTFT மிக வேகமாக உயரும். ஆனால், முதல் token-க்கு பிந்தைய streaming வேகம் பெரிய அளவில் மாறாது.

Decode ஏன் memory bandwidth-ஐச் சார்ந்துள்ளது?

Decode செயல்பாட்டில் ஒவ்வொரு படியிலும் ஒரு token உருவாக்கப்படுகிறது. அந்த ஒரு token-ஐ உருவாக்க, GPU மாடலில் உள்ள ஒவ்வொரு weight-ஐயும் memory-யிலிருந்து படிக்க வேண்டும், ஒவ்வொரு weight-ஐயும் சில கணக்கீடுகளுக்குப் பயன்படுத்த வேண்டும், பிறகு அதை நீக்க வேண்டும். இதன் arithmetic intensity 1-க்கு அருகில் இருப்பதால், compute units பெரும்பாலும் காத்திருப்பதிலேயே நேரத்தைச் செலவிடுகின்றன.

ஒவ்வொரு token-க்கும் முழு மாடலையும் memory-யிலிருந்து படிக்க வேண்டியிருப்பதால் decode மெதுவாக உள்ளது; எனவே memory bus வேகத்தைத் தீர்மானிக்கிறது மற்றும் compute units சும்மா இருக்கின்றன.

இதன் மூலம், single stream decode வேகத்திற்கான உச்ச வரம்பை காகிதத்தில் கணக்கிடலாம். Memory bandwidth-ஐ, weights ஆக்கிரமித்துள்ள bytes-ஆல் வகுக்கவும்.

விளக்கப்படம்Published memory bandwidth and the decode ceiling it implies for a 16 GB model
இந்த விளக்கப்படத்தின் தரவு
[
  {
    "device": "CPU, dual channel DDR5-5600",
    "mem_bandwidth_gb_s": 90,
    "decode_ceiling_tok_s": 6
  },
  {
    "device": "NVIDIA A10G",
    "mem_bandwidth_gb_s": 600,
    "decode_ceiling_tok_s": 38
  },
  {
    "device": "NVIDIA L40S",
    "mem_bandwidth_gb_s": 864,
    "decode_ceiling_tok_s": 54
  },
  {
    "device": "NVIDIA RTX 4090",
    "mem_bandwidth_gb_s": 1008,
    "decode_ceiling_tok_s": 63
  },
  {
    "device": "NVIDIA A100 80GB SXM",
    "mem_bandwidth_gb_s": 2039,
    "decode_ceiling_tok_s": 127
  },
  {
    "device": "NVIDIA H100 SXM",
    "mem_bandwidth_gb_s": 3350,
    "decode_ceiling_tok_s": 209
  }
]

Bandwidth நெடுவரிசையில் ஒவ்வொரு விற்பனையாளரும் வெளியிட்ட விவரக்குறிப்பு உள்ளது. Ceiling நெடுவரிசையில் அந்த மதிப்பை 16 GB-ஆல் வகுக்க வேண்டும்; இது 16 bit precision-ல் சேமிக்கப்பட்ட 8 billion parameter மாடலின் அளவு. இது ஒரு கணக்கீடு மட்டுமே, benchmark முடிவு அல்ல. நீங்கள் அளவிடும் வேகம் இதைவிடக் குறைவாகவே இருக்கும். அது எவ்வளவு குறைவாக உள்ளது என்பதை அறிவது பயனுள்ளது, ஏனெனில் உங்கள் serving stack-ஐச் சரிசெய்ய வேண்டுமா அல்லது hardware-ஐ மாற்ற வேண்டுமா என்பதை அது உணர்த்தும்.

6 வரிசைகளை வரிசையாகப் பார்த்தால் இந்த முறை தெளிவாகும். Dual channel DDR5-ல் உள்ள CPU சுமார் 90 GB/s வேகத்தில் இயங்குகிறது, இது அந்த மாடலுக்கு 6 tokens per second என்ற அளவில் decode வேகத்தைக் கட்டுப்படுத்துகிறது. ஒரு L40S 54 என்ற அளவில் உள்ளது. 3350 GB/s bandwidth கொண்ட H100 SXM, 209 என்ற அளவில் உள்ளது.

இதனால்தான் decode வேகத்தை அதிகரிப்பதில் quantization மிக முக்கியமான காரணியாக உள்ளது. அதே weights-ஐ 16 bit-க்கு பதிலாக 8 bit-ல் சேமித்தால், ஒரு token-க்கு வாசிக்கப்படும் weight bytes பாதியாகக் குறையும், எனவே உச்ச வரம்பு தோராயமாக இரட்டிப்பாகும். இருப்பினும், இந்த உச்ச வரம்பு இறுதி முடிவு அல்ல. KV cache அதன் சொந்த அளவில் தொடர்ந்து படிக்கப்படுகிறது, மேலும் சில 8 bit வடிவங்கள் ஒவ்வொரு token-க்கும் கூடுதல் வேலைகளைச் சேர்க்கின்றன (உதாரணமாக, vLLM அதன் ஒரு FP8 scheme-க்காக ஆவணப்படுத்தும் dynamic per token activation quantization). எனவே, நடைமுறையில் கிடைக்கும் வேகம் பொதுவாக 2x-க்கும் குறைவாகவே இருக்கும். உச்ச வரம்பு உயரும் அதே காரணத்திற்காகவே இந்த முறை வேலை செய்கிறது: நீங்கள் குறைவான memory-யையே கையாளுகிறீர்கள்.

எனது சொந்த server-ல் ஒவ்வொரு கட்டத்தையும் எவ்வாறு அளவிடுவது?

Ollama, response body-ல் இந்த பிரிவினையைத் தருகிறது. Streaming இல்லாத completion-ஐக் கேட்டு, counters-ஐப் படிக்கவும்.

curl -s http://localhost:11434/api/generate -d '{
  "model": "llama3.2",
  "prompt": "Explain memory bandwidth in two sentences.",
  "stream": false
}' | jq '{prompt_eval_count, prompt_eval_duration, eval_count, eval_duration}'

நீங்கள் ஏற்கனவே pull செய்த model tag-ஐப் பயன்படுத்தவும், அதை ollama list உங்களுக்குக் காட்டும். prompt_eval_count மற்றும் prompt_eval_duration ஆகியவை prefill: prompt token எண்ணிக்கை மற்றும் அதற்காகச் செலவிடப்பட்ட நேரம். eval_count மற்றும் eval_duration ஆகியவை decode ஆகும். கால அளவுகள் nanoseconds-ல் இருப்பதால், decode வேகம் eval_count / eval_duration * 1e9 மற்றும் prefill வேகம் prompt_eval_count / prompt_eval_duration * 1e9 ஆகும். Ollama-வின் API reference-ன்படி prompt_eval_duration என்பது cache செய்யப்படாத prompt token-களை மட்டுமே குறிக்கும், எனவே server இதுவரை பார்த்திராத ஒரு prompt-ஐக் கொண்டு prefill விகிதத்தைக் கணக்கிடவும். ஒரே request-ல் decode விகிதத்தை விட prefill விகிதம் மிக அதிகமாக இருக்கும் என்று எதிர்பார்க்கலாம். அந்த இடைவெளிதான் இங்கு விளக்கப்பட்டுள்ள அனைத்திற்கும் காரணமாகும்.

vLLM போன்ற OpenAI இணக்கமான server-க்கு, curl மூலம் முதல் byte-க்கான நேரத்தை உங்களால் அளவிட முடியும்.

curl -N -s -o /dev/null \
  -w 'pretransfer %{time_pretransfer}s  first_byte %{time_starttransfer}s\n' \
  http://localhost:8000/v1/completions \
  -H 'Content-Type: application/json' \
  -d '{"model": "meta-llama/Llama-3.1-8B-Instruct", "prompt": "Explain memory bandwidth.", "max_tokens": 128, "stream": true}'

time_starttransfer என்பது body-ன் முதல் byte வந்து சேர்ந்த தருணம், எனவே "stream": true உடன் சேர்த்தால் அது TTFT மற்றும் connection setup நேரத்தைக் குறிக்கும். Setup செலவைக் கழிக்க time_pretransfer-ஐப் பயன்படுத்தவும். இதை இரண்டு முறை இயக்கவும், இரண்டாவது முடிவை மட்டும் வைத்துக்கொள்ளவும், ஏனெனில் முதல் அழைப்பில் cold model load இருக்கலாம்.

vLLM, இந்த பிரிவினையை Prometheus metrics ஆக /metrics-ல் வெளியிடுகிறது. curl -s http://localhost:8000/metrics | grep -E 'time_to_first_token|inter_token_latency'-ஐ இயக்கினால் உங்களுக்கு vllm:time_to_first_token_seconds மற்றும் vllm:inter_token_latency_seconds ஆகிய histograms கிடைக்கும். Queue depth-க்கு vllm:num_requests_running மற்றும் vllm:num_requests_waiting-ஐயும், cache pressure-க்கு vllm:kv_cache_usage_perc-ஐயும் சேர்க்கவும். இந்த ஐந்து பெயர்களுமே முழு dashboard-க்குத் தேவையானவை.

சுமை அதிகமாக இருக்கும்போது, vllm bench serve --model <name> --num-prompts 200 --request-rate 4 இயங்கும் server-ஐக் கட்டுப்படுத்தி, முதல் token-க்கான நேரம் மற்றும் ஒவ்வொரு output token-க்கான latency ஆகியவற்றை percentiles உடன் வழங்கும். நீங்கள் ஏற்கனவே இயக்கும் stack-ல் இந்த இரண்டு கட்டங்களும் எவ்வாறு ஒன்றையொன்று பாதிக்கின்றன என்பதைப் பார்க்க இதுவே நேரடியான வழியாகும். உங்களுக்குத் தனிப்பட்ட கருவி தேவைப்பட்டால், NVIDIA-வின் GenAI-Perf மற்றும் LLMPerf ஆகியவையும் இதே அளவீடுகளை வழங்குகின்றன. எதையும் மாற்றியமைக்கும் முன், ஒரு தெளிவான baseline-ஐ எடுத்துக்கொள்ளவும்: local LLM-ல் tokens per second-ஐ அளவிடுதல் என்பதில் உள்ள முறை, reboot செய்த பிறகும் அழியாத ஒரு baseline-ஐ உங்களுக்கு வழங்கும்.

நீளமான system prompt ஏன் முதல் token-ஐ தாமதப்படுத்துகிறது, ஆனால் streaming வேகத்தை பாதிப்பதில்லை?

ஏனெனில் system prompt என்பது prefill வேலை மட்டுமே, வேறொன்றும் இல்லை. முதல் token தோன்றுவதற்கு முன்பு, prompt-ன் மற்ற பகுதியுடன் சேர்த்து இது ஒரே முறையில் செயலாக்கப்படுகிறது. அந்தச் செயலாக்கத்திற்குப் பிறகு, அது KV cache பதிவுகளாக மட்டுமே இருக்கும்; decode செய்யும் போது மற்றவற்றுடன் சேர்த்து இதையும் கணினி வாசிக்கும். எனவே, prefix caching இல்லையென்றால், 3,000 token கொண்ட system prompt ஒவ்வொரு கோரிக்கையிலும் TTFT-ஐ அதிகரிக்கும், ஆனால் ஒரு வினாடிக்கான token-களின் எண்ணிக்கையில் பெரிய மாற்றத்தை ஏற்படுத்தாது.

கிட்டத்தட்ட மாறாது, ஆனால் துல்லியமாகச் சொல்ல முடியாது. அந்த கூடுதல் KV பதிவுகள் ஒவ்வொரு decode நிலையிலும் மீண்டும் வாசிக்கப்படுகின்றன, எனவே மிக நீளமான prompt decode வேகத்தை சற்று குறைக்கும். அடுத்த பகுதி இதைப் பற்றி விளக்குகிறது.

ஒரே prefix-ஐ மீண்டும் மீண்டும் கணக்கிடுவதைத் தவிர்ப்பதே இதற்கான தீர்வு. Prefix caching வசதி கொண்ட server, பகிரப்பட்ட prefix-ன் KV cache-ஐ வைத்துக்கொண்டு அதை மீண்டும் பயன்படுத்தும். இதனால், அதே system prompt-ஐக் கொண்ட இரண்டாவது கோரிக்கை prefill-ன் அந்தப் பகுதியை முழுமையாகத் தவிர்க்கும். vLLM இதை automatic prefix caching என்று அழைக்கிறது; உங்கள் பதிப்பில் vllm serve --help-ஐச் சரிபார்க்கவும், ஏனெனில் பல்வேறு releases-களில் இதன் default அமைப்பு மாறியுள்ளது. GPU-க்குள் இருக்கும் அந்த KV cache-க்கும், API வழங்குநர் உங்களிடம் கட்டணம் வசூலிக்கும் prompt cache-க்கும் வித்தியாசம் உள்ளது. எனவே, எதைச் சரிசெய்வதற்கு முன்பும் KV cache மற்றும் prompt cache-க்கு இடையிலான வேறுபாடு குறித்த கட்டுரையை வாசிப்பது அவசியம்.

Context நிரம்பும்போது decode ஏன் வேகம் குறைகிறது?

இதற்கு KV cache தொடர்பான இரண்டு காரணங்கள் உள்ளன.

முதலாவது bandwidth. ஒவ்வொரு decode நிலையிலும், attention முந்தைய அனைத்து tokens-ன் keys மற்றும் values-ஐயும் வாசிக்கிறது. Weights என்பது ஒரு token-க்கு நிலையான செலவு. ஆனால் KV cache வளர்ந்து கொண்டே இருக்கும். மாதிரியின் config.json-ஐக் கொண்டு அதன் அளவைக் கணக்கிடலாம்: ஒரு token-க்கான bytes என்பது 2, பெருக்கல் num_hidden_layers, பெருக்கல் num_key_value_heads, பெருக்கல் head dimension, பெருக்கல் bytes per element ஆகும். Config-ல் head_dim குறிப்பிடப்பட்டிருந்தால் அதைப் பயன்படுத்தவும்; இல்லையெனில் hidden_size-ஐ num_attention_heads-ஆல் வகுத்துப் பயன்படுத்தவும், ஏனெனில் சில மாதிரிகள் இவை இரண்டையும் தனித்தனியாகக் கொண்டுள்ளன. உதாரணமாக, Mistral NeMo-வின் அகலம் 5,120 மற்றும் 32 heads கொண்டது, ஆனால் அதன் head dimension 160 அல்ல, 128 ஆகும். முன்னால் உள்ள 2 என்பது ஒரு key மற்றும் ஒரு value-ஐக் குறிக்கிறது.

பொதுவான 8 billion parameter அமைப்பு, 32 layers, GQA (grouped query attention)-ன் கீழ் 8 key மற்றும் value heads, 128 head dimension, 16 bit precision ஆகியவற்றைக் கொண்ட ஒரு மாதிரியில், இது 2 x 32 x 8 x 128 x 2 = 131,072 bytes, அதாவது ஒரு token-க்கு சுமார் 128 KiB ஆகும். எனவே, 8,000 tokens கொண்ட உரையாடல், ஒரு கோரிக்கைக்கு (request) சுமார் 1 GB KV cache-ஐ எடுத்துக்கொள்ளும்.

இரண்டாவது திறன் (capacity). அந்த 1 GB நினைவகம் (memory), weights-ஐயோ அல்லது மற்றொரு பயனரின் context-ஐயோ வைத்திருக்க முடியாது. Server தனது KV pool-ஐ தொடக்கத்திலேயே ஒருமுறை அளவிடுகிறது; vLLM-ல் இது --gpu-memory-utilization மூலம் நடக்கும். pool நிரம்பியதும் புதிய கோரிக்கைகள் காத்திருக்க வேண்டியிருக்கும். vllm:num_requests_waiting அதிகரித்துக்கொண்டே இருந்து, vllm:kv_cache_usage_perc மதிப்பு 1-க்கு அருகில் இருந்தால், அது இந்த நிலையைக் குறிக்கும். சில stacks, கோரிக்கைகளை வரிசைப்படுத்துவதற்குப் பதிலாக, இயங்கிக்கொண்டிருக்கும் ஒரு கோரிக்கையை இடைநிறுத்தி (preempt), அதன் cache-ஐப் பிறகு மீண்டும் கணக்கிடும்; இதை பயனர் stream-க்கு இடையில் ஏற்படும் ஒரு தடையாக உணர்வார்.

நீண்ட context உங்களுக்கு இரண்டு விதங்களில் செலவை ஏற்படுத்துகிறது: தொடக்கத்தில் அதிக prefill வேலை, மற்றும் பதிலின் மீதமுள்ள பகுதிக்கு ஒவ்வொரு token-க்கும் அதிக நினைவக வாசிப்பு.

Batching ஏன் throughput-ஐ அதிகரித்து tail latency-ஐ பாதிக்கிறது?

Decode செயல்முறை bandwidth-ஐச் சார்ந்திருப்பதால், compute பக்கத்தில் கூடுதல் கோரிக்கைகளை (requests) கையாள்வது கிட்டத்தட்ட இலவசமானது. weights-ஐ ஒருமுறை வாசிப்பதன் மூலம் batch-ல் உள்ள ஒவ்வொரு sequence-க்கும் ஒரு token-ஐ உருவாக்க முடியும். எனவே, KV pool தீரும் வரை அல்லது batch அளவு மீண்டும் compute-ஐச் சார்ந்திருக்கும் நிலையை அடையும் வரை, மொத்த throughput batch அளவுக்கேற்ப நேரியல் முறையில் (linearly) அதிகரிக்கிறது. Continuous batching ஒவ்வொரு நிலையிலும் batch-ஐ மீண்டும் உருவாக்குகிறது; எனவே, ஒரு கோரிக்கை முடிந்ததும் அது வெளியேறுகிறது, வரிசையில் காத்திருக்கும் கோரிக்கை அதன் அண்டை கோரிக்கைகளுக்காகக் காத்திருக்காமல் இணைகிறது.

இதன் பாதிப்பு percentiles-ல் வெளிப்படுகிறது. ஒவ்வொரு பயனரின் அடுத்த token-ம் இப்போது பகிரப்பட்ட ஒரு செயலின் மெதுவான பகுதிக்காகக் காத்திருக்க வேண்டியுள்ளது. இதனால் p50 (median) ஏற்றுக்கொள்ளக்கூடிய அளவில் இருந்தாலும், p99 (100-ல் மிக மெதுவான 1 கோரிக்கை) அதிகரிக்கிறது. ஒரு வாக்கியத்தின் இடையில் ஏற்படும் தாமதம் என்பதால், பயனர்கள் p99-ஐயே கவனிக்கிறார்கள்.

Prefill இந்த பாதிப்பை இன்னும் தீவிரமாக்குகிறது. ஒரு பெரிய prompt பாதியிலேயே வரும்போது, அது நீண்ட நேரத்திற்கு device-ஐ ஆக்கிரமிக்கிறது, இதனால் தற்போது streaming-ல் இருக்கும் அனைவரும் ஒரு இடைவெளியை உணர்கிறார்கள். Chunked prefill, ஒரு நீண்ட prompt-ஐ சிறு துண்டுகளாகப் பிரித்து, ஒவ்வொரு துண்டையும் decode batches-உடன் கலப்பதன் மூலம் இந்த இடைவெளியைக் குறைக்கிறது. அக்டோபர் 2026 நிலவரப்படி, vLLM V1 engine இதை இயல்பாகவே செய்கிறது மற்றும் --max-num-batched-tokens மூலம் இந்தச் சமநிலையை மாற்ற அனுமதிக்கிறது. vLLM tuning ஆவணங்கள் இந்தச் சமரசத்தை தெளிவாகக் குறிப்பிடுகின்றன: 2048 போன்ற சிறிய மதிப்புகள் சிறந்த inter token latency (ITL)-ஐத் தருகின்றன, ஏனெனில் குறைவான prefills மட்டுமே decode-ஐத் தடுக்கின்றன. பெரிய மதிப்புகள் சிறந்த TTFT-ஐத் தருகின்றன, ஏனெனில் அதிக prefill tokens ஒரே batch-ல் அடங்கும். அந்த ஒரே flag, prefill மற்றும் decode ஆகியவற்றுக்கு இடையிலான சமநிலையை மாற்றும் ஒரு கருவியாகும். p99 எந்த அளவில் ஏற்றுக்கொள்ள முடியாததாக மாறுகிறது என்பது ஒரு capacity சார்ந்த கேள்வி. ஒரு self-hosted LLM எத்தனை பயனர்களை ஒரே நேரத்தில் கையாள முடியும் என்பது குறித்த விளக்கம் இதே அளவீடுகளைக் கொண்டு விவரிக்கிறது.

பெரிய GPU சில நேரங்களில் எந்த மாற்றத்தையும் ஏற்படுத்தாதது ஏன்?

பெரிய GPU என்பது பொதுவாக அதிக compute திறனைக் குறிக்கும், ஆனால் decode செயல்பாட்டிற்கு compute தேவைப்படுவதில்லை.

மேலே உள்ள அட்டவணையில் இரண்டு வரிசைகளை ஒப்பிட்டுப் பாருங்கள். A100 80GB கார்டு 2039 GB/s என்ற வெளியிடப்பட்ட bandwidth-ஐக் கொண்டுள்ளது, அதே சமயம் L40S கார்டு 864 GB/s-ஐக் கொண்டுள்ளது. இதற்கேற்ப decode உச்ச வரம்பும் சரியாக அமைகிறது: 127 tokens per second மற்றும் 54. RTX 4090 பெரும்பாலான அளவீடுகளில் மிக வேகமான கார்டாகும், அதன் 1008 GB/s bandwidth அதன் உச்ச வரம்பை 63 அளவில் வைக்கிறது. இரண்டு கார்டுகளுக்கு இடையே மற்ற அம்சங்கள் எதுவாக இருந்தாலும், single stream decode என்பது specification sheet-ல் உள்ள bandwidth அளவைப் பொறுத்தே அமையும்.

எனவே, decode வேகத்தை அதிகரிக்க இரண்டு வழிகள் உள்ளன: ஒரு token-க்கு குறைவான bytes-களை வாசிப்பது (weights-ஐ quantize செய்வது அல்லது சிறிய model-ஐ இயக்குவது), அல்லது அதிக bandwidth கொண்ட கார்டை வாங்குவது. Prefill இதற்கு நேர்மாறானது. அதற்கு compute தேவை, எனவே வேகமான கார்டு நீண்ட prompts-க்கான TTFT-ஐக் கணிசமாகக் குறைக்கும். முதல் token வருவதற்கு நான்கு வினாடிகள் ஆகிறது என்பது புகாராக இருந்தால், சிறந்த hardware அதைச் சரிசெய்யக்கூடும். ஆனால், உரை மெதுவாகத் தட்டச்சு செய்யப்படுகிறது (text types slowly) என்பது புகாராக இருந்தால், hardware மாற்றம் பெரும்பாலும் உதவாது.

Prefill மற்றும் decode பணிகளைத் தனித்தனி workers-ல் இயக்க வேண்டுமா?

பெரிய அளவிலான serving stacks இந்த முறையைத்தான் பின்பற்றுகின்றன; இந்த நுட்பம் prefill மற்றும் decode disaggregation என்று அழைக்கப்படுகிறது. ஒரு worker pool prefill பணிகளை மட்டுமே செய்யும், மற்றொரு pool decode பணிகளை மட்டுமே செய்யும். முதல் pool-ஆல் உருவாக்கப்பட்ட KV cache, அதிவேக interconnect மூலம் இரண்டாவது pool-க்கு மாற்றப்படும். இந்த இரண்டு நிலைகளுக்கும் வெவ்வேறு வன்பொருள் (hardware) மற்றும் scheduling தேவைப்படுவதால் இந்த முறை பயனுள்ளதாக இருக்கிறது. Prefill-க்கு அதிக compute திறனும், பெரிய token batches-ம் தேவை. Decode-க்கு அதிக bandwidth-ம், ஒரே நேரத்தில் பல sequences-ஐ கையாளும் திறனும் தேவை. இவற்றைத் தனித்தனியாகப் பிரிப்பதன் மூலம், ஒவ்வொரு pool-ஐயும் தேவைக்கேற்ப scale செய்ய முடியும். மேலும், ஒரு பெரிய prompt காரணமாக மற்ற active streams பாதிக்கப்படுவதையும் இது தடுக்கிறது.

ஒரே ஒரு GPU கொண்ட ஒரு VPS (virtual private server)-ல் இதைச் செய்வது பெரும்பாலும் பலன் தராது. இது ஒரே சாதனத்தை இரண்டாகப் பிரிப்பதற்குச் சமம்; மேலும், ஒரு pointer-ஐப் பயன்படுத்துவதற்குப் பதிலாக, gigabytes அளவிலான cache-ஐ network வழியாக மாற்ற வேண்டிய சூழல் ஏற்படும். ஒவ்வொரு phase-க்கும் தனித்தனி இயந்திரங்களை ஒதுக்கும் அளவுக்கு accelerators இருக்கும்போதும், இரண்டு pool-களையும் தொடர்ந்து இயக்கும் அளவுக்கு traffic இருக்கும்போதும் மட்டுமே இந்த நுட்பம் பயனுள்ளதாக இருக்கும். அதற்கு குறைவான சூழலில், chunked prefill வசதியைப் பயன்படுத்துவதன் மூலம் ஒரே flag-ஐக் கொண்டு அதே போன்ற isolation-ஐப் பெற முடியும்.

எண் தவறாக இருக்கும்போது எதை மாற்ற வேண்டும்

TTFT மிக அதிகமாக இருந்தால்:

  • Prompt-ஐச் சுருக்கவும். Prefill செலவு prompt tokens-ஐப் பொறுத்தது; prefix caching இல்லையென்றால், ஒவ்வொரு கோரிக்கையின்போதும் system prompt-க்குக் கட்டணம் வசூலிக்கப்படும்.
  • Prefix caching-ஐ இயக்கவும், இதன் மூலம் மீண்டும் மீண்டும் வரும் prefix ஒவ்வொரு முறையும் கணக்கிடப்படாமல் ஒருமுறை மட்டுமே கணக்கிடப்படும்.
  • --max-num-batched-tokens-ஐ அதிகரிக்கவும், இதனால் ஒவ்வொரு நிலையிலும் அதிக prefill வேலைகள் நடைபெறும்.
  • மாதிரியைக் குறை கூறுவதற்கு முன் வரிசையைச் (queue) சரிபார்க்கவும். vllm:num_requests_waiting பூஜ்ஜியத்திற்கு மேல் இருந்தால், கோரிக்கை இன்னும் தொடங்கவில்லை என்று அர்த்தம், இது ஒரு கொள்ளளவு (capacity) சார்ந்த சிக்கலாகும்.

Tokens per second மிகக் குறைவாக இருந்தால்:

  • Weights-ஐ Quantize செய்யவும். ஒரு weight-க்குக் குறைவான bytes இருந்தால், ஒரு token-க்கு வாசிக்கப்படும் bytes-ன் அளவும் குறையும்.
  • உங்கள் கார்டின் வெளியிடப்பட்ட memory bandwidth-ஐ மேலே உள்ள அட்டவணையுடன் ஒப்பிட்டு, அதன் உச்ச வரம்பிற்கு எவ்வளவு அருகில் இருக்கிறீர்கள் என்று பார்க்கவும்.
  • --max-num-batched-tokens-ஐக் குறைக்கவும், இதனால் prefills decode-ஐ அடிக்கடி குறுக்கிடாது.
  • Context length-ஐச் சரிபார்க்கவும். ஆயிரக்கணக்கான tokens கொண்ட உரையாடலில், ஒவ்வொரு நிலையிலும் மிகப் பெரிய KV cache வாசிக்கப்படும்.

இங்கு runtime-ம் முக்கியமானது, ஏனெனில் Ollama மற்றும் vLLM ஆகியவை prefill மற்றும் decode-ஐ வெவ்வேறு விதமாகத் திட்டமிடுகின்றன, ஒரு அமைப்பில் உதவும் மாற்றம் மற்றொன்றில் எந்தப் பலனையும் தராமல் போகலாம். முதலில் இரண்டு நிலைகளிலும் அளவீடு செய்யவும், அதன் பிறகு ஒரு மாற்றத்தை மட்டும் செய்யவும்.

FAQ

முதல் token வர ஏன் சில நொடிகள் ஆகிறது, ஆனால் மற்றவை வேகமாக வருகின்றன?

அந்தக் காத்திருப்பு prefill ஆகும், வேகமாக வருவது decode ஆகும். Prefill என்பது வெளியீடு வருவதற்கு முன்பு முழு prompt-ஐயும் ஒரே compute bound pass-ல் செயலாக்குகிறது, எனவே அதன் செலவு prompt-ன் நீளத்தைப் பொறுத்து அதிகரிக்கும். Decode என்பது ஒவ்வொரு படியிலும் ஒரு token-ஐ வெளியிடுகிறது, இதன் வேகம் memory bandwidth-ஆல் தீர்மானிக்கப்படுகிறது; இது prompt எவ்வளவு நீளமானது என்பதிலிருந்து பெரும்பாலும் சுதந்திரமானது. ஒவ்வொரு கோரிக்கையிலும் ஒரு நீண்ட system prompt இருப்பதுதான் இதற்கு வழக்கமான காரணம். Prefix caching இந்தச் செலவின் மீண்டும் மீண்டும் வரும் பகுதியை நீக்குகிறது.

நீண்ட prompt இருந்தால் tokens per second வேகம் குறையுமா?

சிறிது குறையும், ஆனால் TTFT-க்கு இருக்கும் காரணத்திலிருந்து இது மாறுபட்டது. ஒவ்வொரு decode படியும் முந்தைய அனைத்து tokens-ன் keys மற்றும் values-ஐயும் படிக்கிறது, எனவே பெரிய KV cache என்பது ஒவ்வொரு படியிலும் அதிக bytes படிக்கப்படுவதைக் குறிக்கிறது. பொதுவாக 8 billion parameter layout-க்கு cache ஒரு token-க்கு சுமார் 128 KiB இருக்கும், எனவே 8,000 token context என்பது ஒவ்வொரு படியிலும் சுமார் 1 GB அளவு தரவைத் தொடுகிறது. நீண்ட prompt-ன் பெரிய தாக்கம் இன்னும் TTFT-ல் தான் உள்ளது, streaming வேகத்தில் அல்ல.

எந்த GPU விவரக்குறிப்பு decode வேகத்தைக் கணிக்கும்?

Memory bandwidth. வெளியிடப்பட்ட bandwidth-ஐ memory-யில் உள்ள weights-ன் அளவால் வகுத்தால், ஒரு stream-க்கான arithmetic ceiling கிடைக்கும். அதிக compute திறன் கொண்ட ஆனால் அதே bandwidth கொண்ட ஒரு card வேகமாக stream செய்யாது. இதனால்தான் weights-ஐ 8 bit-க்கு quantization செய்வது decode உச்ச வரம்பைத் தோராயமாக இரட்டிப்பாக்குகிறது: இது ஒரு token-க்கு வாசிக்கப்படும் weight bytes-ஐ பாதியாகக் குறைக்கிறது. நடைமுறையில் கிடைக்கும் வேகம் பொதுவாக குறைவாகவே இருக்கும், ஏனெனில் KV cache அதன் சொந்த அளவில் தொடர்ந்து படிக்கப்படுகிறது மற்றும் சில 8 bit வடிவங்கள் activations-ஐக் கணக்கிடுவது போன்ற கூடுதல் வேலைகளைச் சேர்க்கின்றன.

பயனர்களைச் சேர்க்கும்போது throughput ஏன் அதிகரிக்கிறது, ஆனால் ஒவ்வொரு பயனருக்கும் வேகம் குறைவாகத் தெரிகிறது?

Weights-ஐ ஒருமுறை வாசிப்பது batch-ல் உள்ள அனைத்து sequences-க்கும் ஒரு token-ஐ வழங்குகிறது, எனவே மொத்த tokens per second batch size-உடன் அதிகரிக்கிறது. இப்போது ஒவ்வொரு தனிப்பட்ட token-ம் ஒரு பகிரப்பட்ட படிநிலைக்காகக் காத்திருக்கிறது, எனவே ஒவ்வொரு பயனருக்கான latency அதே நேரத்தில் அதிகரிக்கிறது. மொத்த throughput எண்ணைப் பார்க்காமல் p99 inter token latency-ஐக் கவனியுங்கள், மேலும் கோரிக்கைகள் இயங்குவதை விட queue-வில் நிற்கின்றனவா என்பதைப் பார்க்க vllm:num_requests_waiting-ஐச் சரிபார்க்கவும்.

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