SSD Nodes Learn Hosting plans →
تعلیمی Matt Connorتحریر: Matt Connor · اپ ڈیٹ شدہ 2026-10-24

Prefill بمقابلہ decode: پہلا token سست کیوں ہے؟

Prefill compute bound ہوتا ہے اور time to first token طے کرتا ہے، جبکہ decode memory bandwidth bound ہو کر tokens per second طے کرتا ہے۔ دونوں کو الگ ناپیں۔

Prefill بمقابلہ decode، ایک پیراگراف میں

Prefill بمقابلہ decode وہ بنیادی فرق ہے جو self-hosted LLM (large language model) سے متعلق latency کے زیادہ تر سوالات کی وضاحت کرتا ہے۔ Prefill پورے prompt کو ایک ہی pass میں پڑھتا ہے اور compute سے محدود ہوتا ہے۔ Decode جواب ایک وقت میں ایک token لکھتا ہے اور memory bandwidth سے محدود ہوتا ہے۔ پہلے token تک کا وقت prefill کی پیمائش ہے۔ فی سیکنڈ tokens کی تعداد decode کی پیمائش ہے۔

دونوں phases ایک ہی GPU (graphics processing unit) پر، ایک ہی weights کے ساتھ، ایک ہی process کے اندر چلتے ہیں، اس لیے انہیں ایک ہی workload سمجھنا فطری ہے۔ لیکن یہ ایسے کام کرتے ہیں جیسے دو مختلف programs ایک ہی device کو share کر رہے ہوں۔ انہیں الگ سمجھنے سے بظاہر الجھانے والے نتائج کی ایک طویل فہرست قابلِ فہم ہو جاتی ہے۔

پریفِل compute-bound کیوں ہے؟

پریفِل پورے prompt کو ہر layer سے ایک مرتبہ گزارتی ہے۔ 2,000 token کا prompt ہر matrix multiply کو کام کے لیے 2,000 rows دیتا ہے، اس لیے GPU اپنے load کیے گئے weight کے ہر byte پر بہت زیادہ arithmetic کرتا ہے۔ منتقل کیے گئے ہر byte کے مقابلے میں arithmetic کے اس تناسب کو arithmetic intensity کہتے ہیں، اور prefill میں یہ زیادہ ہوتی ہے۔ Device اپنی compute limit کے قریب چلتی ہے، جبکہ memory bus میں گنجائش باقی رہتی ہے۔

پریفِل دو چیزیں تیار کرتی ہے: ہر prompt token کے لیے KV cache، یعنی key اور value tensors، اور پہلا output token۔ یہ pass مکمل ہونے تک reader کو کچھ نہیں ملتا۔ اسی لیے idle server پر prefill، first token تک پہنچنے کے وقت، یعنی TTFT، کا زیادہ تر حصہ ہوتی ہے۔ NVIDIA کی benchmarking guide کے مطابق TTFT میں request queuing اور network latency بھی شامل ہیں، اس لیے مصروف server پر queue میں انتظار prompt جتنا ہی اہم ہو سکتا ہے۔

Prefill کی لاگت prompt کی لمبائی کے ساتھ بڑھتی ہے۔ اس کا linear حصہ ہر layer کا matrix work ہے۔ quadratic حصہ attention ہے، جس میں ہر token اپنے سے پہلے موجود ہر token پر attention کرتا ہے، اور طویل context میں یہ نمایاں ہونے لگتا ہے۔ اس لیے prompt کو دوگنا کرنے سے TTFT کا prefill حصہ کم از کم دوگنا ہو جاتا ہے۔

آپ اسے ایک منٹ میں دیکھ سکتے ہیں۔ اپنے server کو پہلے 200 token کا prompt بھیجیں، پھر 2,000 token کا prompt بھیجیں، اور دونوں مرتبہ اتنے ہی output tokens کی درخواست کریں۔ TTFT تیزی سے بڑھ جائے گا۔ پہلے token کے بعد streaming speed میں بہت کم تبدیلی آئے گی۔

ڈی کوڈ کی memory bandwidth سے حد کیوں مقرر ہوتی ہے؟

ڈی کوڈ ہر step میں ایک token تیار کرتا ہے۔ یہ واحد token تیار کرنے کے لیے GPU کو model کے تمام weights memory سے پڑھنے، ہر weight کو چند operations میں استعمال کرنے، اور پھر اسے ضائع کرنے کی ضرورت ہوتی ہے۔ Arithmetic intensity تقریباً 1 رہتی ہے، اس لیے compute units زیادہ تر وقت انتظار کرتے رہتے ہیں۔

