SSD Nodes Learn Hosting plans →
మార్గదర్శకాలు Matt Connorద్వారా Matt Connor · అప్‌డేట్ చేయబడింది 2026-10-24

Prefill vs decode: మొదటి token ఎందుకు ఆలస్యం?

Prefill compute-bound కావడంతో మొదటి tokenకు సమయం పడుతుంది. Decode memory bandwidth-bound కావడంతో tokens per second నిర్ణయించబడుతుంది. మీ boxలో రెండింటినీ వేరుగా కొలవండి.

Prefill మరియు decode తేడా, ఒక పేరాలో

Self-hosted LLM (large language model)కు సంబంధించిన latency ప్రశ్నల్లో ఎక్కువ భాగాన్ని వివరించే ప్రధాన తేడా prefill మరియు decode మధ్య ఉంటుంది. Prefill మొత్తం promptను ఒకే passలో చదువుతుంది; దీనికి compute పరిమితిగా ఉంటుంది. Decode సమాధానాన్ని ఒక్కో token చొప్పున రాస్తుంది; దీనికి memory bandwidth పరిమితిగా ఉంటుంది. మొదటి token అందే సమయం prefillకు సంబంధించిన కొలత. సెకనుకు ఉత్పత్తి అయ్యే tokens decodeకు సంబంధించిన కొలత.

రెండు దశలూ అదే GPU (graphics processing unit)పై, అదే weightsతో, అదే processలో నడుస్తాయి. అందువల్ల వీటిని ఒకే workloadగా పరిగణించడం సహజం. అయితే ఇవి ఒకే deviceను పంచుకునే రెండు వేర్వేరు programsలా ప్రవర్తిస్తాయి. వీటిని వేరు చేసి పరిశీలిస్తే, గందరగోళంగా కనిపించే అనేక ఫలితాలు ఇక గందరగోళంగా ఉండవు.

Prefill compute-bound ఎందుకు ఉంటుంది?

Prefill మొత్తం prompt‌ను ప్రతి layer ద్వారా ఒక్కసారి పంపుతుంది. 2,000 tokenల prompt‌లో ప్రతి matrix multiply‌కు 2,000 వరుసల పని లభిస్తుంది. అందువల్ల GPU లోడ్ చేసే ప్రతి weight byteకు ఎక్కువ arithmetic పని జరుగుతుంది. తరలించిన ప్రతి byteకు జరిగే arithmetic పనిని arithmetic intensity అంటారు. Prefillలో ఇది ఎక్కువగా ఉంటుంది. పరికరం తన compute పరిమితికి సమీపంగా పనిచేస్తుంది. Memory busలో మాత్రం కొంత సామర్థ్యం మిగులుతుంది.

Prefill రెండు ఫలితాలను ఉత్పత్తి చేస్తుంది: ప్రతి prompt tokenకు సంబంధించిన KV cache (key మరియు value tensors), అలాగే మొదటి output token. ఆ pass పూర్తయ్యే వరకు readerకు ఏదీ చేరదు. అందుకే idle serverలో మొదటి token అందే సమయం (TTFT)లో ఎక్కువ భాగం prefillకే పడుతుంది. NVIDIA benchmarking guide నిర్వచనం ప్రకారం TTFTలో request queuing మరియు network latency కూడా ఉంటాయి. కాబట్టి busy serverలో queueలో వేచి ఉండే సమయం prompt processing సమయానికి సమానంగా ముఖ్యమవుతుంది.

Prompt పొడవు పెరిగే కొద్దీ prefill ఖర్చు పెరుగుతుంది. ఇందులో linear భాగం ప్రతి layerలో జరిగే matrix పనికి సంబంధించినది. Quadratic భాగం attentionకు సంబంధించినది. ఇందులో ప్రతి token తనకు ముందు ఉన్న ప్రతి tokenపై attention చేస్తుంది. దీని ప్రభావం long contextలో స్పష్టంగా కనిపిస్తుంది. అందువల్ల prompt‌ను రెట్టింపు చేస్తే TTFTలోని prefill భాగం కనీసం రెట్టింపు అవుతుంది.