ڈی کوڈ سست ہے کیونکہ ہر token کے لیے پورا model memory سے پڑھنا پڑتا ہے۔ اس لیے رفتار memory bus طے کرتی ہے اور compute units idle رہتے ہیں۔

اس طرح single stream decode speed کی حد وہ arithmetic بنتی ہے جو کاغذ پر کی جا سکتی ہے۔ 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 column میں ہر vendor کی شائع کردہ specification figure درج ہے۔ Ceiling column میں اسی figure کو 16 GB سے تقسیم کیا گیا ہے۔ یہ 16 GB اس model کا سائز ہے جس میں 8 billion parameters کو 16 bit precision پر محفوظ کیا گیا ہے۔ یہ حساب ہے، benchmark result نہیں۔ آپ کی measured rate اس سے کم ہوگی۔ یہ جاننا مفید ہے کہ کتنی کم ہے، کیونکہ اس سے معلوم ہوتا ہے کہ serving stack درست کرنا چاہیے یا hardware۔

6 rows کو ترتیب سے پڑھیں تو pattern واضح ہو جاتا ہے۔ Dual channel DDR5 والا CPU تقریباً 90 GB/s منتقل کرتا ہے۔ اس سے اس model کے لیے decode تقریباً 6 tokens per second تک محدود رہتا ہے۔ L40S تقریباً 54 تک پہنچتا ہے۔ H100 SXM، جس کی شائع کردہ bandwidth 3350 GB/s ہے، تقریباً 209 پر رہتا ہے۔

یہی وجہ ہے کہ quantization، decode speed بڑھانے کا سب سے مؤثر single lever ہے۔ اگر وہی weights 16 bits کے بجائے 8 bits پر محفوظ کیے جائیں تو ہر token کے لیے پڑھے جانے والے weight bytes نصف ہو جاتے ہیں، اس لیے ceiling تقریباً دوگنی ہو جاتی ہے۔ تاہم ceiling اصل result نہیں ہے۔ KV cache اپنی size کے مطابق بدستور پڑھا جاتا ہے۔ بعض 8 bit formats فی token اضافی work بھی کرتے ہیں، مثلاً vLLM اپنی ایک FP8 scheme کے لیے dynamic per token activation quantization document کرتا ہے۔ اس لیے measured gain عموماً 2x سے کم رہتا ہے۔ یہ lever اسی وجہ سے مؤثر ہے جس وجہ سے ceiling تبدیل ہوتی ہے: آپ نے کم memory منتقل کی۔

میں اپنے server پر ہر phase کی پیمائش کیسے کروں؟

Ollama response body میں یہ تقسیم واپس کرتا ہے۔ non 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}'

ایسا model tag استعمال کریں جسے آپ نے واقعی pull کیا ہو؛ ollama list آپ کو دستیاب tags دکھائے گا۔ prompt_eval_count اور prompt_eval_duration prefill سے متعلق ہیں: prompt token count اور اس پر صرف ہونے والا وقت۔ eval_count اور eval_duration decode سے متعلق ہیں۔ Durations nanoseconds میں ہوتی ہیں، اس لیے decode speed eval_count / eval_duration * 1e9 اور prefill speed prompt_eval_count / prompt_eval_duration * 1e9 ہے۔ Ollama کی API reference کے مطابق prompt_eval_duration صرف uncached prompt tokens کو شامل کرتا ہے، اس لیے prefill rate ایسے prompt سے حاصل کریں جسے server نے ابھی process نہ کیا ہو۔ اسی request پر prefill rate کے decode rate سے کہیں زیادہ ہونے کی توقع رکھیں۔ یہی فرق اس مضمون کی باقی وضاحتوں کی بنیاد ہے۔

OpenAI compatible server، مثلاً vLLM، کے لیے 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 cost نکالنے کے لیے time_pretransfer منہا کریں۔ اسے دو بار چلائیں اور دوسرا نتیجہ رکھیں، کیونکہ پہلی call میں cold model load شامل ہو سکتا ہے۔

vLLM /metrics پر Prometheus metrics بھی فراہم کرتا ہے۔ curl -s http://localhost:8000/metrics | grep -E 'time_to_first_token|inter_token_latency' چلانے سے histograms vllm:time_to_first_token_seconds اور vllm:inter_token_latency_seconds حاصل ہوتے ہیں۔ queue depth کے لیے vllm:num_requests_running اور vllm:num_requests_waiting، جبکہ cache pressure کے لیے vllm:kv_cache_usage_perc شامل کریں۔ یہ پانچ names ہی مکمل dashboard ہیں۔