దీన్ని ఒక నిమిషంలో గమనించవచ్చు. మీ serverకు 200 tokenల prompt పంపండి. తరువాత 2,000 tokenల prompt పంపండి. రెండు సందర్భాల్లోనూ ఒకే సంఖ్యలో output tokenలను కోరండి. TTFT గణనీయంగా పెరుగుతుంది. మొదటి token తర్వాత streaming వేగం మాత్రం దాదాపుగా మారదు.

డీకోడ్ memory bandwidthపై ఎందుకు ఆధారపడుతుంది?

డీకోడ్ ప్రతి దశలో ఒక token ను ఉత్పత్తి చేస్తుంది. ఆ ఒక్క token ను ఉత్పత్తి చేయడానికి GPU మోడల్‌లోని ప్రతి weight ను memory నుంచి చదవాలి, ప్రతి weight ను కొన్ని operations కోసం ఉపయోగించాలి, తరువాత దాన్ని వదిలేయాలి. Arithmetic intensity దాదాపు 1గా ఉంటుంది. అందువల్ల compute units ఎక్కువ సమయం వేచి ఉంటాయి.

ప్రతి token కోసం మొత్తం మోడల్‌ను memory నుంచి చదవాల్సి ఉంటుంది. అందుకే decode నెమ్మదిగా ఉంటుంది. Memory bus వేగాన్ని నిర్ణయిస్తుంది, compute units ఖాళీగా ఉంటాయి.

దీని వల్ల single-stream decode speed కు ఉన్న గరిష్ఠ పరిమితిని కాగితంపై లెక్కించవచ్చు. 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 అనేది 16-bit precision లో నిల్వ చేసిన 8 billion parameter model పరిమాణం. ఇది arithmetic లెక్క మాత్రమే, benchmark ఫలితం కాదు. మీరు కొలిచే rate ఈ పరిమితి కంటే తక్కువగా ఉంటుంది. ఆ తేడా ఎంత ఉందో తెలుసుకోవడం ఉపయోగకరం. దాని ఆధారంగా మీ serving stack ను సరిచేయాలా లేదా hardware ను మార్చాలా నిర్ణయించవచ్చు.

6 rows ను క్రమంగా చదివితే pattern స్పష్టంగా కనిపిస్తుంది. Dual-channel DDR5 పై CPU సుమారు 90 GB/s వేగంతో data ను తరలిస్తుంది. ఆ మోడల్‌కు decode వేగం దాదాపు 6 tokens per second వద్ద పరిమితం అవుతుంది. L40S దాదాపు 54 వద్ద ఉంటుంది. Published bandwidth 3350 GB/s ఉన్న H100 SXM దాదాపు 209 వద్ద ఉంటుంది.

అందుకే decode speed పై quantization అత్యంత ప్రభావవంతమైన ఒకే lever గా ఉంటుంది. అదే weights ను 16 bits బదులుగా 8 bits వద్ద నిల్వ చేస్తే, ప్రతి token కు చదవాల్సిన weight bytes సగానికి తగ్గుతాయి. అందువల్ల ceiling సుమారుగా రెట్టింపు అవుతుంది. అయితే ceiling అనేది తుది ఫలితం కాదు. KV cache దాని స్వంత పరిమాణం మేరకు ఇంకా చదవాలి. కొన్ని 8-bit formats ప్రతి token కు అదనపు పని కూడా జోడిస్తాయి. ఉదాహరణకు, vLLM తన ఒక FP8 scheme కోసం dynamic per-token activation quantization ను document చేస్తుంది. అందువల్ల కొలిచిన gain సాధారణంగా 2x కంటే తక్కువగా ఉంటుంది. Ceiling మారడానికి కారణమైనదే ఈ lever పనిచేయడానికి కూడా కారణం: మీరు తక్కువ memory ను తరలించారు.