load کے دوران vllm bench serve --model <name> --num-prompts 200 --request-rate 4 چلتے ہوئے server کو drive کرتا ہے اور percentiles کے ساتھ پہلے token تک کا وقت اور ہر output token کی latency رپورٹ کرتا ہے۔ آپ کے موجودہ stack پر دونوں phases کے باہمی اثرات دیکھنے کا یہ سب سے براہِ راست طریقہ ہے۔ اگر آپ الگ tool استعمال کرنا چاہیں تو NVIDIA's GenAI-Perf اور LLMPerf بھی یہی quantities measure کرتے ہیں۔ کسی بھی tuning سے پہلے صاف baseline حاصل کریں: local LLM پر tokens per second کی پیمائش کا طریقہ ایسا baseline دیتا ہے جو reboot کے بعد بھی برقرار رہتا ہے۔

لمبڑا system prompt پہلے token میں تاخیر کیوں کرتا ہے، لیکن streaming speed میں نہیں؟

کیونکہ system prompt صرف prefill کا کام ہے۔ اسے باقی prompt کے ساتھ اسی pass میں ایک مرتبہ process کیا جاتا ہے، اور اس کے مکمل ہونے سے پہلے پہلا token ظاہر نہیں ہوتا۔ اس pass کے بعد یہ صرف KV cache entries کی صورت میں موجود رہتا ہے، اور decode ہر دوسری چیز کے ساتھ ان entries کو بھی پڑھتا ہے۔ اس لیے prefix caching کے بغیر 3,000 token کا system prompt ہر request میں TTFT بڑھاتا ہے، جبکہ tokens per second تقریباً تبدیل نہیں ہوتے۔

تقریباً، بالکل نہیں۔ یہ اضافی KV entries ہر decode step پر دوبارہ پڑھی جاتی ہیں، اس لیے بہت لمبا prompt decode کو معمولی حد تک سست کرتا ہے۔ اگلا section اسی موضوع کا احاطہ کرتا ہے۔

حل یہ ہے کہ ایک ہی prefix کو بار بار recompute کرنا بند کیا جائے۔ prefix caching والا server shared prefix کا KV cache محفوظ رکھتا ہے اور اسے دوبارہ استعمال کرتا ہے، اس لیے وہ دوسری request جس میں وہی system prompt ہو، prefill کے اس حصے کو مکمل طور پر skip کر دیتی ہے۔ vLLM اسے automatic prefix caching کہتا ہے؛ اپنے version میں vllm serve --help دیکھیں، کیونکہ releases کے دوران default تبدیل ہوتا رہا ہے۔ GPU میں موجود یہ KV cache اس prompt cache سے مختلف ہے جس کے لیے API provider آپ سے billing کرتا ہے، اور KV cache اور prompt cache کے درمیان فرق پڑھ لینا چاہیے، اس سے پہلے کہ آپ ان میں سے کسی کو tune کریں۔

decode کی رفتار context بھرنے کے ساتھ کیوں کم ہو جاتی ہے؟

اس کی دو وجوہات ہیں، اور دونوں کا تعلق KV cache سے ہے۔

پہلی وجہ bandwidth ہے۔ ہر decode step پر attention ہر سابقہ token کی keys اور values پڑھتا ہے۔ Weights ہر token کے لیے ایک مستقل لاگت ہیں۔ KV cache بڑھتی رہنے والی لاگت ہے۔ آپ اس کا سائز model کے 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 سے تقسیم کریں، کیونکہ کچھ models دونوں values الگ الگ مقرر کرتے ہیں۔ مثال کے طور پر Mistral NeMo کی width 5,120 اور 32 heads ہیں، لیکن اس کا head dimension 128 ہے، 160 نہیں۔ ابتدائی 2 ایک key اور ایک value کو شمار کرتا ہے۔

ایک عام 8 billion parameter layout میں، 32 layers، GQA (grouped query attention) کے تحت 8 key and value heads، head dimension 128، اور 16 bit precision کے ساتھ حساب 2 x 32 x 8 x 128 x 2 = 131,072 bytes بنتا ہے، یعنی فی token تقریباً 128 KiB۔ اس لیے 8,000 token کی conversation میں ہر request کے لیے تقریباً 1 GB KV cache ہوتی ہے۔