నా స్వంత serverలో ప్రతి దశను ఎలా కొలవాలి?

Ollama ప్రతిస్పందన 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 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 cached కాని prompt tokensను మాత్రమే కలుపుతుంది. అందువల్ల server ఇప్పుడే చూడని prompt నుంచి prefill rateను తీసుకోండి. అదే requestలో prefill rate decode rate కంటే చాలా ఎక్కువగా ఉంటుంది. మిగతా వివరణ అంతా ఈ తేడా గురించే.

vLLM వంటి OpenAI compatible server కోసం curl మీకు first 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 connection setupతో కలిపిన TTFT. Setup ఖర్చును తొలగించడానికి 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' నడిపితే 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.

Load సమయంలో vllm bench serve --model <name> --num-prompts 200 --request-rate 4 నడుస్తున్న serverను కొలిచి, first tokenకు పట్టే సమయం మరియు ప్రతి output token latencyని percentilesతో నివేదిస్తుంది. మీరు ఇప్పటికే నడుపుతున్న stackలో ఈ రెండు దశలు పరస్పరం ఎలా ప్రభావితం చేసుకుంటున్నాయో చూడటానికి ఇది అత్యంత ప్రత్యక్ష మార్గం. వేరే toolను ఉపయోగించాలనుకుంటే NVIDIA's GenAI-Perf మరియు LLMPerf కూడా ఇదే పరిమాణాలను కొలుస్తాయి. ఏదైనా tune చేయడానికి ముందు స్వచ్ఛమైన baseline తీసుకోండి: స్థానిక LLMలో ప్రతి సెకనుకు tokens కొలవడంలోని పద్ధతి reboot తర్వాత కూడా ఉపయోగించగల baselineను ఇస్తుంది.

పొడవైన system prompt మొదటి token రావడాన్ని ఆలస్యం చేస్తుంది, కానీ streaming వేగాన్ని ఎందుకు ఆలస్యం చేయదు?

ఎందుకంటే system prompt prefill పనిలో భాగం మాత్రమే. ఇది prompt లోని మిగతా భాగంతో పాటు ఒకే passలో, మొదటి token కనిపించే ముందు ఒకసారి process అవుతుంది. ఆ pass పూర్తయిన తర్వాత ఇది KV cache entries రూపంలో మాత్రమే ఉంటుంది. Decode సమయంలో మిగతా సమాచారంతో పాటు వాటినీ read చేస్తుంది. కాబట్టి prefix caching లేకపోతే, 3,000 tokenల system prompt ప్రతి requestలోనూ TTFT కు అదనపు సమయాన్ని జోడిస్తుంది. అయితే tokens per second దాదాపు మారదు.

దాదాపు మాత్రమే, పూర్తిగా కాదు. ఆ అదనపు KV entries ప్రతి decode stepలో మళ్లీ read చేయాలి. అందువల్ల చాలా పొడవైన prompt decode ను కొద్దిగా నెమ్మదిస్తుంది. తరువాతి sectionలో దీనిని వివరిస్తాం.

అదే prefixను మళ్లీ recompute చేయకుండా ఆపడం పరిష్కారం. prefix caching ఉన్న server shared prefix యొక్క KV cacheను ఉంచి, దాన్ని మళ్లీ ఉపయోగిస్తుంది. అందువల్ల అదే system promptతో వచ్చే రెండో requestలో ఆ prompt భాగానికి సంబంధించిన prefill పూర్తిగా skip అవుతుంది. vLLM దీనిని automatic prefix caching అని పిలుస్తుంది. మీ versionలో vllm serve --help ను పరిశీలించండి, ఎందుకంటే releases మధ్య default మారింది. GPUలో ఉండే ఈ KV cache, API provider మీకు billing చేసే prompt cacheకి భిన్నమైనది. రెండింటినీ tune చేయడానికి ముందు KV cache మరియు prompt cache మధ్య తేడా చదవడం ఉపయోగకరం.