دوسری وجہ capacity ہے۔ یہ 1 GB ایسی memory ہے جس میں weights یا کسی دوسرے user کا context محفوظ نہیں کیا جا سکتا۔ Server startup کے وقت اپنے KV pool کا سائز مقرر کرتا ہے؛ vLLM میں یہ --gpu-memory-utilization کے ذریعے ہوتا ہے۔ جب pool بھر جاتا ہے تو نئی requests انتظار کرتی ہیں۔ vllm:num_requests_waiting کا بڑھنا، جبکہ vllm:kv_cache_usage_perc تقریباً 1 پر برقرار رہے، اس حالت کی واضح علامت ہے۔ کچھ stacks کسی جاری request کو preempt کر کے اس کی cache بعد میں دوبارہ compute کرتے ہیں، queue میں ڈالنے کے بجائے۔ User کو یہ stream کے درمیان stall کی صورت میں محسوس ہوتا ہے۔

طویل context کی لاگت دو مرتبہ ادا کرنی پڑتی ہے: شروع میں زیادہ prefill work، اور جواب کے باقی حصے کے دوران ہر token کے لیے زیادہ memory read۔

بیچنگ throughput میں کیوں مدد کرتی ہے اور tail latency کو کیوں خراب کرتی ہے؟

چونکہ decode bandwidth-bound ہے، اس لیے اضافی requests compute کے لحاظ سے تقریباً مفت ہوتی ہیں۔ weights کو ایک بار پڑھنے سے batch میں موجود ہر sequence کے لیے ایک token تیار کیا جا سکتا ہے۔ اس لیے batch size بڑھنے کے ساتھ مجموعی throughput تقریباً خطی طور پر بڑھتا ہے، یہاں تک کہ KV pool ختم ہو جائے یا batch اتنا بڑا ہو جائے کہ دوبارہ compute-bound بن جائے۔ Continuous batching ہر step پر batch کو دوبارہ بناتی ہے۔ اس طرح مکمل ہونے والی request نکل جاتی ہے اور queue میں موجود request اپنے ہمسایوں کا انتظار کیے بغیر شامل ہو جاتی ہے۔

اس کی قیمت percentiles میں ظاہر ہوتی ہے۔ اب ہر user کا اگلا token مشترکہ step کے سب سے سست حصے کا انتظار کرتا ہے۔ اس لیے p50، یعنی median، قابل قبول رہتا ہے، جبکہ p99، یعنی 100 میں سب سے سست 1 request، بڑھ جاتا ہے۔ لوگ p99 ہی محسوس کرتے ہیں، کیونکہ یہ جملے کے درمیان آنے والا وقفہ ہوتا ہے۔

Prefill اس اثر کو مزید نمایاں کرتا ہے۔ stream کے دوران آنے والا بڑا prompt device کو ایک طویل step کے لیے مصروف رکھتا ہے، اور اس وقت streaming کرنے والے ہر user کو وقفہ محسوس ہوتا ہے۔ Chunked prefill بڑے prompt کو حصوں میں تقسیم کرتی ہے اور ہر حصے کو decode batches میں شامل کرتی ہے، جس سے یہ مسئلہ بڑی حد تک کم ہو جاتا ہے۔ اکتوبر 2026 تک vLLM V1 engine یہ عمل default طور پر کرتا ہے اور اس توازن کو --max-num-batched-tokens کے ذریعے ظاہر کرتا ہے۔ vLLM tuning documentation اس tradeoff کو واضح طور پر بیان کرتی ہے: تقریباً 2048 کی چھوٹی values بہتر inter token latency (ITL) دیتی ہیں، کیونکہ کم prefills، decodes میں خلل ڈالتی ہیں؛ جبکہ بڑی values بہتر TTFT دیتی ہیں، کیونکہ ایک batch میں زیادہ prefill tokens شامل ہو جاتے ہیں۔ یہ واحد flag prefill اور decode کے درمیان توازن کو ایک ایسی number کے طور پر ظاہر کرتا ہے جسے آپ تبدیل کر سکتے ہیں۔ p99 کس مقام پر ناقابل قبول ہو جاتی ہے، یہ capacity کا سوال ہے، اور ایک self-hosted LLM کتنے concurrent users کو serve کر سکتا ہے اسی metrics کے ذریعے اس کا جائزہ لیتی ہے۔

بڑا GPU کبھی کبھی کوئی فرق کیوں نہیں ڈالتا؟

کیونکہ بڑا GPU عموماً زیادہ compute فراہم کرتا ہے، جبکہ decode کو compute کی ضرورت نہیں ہوتی۔

اوپر دیے گئے chart کی دو rows کا موازنہ کریں۔ A100 80GB کی شائع شدہ bandwidth 2039 GB/s ہے، جبکہ L40S کی 864 GB/s ہے۔ decode ceiling بھی عین اسی نسبت سے ہے: بالترتیب 127 tokens per second اور 54۔ RTX 4090 زیادہ تر پیمانوں کے لحاظ سے بہت تیز card ہے، لیکن اس کی 1008 GB/s bandwidth اس کی ceiling کو 63 تک محدود کرتی ہے۔ دو cards کے درمیان دیگر خصوصیات میں جو بھی فرق ہو، single stream decode specification sheet میں دی گئی bandwidth line کی پیروی کرتا ہے۔

اس لیے decode کو تیز کرنے کے دو طریقے ہیں: ہر token کے لیے کم bytes پڑھیں، یعنی weights کو quantize کریں یا چھوٹا model چلائیں؛ یا زیادہ bandwidth خریدیں۔ Prefill اس کے برعکس ہے۔ اسے compute درکار ہوتی ہے، اس لیے تیز card طویل prompts پر TTFT کو واقعی کم کرتا ہے۔ اگر شکایت یہ ہے کہ پہلا token آنے میں چار seconds لگتے ہیں تو بہتر hardware مسئلہ حل کر سکتا ہے۔ اگر شکایت یہ ہے کہ text آہستہ آہستہ type ہوتا ہے تو غالباً بہتر hardware اس میں مدد نہیں کرے گا۔

کیا آپ کو prefill اور decode الگ workers پر چلانے چاہییں؟

بڑے serving stacks عین یہی کام کرتے ہیں، اور اس تکنیک کو prefill اور decode disaggregation کہا جاتا ہے۔ workers کا ایک pool صرف prefill چلاتا ہے، جبکہ دوسرا pool صرف decode چلاتا ہے۔ پہلے pool کی تیار کردہ KV cache تیز interconnect کے ذریعے دوسرے pool کو منتقل کی جاتی ہے۔ یہ اس لیے کام کرتا ہے کہ دونوں phases کو مختلف hardware اور مختلف scheduling درکار ہوتی ہے۔ Prefill کو زیادہ compute اور بڑے token batches درکار ہوتے ہیں۔ Decode کو زیادہ bandwidth اور بیک وقت چلنے والی بہت سی sequences درکار ہوتی ہیں۔ انہیں الگ کرنے سے ہر pool کو اپنی ضرورت کے مطابق scale کیا جا سکتا ہے، اور کوئی ایک بہت بڑا prompt تمام فعال streams کو روک نہیں دیتا۔

ایک GPU والے single VPS (virtual private server) پر ایسا کرنا تقریباً کبھی فائدہ مند نہیں ہوتا۔ آپ ایک ہی device کو اپنے خلاف تقسیم کر رہے ہوں گے، اور pointer کو کئی gigabytes کی cache کے network transfer میں تبدیل کر دیں گے۔ یہ تکنیک اس وقت فائدہ دیتی ہے جب آپ کے پاس اتنے accelerators ہوں کہ ہر phase کے لیے پوری machines مختص کی جا سکیں، اور اتنا مسلسل traffic ہو کہ دونوں pools مصروف رہیں۔ اس سے کم scale پر ایک flag کے ذریعے chunked prefill تقریباً وہی isolation فراہم کرتا ہے۔

جب عدد ناموزوں ہو تو کیا تبدیل کریں

جب TTFT بہت زیادہ ہو:

  • prompt مختصر کریں۔ Prefill cost، prompt tokens کے ساتھ بڑھتی ہے، اور prefix caching کے بغیر ہر request پر system prompt کی لاگت دوبارہ ادا ہوتی ہے۔
  • prefix caching فعال کریں تاکہ repeated prefix ہر بار کے بجائے صرف ایک بار compute ہو۔
  • --max-num-batched-tokens بڑھائیں تاکہ ہر step میں زیادہ prefill work مکمل ہو۔
  • model کو موردِ الزام ٹھہرانے سے پہلے queue چیک کریں۔ vllm:num_requests_waiting کا صفر سے زیادہ ہونا ظاہر کرتا ہے کہ request شروع نہیں ہوئی تھی، یعنی یہ capacity کا مسئلہ ہے۔