కాంటెక్స్ట్ నిండుతున్నప్పుడు decode ఎందుకు నెమ్మదిస్తుంది?

దీనికి రెండు కారణాలు ఉన్నాయి. రెండూ KV cache కు సంబంధించినవే.

మొదటి కారణం bandwidth. ప్రతి decode దశలో attention, ఇంతకు ముందు వచ్చిన ప్రతి token యొక్క keys మరియు values ను చదువుతుంది. ప్రతి token కు weights ఒక స్థిరమైన వ్యయం. KV cache పరిమాణం మాత్రం పెరుగుతూనే ఉంటుంది. Model యొక్క config.json ఆధారంగా దాని పరిమాణాన్ని లెక్కించవచ్చు: ప్రతి token కు bytes = 2 × num_hidden_layers × num_key_value_heads × head dimension × ప్రతి element కు bytes. Configuration లో head dimension ఇచ్చి ఉంటే head_dim ను ఉపయోగించండి. అది లేకపోతే మాత్రమే hidden_size ను num_attention_heads తో భాగించండి, ఎందుకంటే కొన్ని models ఈ రెండు విలువలను స్వతంత్రంగా సెట్ చేస్తాయి. ఉదాహరణకు, Mistral NeMo లో width 5,120, heads 32 ఉన్నప్పటికీ 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 ప్రారంభ సమయంలోనే తన KV pool పరిమాణాన్ని నిర్ణయిస్తుంది. vLLM లో దీనిని --gpu-memory-utilization ద్వారా సెట్ చేస్తారు. Pool పూర్తయినప్పుడు కొత్త requests వేచి ఉంటాయి. vllm:num_requests_waiting పెరుగుతూ, vllm:kv_cache_usage_perc దాదాపు 1 వద్ద ఉండటం ఈ స్థితికి ఖచ్చితమైన సంకేతం. కొన్ని stacks request ను queue చేయడానికి బదులుగా, నడుస్తున్న request ను తాత్కాలికంగా నిలిపి, తరువాత దాని cache ను మళ్లీ లెక్కిస్తాయి. దీనివల్ల stream మధ్యలో stall కనిపిస్తుంది.

Long context కు రెండుసార్లు ఖర్చు ఉంటుంది: ప్రారంభంలో ఎక్కువ prefill పని, అలాగే సమాధానం మిగిలిన భాగంలో ప్రతి token కు ఎక్కువ memory read.

బ్యాచింగ్ throughput ను ఎందుకు పెంచుతుంది, tail latency ను ఎందుకు దెబ్బతీస్తుంది?

decode bandwidth-bound కావడంతో, అదనపు requests compute వైపు దాదాపు ఉచితంగానే ఉంటాయి. Weights ను ఒకసారి read చేయడం ద్వారా batch లోని ప్రతి sequence కు ఒక token ఉత్పత్తి చేయవచ్చు. అందువల్ల batch size పెరిగే కొద్దీ మొత్తం throughput దాదాపు linear గా పెరుగుతుంది. అయితే KV pool అయిపోయే వరకు లేదా batch మళ్లీ compute-bound అయ్యేంత పెద్దదయ్యే వరకు మాత్రమే ఇది జరుగుతుంది. Continuous batching ప్రతి stepలో batch ను మళ్లీ నిర్మిస్తుంది. అందువల్ల ఒక request పూర్తయితే అది బయటకు వెళ్తుంది, queueలో ఉన్న మరో request దాని పొరుగు requests కోసం వేచి ఉండకుండా batchలో చేరుతుంది.