جب tokens per second بہت کم ہو:

  • weights کو quantize کریں۔ ہر weight کے لیے کم bytes کا مطلب ہے کہ ہر token کے لیے کم bytes پڑھنے ہوں گے۔
  • اپنے card کی published memory bandwidth کو اوپر دیے گئے chart سے ملائیں اور دیکھیں کہ آپ ceiling کے کتنے قریب ہیں۔
  • --max-num-batched-tokens کم کریں تاکہ prefill، decode میں کم بار مداخلت کرے۔
  • context length چیک کریں۔ ہزاروں tokens تک بڑھ جانے والی conversation ہر step پر کہیں بڑا KV cache پڑھتی ہے۔

یہاں runtime بھی اہم ہے، کیونکہ Ollama اور vLLM prefill اور decode کو مختلف طریقے سے schedule کرتے ہیں، اور جو setting ایک runtime میں مدد دیتی ہے وہ دوسرے میں کچھ بھی نہیں کر سکتی۔ پہلے دونوں phases میں measure کریں، پھر ایک وقت میں صرف ایک چیز تبدیل کریں۔

FAQ

میرے پہلے token کو کئی seconds کیوں لگتے ہیں، لیکن باقی tokens تیزی سے stream ہوتے ہیں؟

انتظار prefill ہوتا ہے، جبکہ streaming decode ہوتی ہے۔ prefill کسی بھی output کے وجود میں آنے سے پہلے پورے prompt کو ایک compute-bound مرحلے میں process کرتا ہے، اس لیے اس کی لاگت prompt کی لمبائی کے ساتھ بڑھتی ہے۔ اس کے بعد decode ہر step میں ایک token خارج کرتا ہے، اور اس کی رفتار memory bandwidth سے متعین ہوتی ہے؛ یہ رفتار prompt کی لمبائی سے تقریباً متاثر نہیں ہوتی۔ ہر request کے ساتھ طویل system prompt بھیجنا اس کی عام وجہ ہے۔ Prefix caching اس لاگت کے بار بار آنے والے حصے کو ختم کرتی ہے۔

کیا طویل prompt tokens per second کی رفتار کم کرتا ہے؟

تھوڑی کم کرتا ہے، لیکن اس کی وجہ TTFT سے مختلف ہے۔ ہر decode step تمام سابقہ tokens کی keys اور values پڑھتا ہے، اس لیے بڑا KV cache ہر token کے لیے زیادہ bytes پڑھنے کا باعث بنتا ہے۔ عام 8 billion parameter layout میں cache تقریباً 128 KiB فی token ہوتا ہے، اس لیے 8,000 token context میں ہر step پر تقریباً 1 GB data پڑھا جاتا ہے۔ طویل prompt کا بڑا اثر اب بھی TTFT پر ہوتا ہے، streaming speed پر نہیں۔

کون سی GPU specification decode speed کی پیش گوئی کرتی ہے؟

Memory bandwidth۔ شائع شدہ bandwidth کو memory میں موجود weights کے size سے تقسیم کریں؛ اس سے ایک stream کے لیے arithmetic ceiling حاصل ہوتی ہے۔ زیادہ compute لیکن وہی bandwidth رکھنے والا card زیادہ تیزی سے stream نہیں کرے گا۔ اسی وجہ سے weights کو 8 bits تک quantize کرنے سے decode ceiling تقریباً دو گنا ہو جاتی ہے: ہر token کے لیے پڑھے جانے والے weight bytes نصف ہو جاتے ہیں۔ عملی طور پر ناپا گیا فائدہ عموماً کم ہوتا ہے، کیونکہ KV cache اپنی اصل size کے مطابق پھر بھی پڑھا جاتا ہے، اور کچھ 8 bit formats میں اضافی فی-token کام شامل ہوتا ہے، جیسے activations کو quantize کرنا۔

جب میں users شامل کرتا ہوں تو throughput کیوں بڑھتا ہے، لیکن ہر user کو سروس سست کیوں محسوس ہوتی ہے؟

Weights کی ایک read batch میں موجود ہر sequence کے لیے ایک token فراہم کرتی ہے، اس لیے batch size بڑھنے کے ساتھ مجموعی tokens per second بڑھتے ہیں۔ اب ہر انفرادی token کو مشترکہ step کے لیے انتظار کرنا پڑتا ہے، اس لیے اسی وقت فی user latency بھی بڑھ جاتی ہے۔ aggregate throughput number کے بجائے p99 inter token latency کو monitor کریں، اور vllm:num_requests_waiting دیکھیں تاکہ معلوم ہو سکے کہ requests queue میں انتظار کر رہی ہیں یا چل رہی ہیں۔

کیا یہ مضمون مفید تھا؟