దీని ప్రభావం percentilesలో కనిపిస్తుంది. ఇప్పుడు ప్రతి user యొక్క తదుపరి token, shared stepలో అత్యంత నెమ్మదిగా ఉన్న భాగం పూర్తయ్యే వరకు వేచి ఉండాలి. కాబట్టి p50, అంటే median, ఆమోదయోగ్యంగానే ఉండవచ్చు. కానీ p99, అంటే 100 requestsలో నెమ్మదిగా పూర్తయ్యే 1 request, మరింత ఆలస్యం అవుతుంది. ప్రజలు గమనించేది p99నే, ఎందుకంటే వాక్యం మధ్యలో కనిపించే విరామం అదే.

Prefill ఈ ప్రభావాన్ని మరింత పెంచుతుంది. stream మధ్యలో పెద్ద prompt వస్తే, device ఒక దీర్ఘమైన step కోసం దానిపై పనిచేయాల్సి ఉంటుంది. ఆ సమయంలో ప్రస్తుతం streaming చేస్తున్న ప్రతి userకు gap కనిపిస్తుంది. Chunked prefill దీర్ఘమైన prompt ను చిన్న భాగాలుగా విభజించి, ప్రతి భాగాన్ని decode batchesలో కలపడం ద్వారా ఈ సమస్యలో ఎక్కువ భాగాన్ని తొలగిస్తుంది. October 2026 నాటికి vLLM V1 engine దీన్ని defaultగా చేస్తుంది మరియు సమతుల్యాన్ని --max-num-batched-tokens ద్వారా నియంత్రించవచ్చు. vLLM tuning documentation ఈ tradeoff ను స్పష్టంగా వివరిస్తుంది: సుమారు 2048 వంటి చిన్న values మెరుగైన inter token latency (ITL) ఇస్తాయి, ఎందుకంటే తక్కువ prefills decodeలను అంతరాయం కలిగిస్తాయి. పెద్ద values మెరుగైన TTFT ఇస్తాయి, ఎందుకంటే ఒక batchలో ఎక్కువ prefill tokens సరిపోతాయి. ఈ ఒక్క flag prefill మరియు decode మధ్య సమతుల్యాన్ని ఒక సంఖ్యగా నియంత్రించడానికి అందిస్తుంది. p99 ఎక్కడ ఆమోదయోగ్యం కాకుండా మారుతుందో అనేది capacity ప్రశ్న. ఒక self-hosted LLM ఎన్ని concurrent usersకు సేవలు అందించగలదో ఇదే metricsతో నిర్ణయించవచ్చు.

పెద్ద GPU కొన్నిసార్లు ఎలాంటి మార్పు ఎందుకు చేయదు?

ఎందుకంటే పెద్దది అంటే సాధారణంగా ఎక్కువ compute అని అర్థం. కానీ decode కు ఎక్కువ compute అవసరం ఉండదు.

పై chart లోని రెండు వరుసలను పోల్చండి. A100 80GB కి ప్రచురించిన bandwidth 2039 GB/s ఉంది. L40S కి అది 864 GB/s. Decode ceiling కూడా అదే విధంగా ఉంటుంది: సెకనుకు 127 tokens, దీనికి విరుద్ధంగా 54. చాలా ప్రమాణాల ప్రకారం RTX 4090 అత్యంత వేగవంతమైన card. దాని 1008 GB/s వల్ల దాని 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 అవుతున్నదనేది సమస్య అయితే, అది సాధారణంగా పరిష్కరించదు.

prefill మరియు decode ను వేర్వేరు workers పై నడపాలా?

పెద్ద serving stacks ఇదే విధానాన్ని ఉపయోగిస్తాయి. దీనిని prefill and decode disaggregation అంటారు. ఒక worker pool prefill ను మాత్రమే నడుపుతుంది. రెండో pool decode ను మాత్రమే నడుపుతుంది. మొదటి pool నిర్మించిన KV cache ను fast interconnect ద్వారా రెండో pool కు బదిలీ చేస్తారు. ఈ విధానం పనిచేయడానికి కారణం, ఈ రెండు దశలకు వేర్వేరు hardware మరియు వేర్వేరు scheduling అవసరాలు ఉండటమే. prefill కు compute మరియు పెద్ద token batches అవసరం. decode కు bandwidth మరియు ఒకేసారి నడిచే అనేక sequences అవసరం. వాటిని విడదీయడం వల్ల ప్రతి pool ను స్వతంత్రంగా scale చేయవచ్చు. అలాగే ఒక పెద్ద prompt కారణంగా అన్ని active streams నిలిచిపోకుండా ఉంటుంది.

ఒకే GPU ఉన్న single VPS (virtual private server) పై దీన్ని చేయడం దాదాపు ఎప్పుడూ ప్రయోజనకరం కాదు. మీరు ఒకే device ను దాని నుంచే విభజించినట్లవుతుంది. అదనంగా, pointer ను gigabytes పరిమాణంలోని cache network transfer గా మార్చాల్సి వస్తుంది. ప్రతి దశకు మొత్తం machines కేటాయించడానికి సరిపడా accelerators ఉన్నప్పుడు, అలాగే రెండు pools ను నిరంతరం busy గా ఉంచగల స్థిరమైన traffic ఉన్నప్పుడు ఈ విధానం ప్రయోజనకరంగా ఉంటుంది. అంతకంటే తక్కువ స్థాయిలో, ఒక flag తో chunked prefill దాదాపు ఇదే isolation ను అందిస్తుంది.

సంఖ్య అనుకూలంగా లేకపోతే ఏమి మార్చాలి

TTFT చాలా ఎక్కువగా ఉన్నప్పుడు:

  • prompt ను కుదించండి. Prefill ఖర్చు prompt tokens సంఖ్యను అనుసరిస్తుంది. Prefix caching లేకపోతే ప్రతి అభ్యర్థనలో system prompt కోసం మళ్లీ ఖర్చు అవుతుంది.
  • Prefix caching ను ప్రారంభించండి. దీంతో పునరావృతమయ్యే prefix ప్రతి సారి కాకుండా ఒక్కసారి మాత్రమే లెక్కించబడుతుంది.
  • --max-num-batched-tokens ను పెంచండి. అప్పుడు ప్రతి step లో ఎక్కువ prefill పని పూర్తవుతుంది.
  • model ను తప్పుపట్టే ముందు queue ను తనిఖీ చేయండి. vllm:num_requests_waiting సున్నా కంటే ఎక్కువగా ఉంటే అభ్యర్థన ఇంకా ప్రారంభం కాలేదని అర్థం. ఇది capacity సమస్య.

Tokens per second చాలా తక్కువగా ఉన్నప్పుడు:

  • weights ను quantize చేయండి. ప్రతి weight కు తక్కువ bytes ఉంటే, ప్రతి token కోసం చదవాల్సిన bytes కూడా తక్కువగా ఉంటాయి.
  • మీ card ప్రచురించిన memory bandwidth ను పై chart తో పోల్చి, ceiling కు మీరు ఎంత దగ్గరగా ఉన్నారో చూడండి.
  • --max-num-batched-tokens ను తగ్గించండి. అప్పుడు prefill, decode ను తక్కువ తరచుగా అంతరాయం కలిగిస్తుంది.
  • context length ను తనిఖీ చేయండి. వేల tokens వరకు పెరిగిన conversation ప్రతి step లో చాలా పెద్ద KV cache ను చదువుతుంది.

ఇక్కడ runtime కూడా ముఖ్యమే, ఎందుకంటే Ollama మరియు vLLM prefill మరియు decode ను వేర్వేరుగా schedule చేస్తాయి. ఒకదానికి సహాయపడే setting మరొకదానిపై ఎలాంటి ప్రభావం చూపకపోవచ్చు. ముందుగా రెండు phases లోనూ కొలతలు తీసుకుని, తరువాత ఒక్కసారి ఒక మార్పు మాత్రమే చేయండి.

FAQ

నా మొదటి token రావడానికి seconds పడుతున్నాయి, కానీ మిగతావి వేగంగా stream అవుతున్నాయి. ఎందుకు?

ఆ వేచి ఉండే సమయం prefill కు, streaming decode కు సంబంధించినది. ఏ output ఉత్పత్తి కాకముందు prefill మొత్తం prompt ను compute-bound pass లో process చేస్తుంది. అందువల్ల దాని వ్యయం prompt పొడవు పెరిగే కొద్దీ పెరుగుతుంది. తరువాత decode ప్రతి step కు ఒక token ను emit చేస్తుంది. దీని వేగాన్ని memory bandwidth నిర్ణయిస్తుంది. Prompt ఎంత పొడవుగా ఉన్నా, దానిపై దీని ప్రభావం చాలా తక్కువగా ఉంటుంది. ప్రతి request లో పొడవైన system prompt పంపడం సాధారణ కారణం. Prefix caching ద్వారా ఈ పునరావృత వ్యయంలోని భాగాన్ని తొలగించవచ్చు.

Prompt పొడవు పెరిగితే seconds కు వచ్చే tokens వేగం తగ్గుతుందా?

కొంతవరకు తగ్గుతుంది. అయితే కారణం TTFT కు సంబంధించిన కారణం కంటే భిన్నంగా ఉంటుంది. ప్రతి decode step లో ముందు వచ్చిన అన్ని tokens కు సంబంధించిన keys మరియు values ను చదవాలి. అందువల్ల పెద్ద KV cache అంటే ప్రతి token కు మరిన్ని bytes చదవాల్సి ఉంటుంది. సాధారణ 8 billion parameter layout లో cache ప్రతి token కు సుమారు 128 KiB ఉంటుంది. కాబట్టి 8,000 token context లో ప్రతి step సమయంలో దాదాపు 1 GB డేటాను చదవాలి. అయినప్పటికీ పొడవైన prompt ప్రభావం ప్రధానంగా TTFT పైనే ఉంటుంది, streaming speed పైన కాదు.

Decode speed ను ఏ GPU specification అంచనా వేయగలదు?

Memory bandwidth. Published bandwidth ను memory లోని weights పరిమాణంతో భాగిస్తే, ఒక stream కు గల arithmetic ceiling లభిస్తుంది. ఎక్కువ compute ఉన్నా అదే bandwidth కలిగిన card వేగంగా stream చేయదు. అందుకే weights ను 8 bits కు quantize చేసినప్పుడు decode ceiling సుమారు రెట్టింపు అవుతుంది. ప్రతి token కు చదవాల్సిన weight bytes సగానికి తగ్గుతాయి. కొలిచిన gain సాధారణంగా అంత పెద్దగా ఉండదు. కారణం KV cache తన పరిమాణం మేరకు ఇంకా చదవాల్సి ఉంటుంది. అదనంగా, కొన్ని 8 bit formats లో activations ను quantize చేయడం వంటి ప్రతి token కు సంబంధించిన పనులు ఉంటాయి.

Users ను జోడించినప్పుడు throughput పెరుగుతోంది, కానీ ప్రతి user కు నెమ్మదిగా అనిపిస్తోంది. ఎందుకు?

Weights ను ఒకసారి చదివితే batch లోని ప్రతి sequence కోసం ఒక token ను process చేయవచ్చు. అందువల్ల batch size పెరిగే కొద్దీ మొత్తం tokens per second పెరుగుతుంది. అయితే ప్రతి individual token shared step కోసం వేచి ఉండాలి. అదే సమయంలో ఒక్కో user latency పెరుగుతుంది. Aggregate throughput number ను మాత్రమే కాకుండా p99 inter token latency ను కూడా monitor చేయండి. Requests queue అవుతున్నాయా, లేక అమలవుతున్నాయా తెలుసుకోవడానికి vllm:num_requests_waiting ను పరిశీలించండి.

ఈ వ్యాసం ఉపయోగకరంగా ఉందా?