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

5 మంది వచ్చినప్పుడు self-hosted LLM ఎందుకు ఆగిపోతుంది

ఒక్క వినియోగదారుతో వేగంగా, ఐదుగురితో నెమ్మదిగా ఎందుకు? Ollama default parallel requests 1; batching, KV cache, prefill, queue depth మీ LLM సామర్థ్యాన్ని నిర్ణయిస్తాయి.

మరిన్ని వినియోగదారులు చేరినప్పుడు self-hosted LLM ఎందుకు నెమ్మదిస్తుంది?

5 concurrent users వద్ద self-hosted LLM నిలిచిపోతే, సాధారణ కారణం server ఒకేసారి ఒక reply మాత్రమే generate చేసేలా సెట్ చేయబడి ఉండటమే. మిగిలిన నలుగురు queueలో వేచి ఉంటారు. Ollama documentation తన default గురించి స్పష్టంగా చెబుతుంది: OLLAMA_NUM_PARALLEL అంటే “ప్రతి model ఒకేసారి process చేసే గరిష్ఠ parallel requests సంఖ్య; default 1.” ఏదీ విఫలమవడం లేదు. Serving software ఒకేసారి అనేక requests పై పనిచేయగలదు. మీ ఐదుగురిలో నలుగురు తమ turn కోసం వేచి ఉన్నారు, ఎందుకంటే ఒక setting అలా నిర్దేశించింది.

దీనికి పరిష్కారం సాధారణంగా పెద్ద server కాదు. ఒకే forward passలో model ద్వారా అనేక requests ను process చేసే serving engine అవసరం. అలాగే ఆ సమయంలో అందరి conversationలను నిల్వ చేయడానికి సరిపడా అదనపు memory కూడా అవసరం. ఈ రెండు అంశాలు ముఖ్యమైనవే. అయితే మీ గరిష్ఠ పరిమితిని వాస్తవంగా నిర్ణయించేది రెండవ అంశమే.

ప్రతి అభ్యర్థన దాటే రెండు దశలు

Prefill మొత్తం prompt ను ఒకేసారి చదివి, దాని కోసం attention cache ను నిర్మిస్తుంది. ప్రతి prompt token model గుండా కలిసి వెళ్తుంది. అందువల్ల prefill ఒక పెద్ద matrix multiply గా ఉంటుంది. ఇది arithmetic throughput ద్వారా పరిమితమవుతుంది. తరువాత decode సమాధానాన్ని ఒక్కో token చొప్పున రాస్తుంది. ప్రతి token కోసం model యొక్క పూర్తి weights ను మళ్లీ memory నుంచి చదవాలి. అయితే ఆ ఒక్క token పై జరిగే arithmetic చాలా తక్కువగా ఉంటుంది. అందువల్ల decode memory bandwidth ద్వారా పరిమితమవుతుంది.

Batching పనిచేయడానికి ప్రధాన కారణం ఈ అసమానతే. ఒక user కోసం decoding చేస్తున్నప్పుడు ప్రతి token కు ఉదాహరణకు 5 GB weights చదవాలి. Arithmetic units లో ఎక్కువ భాగం ఖాళీగా ఉంటుంది. రెండో request ను జోడిస్తే అదే 5 GB ను ఒక్కసారి చదివి, దాని ఆధారంగా రెండు tokens ను compute చేయవచ్చు. రెండో user వల్ల అదనపు సమయం దాదాపుగా ఉండదు. Requests ను తప్పనిసరిగా ఒకదాని తరువాత ఒకటి serve చేస్తే ఈ ప్రయోజనం కోల్పోతారు.

User అనుభవాన్ని రెండు సంఖ్యలు వివరిస్తాయి. TTFT (time to first token) అనేది queue wait మరియు prefill కలిపిన సమయం. ITL (inter-token latency) అనేది stream అవుతున్న tokens మధ్య వ్యవధి. ఇది decode ద్వారా నిర్ణయించబడుతుంది. Slow server సాధారణంగా వీటిలో ఒకదానిలో slow గా ఉంటుంది. వాటికి అవసరమైన పరిష్కారాలు ఒకేలా ఉండవు. ఏ సమస్యను పరిష్కరిస్తున్నారో setting మార్చే ముందు నిర్ధారించుకోవాలి. prefill మరియు decode ను విడిగా సమయాన్ని కొలవడం ద్వారా అది తెలుస్తుంది.

మందగించిన సమాధానం కోసం అందరూ వేచి ఉండేలా static batching చేస్తుంది

Static batching అనేది సరళమైన విధానం. అప్లికేషన్ code లో మీరే requests ను సమూహాలుగా కలిపితే ఇదే జరుగుతుంది. Engine N requests ను సేకరించి, వాటిని కలిసి నడుపుతుంది. ఆ సమూహంలోని ఎక్కువ generation పూర్తయ్యే వరకు ప్రతి slot ను అలాగే ఉంచుతుంది.

ఒక user 1,200 tokenల summary అడిగితే, ఒకే వరుసలో సమాధానం ఇవ్వాల్సిన నాలుగు requests కూడా batch లోనే నిలిచిపోతాయి. ఎందుకంటే batch లోని అత్యంత మందగించిన request పూర్తయ్యే వరకు ఏ slot కూడా విడుదల కాదు.

దీనివల్ల రెండు రకాల వ్యయాలు ఏర్పడతాయి. పూర్తయిన sequences ఉపయోగకరమైన compute చేయకపోయినా slots ను ఆక్రమిస్తూనే ఉంటాయి. Output lengths మారుతున్నప్పుడు effective throughput తగ్గుతుంది. Chat output lengths లో ఈ మార్పు ఎక్కువగా ఉంటుంది. Batch ఏర్పడిన ఒక step తర్వాత వచ్చిన request ప్రారంభమయ్యే ముందు మొత్తం batch పూర్తిగా ఖాళీ కావాలి. అందువల్ల అది prefill ప్రారంభించకముందే వేచి ఉంటుంది. దాని TTFT మరొకరి పొడవైన essay పై ఆధారపడుతుంది.

ప్రతి token వద్ద continuous batching అభ్యర్థనలను చేర్చి, పూర్తయిన అభ్యర్థనలను తొలగిస్తుంది

Continuous batching ఒకే decoding step స్థాయిలో scheduling చేస్తుంది. ప్రతి step తర్వాత scheduler stop token ను ఇప్పుడే విడుదల చేసిన sequences ను తొలగించి, ఖాళీ slots లో వేచి ఉన్న అభ్యర్థనలను చేర్చుతుంది. step 40 వద్ద ముగిసే reply తన slot ను batch ముగిసినప్పుడు కాదు, step 40 వద్దనే ఖాళీ చేస్తుంది.

ఇది అసాధారణమైన విధానం కాదు. llama-server లో -cb, --cont-batching ను “continuous batching (a.k.a dynamic batching) ను ప్రారంభించాలా (default: enabled)” అని వివరించి, features లో “Parallel decoding with multi-user support” ను చేర్చారు. November 2025లో merge చేసిన మార్పు తర్వాత ఇది defaultగా 4 slots తో ప్రారంభమవుతుంది (-np defaultగా -1, auto కు సెట్ అవుతుంది). vLLM ఈ ఆలోచన ఆధారంగానే రూపొందించబడింది. Ollama కూడా parallel requests ను అందిస్తుంది. అయితే default విలువ సంఖ్యను oneకు పరిమితం చేస్తుంది. అందుకే చాలా మంది తమ hardware concurrency ను నిర్వహించలేదని భావిస్తారు. వాస్తవానికి వారి configuration దానిని నిరాకరించింది.

ప్రచురితమైన continuous batching ఫలితాలను సాధారణంగా spare compute మరియు cache కోసం tens of gigabytes రెండూ కలిగిన datacenter cards పై కొలుస్తారు. ఆ ఫలితాల స్వరూపం మీ boxకూ వర్తిస్తుంది. అయితే వాటి పరిమాణం వర్తించదు. దానికి కారణం కింది memory విభాగంలో వివరించబడింది.

Prefill అదే compute వనరుల కోసం decode తో పోటీ పడుతుంది

నాలుగు replies stream అవుతున్న సమయంలో కొత్త request వస్తే, దాని prompt ను ముందుగా prefill చేయాలి. Prefill కు ఎక్కువ compute అవసరం. Scheduler ఆ prefill కోసం ప్రత్యేక step కేటాయిస్తే, ఆ సమయంలో stream అవుతున్న నలుగురు users కు token అందదు. పొడవైన prompt ఉన్నప్పుడు ప్రతి open window లో ఇది స్పష్టమైన pause గా కనిపిస్తుంది. మరొకరు send నొక్కినప్పుడల్లా server hiccup అవుతుందని చెప్పినప్పుడు వారు ఉద్దేశించేది ఈ stutter నే.

Chunked prefill పొడవైన prompt ను భాగాలుగా విభజిస్తుంది. ప్రతి భాగాన్ని ఇప్పటికే నడుస్తున్న decodes తో అదే step లో కలుపుతుంది. vLLM tuning guide ఈ tradeoff ను నేరుగా వివరిస్తుంది: చిన్న chunk budgets “decode ను నెమ్మదింపజేసే prefills తక్కువగా ఉండటం వల్ల మెరుగైన ITL ను అందిస్తాయి”. ఎక్కువ విలువలు “ఒక batch లో ఎక్కువ prefill tokens ను process చేయగలగడం వల్ల మెరుగైన time to first token (TTFT) ను అందిస్తాయి”. మీరు ఎవరి అనుభవాన్ని మెరుగ్గా రక్షించాలో ఎంచుకుంటున్నారు: reply ప్రారంభం కావడానికి వేచి ఉన్న వ్యక్తిదా, లేదా text stream అవడాన్ని చూస్తున్న వ్యక్తులదా?

ఈ ప్రభావం ఎంత తీవ్రంగా ఉంటుందో prompt length నిర్ణయిస్తుంది. 6,000 token prompt కు 200 token answer ఉంటే, 200 decode steps కు వ్యతిరేకంగా 6,000 tokens prefill work చేయాలి. Retrieval-augmented chat మరియు పొడవైన system prompts రెండూ మిమ్మల్ని ఈ పరిస్థితిలోకి నెడతాయి. అందువల్ల prefill చిన్న rounding error గా ఉండదు; users వేచి ఉండే ప్రధాన కారణంగా మారుతుంది. పొడవైన భాగం మళ్లీ మళ్లీ వస్తే prefix caching సహాయపడుతుంది: vLLM --enable-prefix-caching ను అందిస్తుంది. ఇది ప్రతి request కోసం shared prompt prefix ను మళ్లీ compute చేయకుండా, దాని cache ను reuse చేస్తుంది.

ముందుగా అయిపోయేది KV cache మెమరీ

సక్రియంగా ఉన్న ప్రతి conversation లోని ప్రతి token, model లోని ప్రతి layer లో ఒక key vector మరియు ఒక value vector ను ఉంచుతుంది. ఇదే KV cache (key/value cache). ప్రతి కొత్త token కోసం మొత్తం prompt ను మళ్లీ లెక్కించాల్సిన అవసరం లేకుండా decode ప్రక్రియ కొనసాగడానికి ఇది ఉపయోగపడుతుంది. ప్రతి token కు cache చేయబడే values సంఖ్య model shape ద్వారా స్థిరంగా నిర్ణయించబడుతుంది: 2 (ఒక key, ఒక value) × layer count × key/value heads సంఖ్య × head dimension. ఆ సంఖ్యలను model యొక్క config.json నుంచి తీసుకోండి. ఆ పరిమాణాన్ని bytes per value తో గుణిస్తే cache పరిమాణం వస్తుంది. ఈ చివరి అంశం model లో భాగం కాదు; ఇది runtime setting. llama-server cache ను default గా f16 (2 bytes) లో ఉంచుతుంది. -ctk మరియు -ctv ద్వారా q8_0 వంటి చిన్న types ను కూడా స్వీకరిస్తుంది.

ఈ లెక్కను ఒక్కసారి చేస్తే memory ceiling ఇక రహస్యంగా ఉండదు. 36 layers, 8 key/value heads, 128 head dimension కలిగిన సాధారణ 8B model లో cache ను 16-bit గా ఉంచితే, ప్రతి token కు 2 36 8 128 2 bytes అవసరం. అంటే 147,456 bytes, సుమారు 144 KiB. 8,192 tokens గల ఒక conversation కు సుమారు 1.2 GB cache అవసరం. ఇలాంటి 5 conversations కు weights కు అదనంగా సుమారు 6 GB అవసరం. ఎన్ని users ను నిర్వహించగలమో చెప్పే అసలు సమాధానం ఇదే.

Concurrency పెరిగితే context అవసరం కూడా పెరుగుతుంది. Tools దీనిని స్పష్టంగా చూపిస్తాయి. Ollama FAQ ఇలా చెబుతుంది: "ఒక model కోసం parallel request processing చేస్తే, parallel requests సంఖ్యకు అనుగుణంగా context size పెరుగుతుంది. ఉదాహరణకు, 4 parallel requests తో 2K context ఉంటే, అది 8K context గా మారుతుంది మరియు అదనపు memory allocation అవసరం అవుతుంది." అవసరమైన RAM, OLLAMA_NUM_PARALLEL ను OLLAMA_CONTEXT_LENGTH తో గుణించిన పరిమాణానికి అనుగుణంగా పెరుగుతుంది. llama-server లో default auto slot count ప్రతి slot ను ఒకే unified KV buffer పై నడుపుతుంది. అందువల్ల మొత్తం -c context, slots ఉపయోగించే ఒకే pool గా ఉంటుంది. మీరు -np ను స్వయంగా సెట్ చేస్తే, --kv-unified ను కూడా pass చేయనంతవరకు unified buffer నిలిపివేయబడుతుంది. అప్పుడు -c తో కోరిన context, -np slots మధ్య భాగించబడుతుంది. Slot count ను మాత్రమే పెంచితే ప్రతి request ఉంచగల context పరిమాణం తగ్గుతుంది. Per-slot context ను startup log నుంచి చూడండి. దాన్ని ఊహించవద్దు.

vLLM బదులుగా ముందుగానే allocation చేస్తుంది. --gpu-memory-utilization (default 0.92) అనేది "model executor కోసం ఉపయోగించాల్సిన GPU memory fraction". --kv-cache-memory-bytes ను సెట్ చేయనంతవరకు, vLLM ఆ fraction ఆధారంగా KV cache పరిమాణాన్ని అంచనా వేస్తుంది. Weights మరియు engine profile చేసిన working memory కోసం కేటాయింపులను తీసివేసిన తర్వాత budget లో మిగిలిన భాగం paged KV pool అవుతుంది. ఆ pool ఖాళీ అయినప్పుడు scheduler request ను విఫలంగా ముగించకుండా దాన్ని evict చేస్తుంది:

WARNING 05-09 00:49:33 scheduler.py:1057] Sequence group 0 is preempted by PreemptionMode.RECOMPUTE mode because there is not enough KV cache space.

vLLM యొక్క V1 engine లో default preemption mode RECOMPUTE. అందువల్ల evict చేసిన request యొక్క cache తొలగించబడుతుంది. Request మళ్లీ admit అయినప్పుడు దాని prefill మళ్లీ జరుగుతుంది. ఆ పని రెండుసార్లు చేయాల్సి వస్తుంది. "preemption మరియు recomputation end-to-end latency పై ప్రతికూల ప్రభావం చూపవచ్చు" అని documentation హెచ్చరిస్తుంది. Average latency సాధారణంగా కనిపించినప్పటికీ, ఒక user మిగిలిన అందరికంటే చాలా ఎక్కువసేపు ఎందుకు వేచి చూశాడో వివరించే అత్యంత ఉపయోగకరమైన log line ఇదే. Cumulative count ను log చేయడానికి disable_log_stats=False ను సెట్ చేయండి. లేదా vLLM అందించే Prometheus metrics నుంచి preemption counter ను చదవండి.

2, 5 మరియు 20 సమకాలీన వినియోగదారుల వద్ద ఏమి మారుతుంది

ఇద్దరు వినియోగదారులు. అదనపు cache ఉన్న GPUపై ప్రభావం దాదాపు కనిపించదు, ఎందుకంటే రెండవ decode stream మొదటి stream తో పాటు చాలా తక్కువ అదనపు సమయంలోనే నడుస్తుంది. 4 నుంచి 8 GB RAM ఉన్న CPU-only VPSలో ఇది ఉచితం కాదు: రెండు streams ఒకే కొద్దిమంది vCPUలు మరియు అదే RAM bandwidthను పంచుకుంటాయి. అందువల్ల ప్రతి వినియోగదారుకు tokens per second సుమారు సగానికి తగ్గుతుంది. చాలా తక్కువ cache budgetపై cache అవసరం రెండింతలు అవుతుంది.

ఐదుగురు వినియోగదారులు. ఇక్కడ defaults సరిపోవడం ఆగిపోతుంది. సమస్య మొదట queue సమస్యగా కనిపిస్తుంది. OLLAMA_NUM_PARALLEL విలువ 1గా ఉంటే, దీర్ఘమైన సమాధానం అడిగిన వ్యక్తి పూర్తిచేసే వరకు మిగతా నలుగురు వేచి ఉండాలి. అయితే తమ వంతు వచ్చిన వెంటనే ప్రతి ఒక్కరికీ సాధారణ వేగం కనిపిస్తుంది. parallel count పెంచితే సమస్య స్వరూపం మారుతుంది: ఒక్కో slotకు 8K contextతో ఐదు slots కోసం 40K tokens cache అవసరం. ఇది VRAMలో సరిపోకపోతే engine layersను system RAMకు offload చేస్తుంది. అది RAMలో కూడా సరిపోకపోతే server swapను ఉపయోగిస్తుంది, tokens per second తీవ్రంగా పడిపోతుంది.

ఇరవై మంది వినియోగదారులు. chat UIలో ఇరవై మంది వ్యక్తులు సాధారణంగా ఇరవై సమకాలీన requests కారు. Hardware కొనుగోలు చేసే ముందు అర్థం చేసుకోవాల్సిన ముఖ్యమైన విషయం ఇదే. ఒక వ్యక్తి reply చదివి, తదుపరి turnకు ముందు 20 నుంచి 60 seconds ఆలోచిస్తాడు. అందువల్ల వారి sessionలో ఎక్కువ సమయం idleగా ఉంటుంది. ఇరవై agents లేదా ఇరవై document summarisation jobs మాత్రం idle సమయం లేకుండా నడిచే ఇరవై వాస్తవ streams. అది వేరే రకమైన machine. తమ స్వంత Ollama serverకు coding agentను అనుసంధానించిన ఒక developer మొదటి పరిస్థితికన్నా రెండవ పరిస్థితికి దగ్గరగా ఉంటాడు. ఎందుకంటే task నడుస్తున్నంతకాలం agent requests పంపుతూనే ఉంటుంది. మనిషి చదివే సమయంలో ఉండే విరామాలు అందులో ఉండవు.

మీ వినియోగదారులు ఏకకాలంలో అభ్యర్థనలు పంపుతున్నారా, లేక కేవలం login చేసి ఉన్నారా?

ఏదైనా పరిమాణాన్ని నిర్ణయించే ముందు ప్రస్తుతం ప్రాసెస్‌లో ఉన్న అభ్యర్థనలను లెక్కించండి. లెక్కింపు సులభమే: ప్రాసెస్‌లో ఉన్న అభ్యర్థనలు = వినియోగదారుల సంఖ్య × ప్రతి turn కోసం generation కు పట్టే సెకన్లు ÷ turns మధ్య ఉన్న సెకన్లు.

  1. ముందుగా మీ స్వంత single-stream వేగాన్ని కొలవండి. Prefill మరియు decode రెండింటినీ కొలవాలి. మరొకరి card నుంచి సంఖ్యను తీసుకోకండి: మీ స్వంత box లో ప్రతి సెకనుకు tokens ను కొలవండి మరియు వచ్చిన విలువనే ఉపయోగించండి.
  2. Duty cycle ను అంచనా వేయండి. 20 chat వినియోగదారులు, ప్రతి turn కు 12 సెకన్ల generation, ప్రతి 90 సెకన్లకు ఒక turn ఉంటే, 20 * 12 / 90 అవుతుంది. అంటే సుమారు 2.7 requests in flight.
  3. Slot count ను ఆ విలువకు కొద్దిగా ఎక్కువగా సెట్ చేయండి. తరువాత memory తో సరిపోల్చండి: slots × ప్రతి request కు అవసరమైన context, మీ వద్ద వాస్తవంగా ఉన్న cache tokens లోపల సరిపోవాలి.
  4. Queue ను చిన్నగా ఉంచండి. పరిమితి దాటినప్పుడు వైఫల్యం త్వరగా మరియు స్పష్టంగా కనిపించాలి.

అందుబాటులో ఉన్న cache tokens = weights తీసివేసిన తరువాత మిగిలిన free memory ÷ పై section లో పేర్కొన్న ప్రతి token కు అయ్యే ఖర్చు. 8B model ను 16-bit లో నడుపుతున్న 24 GB card, weights కోసం సుమారు 16 GB ఉపయోగిస్తుంది. Default utilisation వద్ద usable cache కోసం గరిష్ఠంగా సుమారు 6 GB మాత్రమే మిగులుతుంది. Working memory కోసం కొంత భాగాన్ని కేటాయించిన తరువాత ఇది మరికొంత తగ్గుతుంది. ఇది సుమారు ఐదు 8K conversations కు సరిపోతుంది. మరిన్ని conversations సరిపెట్టాలంటే ప్రతి request కు context ను తగ్గించండి, లేదా cache ను 8-bit లో నిల్వ చేయండి (llama-server కి --cache-type-k q8_0 అవసరం). రెండింటి వల్ల ఏదో ఒకదాన్ని వదులుకుని concurrency పెరుగుతుంది. Hardware కోసం డబ్బు ఖర్చు చేసే ముందు ఈ trade-off యొక్క వాస్తవ రూపాన్ని చదవడం ఉపయోగకరం: GPU VPS API tokens తో సమాన ఖర్చు స్థాయికి ఎప్పుడు చేరుతుందో తెలుసుకోండి.

Ollama డిఫాల్ట్‌లు సరిపోని సందర్భాలు

Parallel count ను service unit ద్వారా పెంచండి. ఎందుకంటే shell export systemd-managed daemon కు చేరదు.

sudo systemctl edit ollama.service
[Service]
Environment="OLLAMA_NUM_PARALLEL=4"
Environment="OLLAMA_CONTEXT_LENGTH=8192"
Environment="OLLAMA_MAX_QUEUE=64"
sudo systemctl daemon-reload
sudo systemctl restart ollama
systemctl show ollama --property=Environment
ollama ps

systemctl show మీరు ఇప్పుడే సెట్ చేసిన మూడు variables ను ప్రింట్ చేయాలి. అలా కాకపోతే drop-in save కాలేదు. మీరు తరువాత చేసే ఏ పని కూడా ఉపయోగపడదు. ollama ps తరువాత loaded model ను చూపుతుంది. ఆ పరిమాణం weights పరిమాణం కంటే ఎక్కువగా ఉంటుంది. ఎందుకంటే 8,192 tokens ఉన్న నాలుగు slots కోసం వాటి పక్కన 32,768 tokens cache reserve అవుతుంది. మొత్తం model GPUలో ఉండాలని మీరు ఆశించినప్పుడు PROCESSOR column modelలో కొంత భాగం CPUపై ఉందని చూపిస్తే, cardలో మిగిలినదానికంటే ఎక్కువ cache మీరు కోరారు అని అర్థం. ఆ రెండు సంఖ్యల్లో ఒకదాన్ని తగ్గించండి. సాధారణంగా context ను తగ్గించడం సురక్షితమైన ఎంపిక. అయితే window చాలా చిన్నగా ఉంటే error ఇవ్వకుండా పొడవైన prompts ను నిశ్శబ్దంగా truncate చేస్తుంది. అందువల్ల model సరిపోయే వరకు సంఖ్యను తగ్గించడం కంటే num_ctx ను ఉద్దేశపూర్వకంగా పరిమాణం నిర్ణయించడం మంచిది.

Queue default ను మరోసారి పరిశీలించాలి. Ollama గరిష్ఠంగా OLLAMA_MAX_QUEUE requests ను queue చేస్తుంది, మరియు "the default is 512". ఆ పరిమితిని దాటితే "with a 503 error indicating the server is overloaded" అని response ఇస్తుంది. ఒకేసారి నాలుగు requests ను మాత్రమే అందించే serverలో 512 requests లోతైన queue ఉంచడం నిలబెట్టుకోలేని హామీ వంటిది. ఎందుకంటే 300వ స్థానంలో ఉన్న client తన వంతు రాకముందే timeout అవుతుంది. చిన్న queue application retry చేయగల లేదా report చేయగల error ను త్వరగా ఇస్తుంది. ఎప్పటికీ పూర్తికాని spinner కంటే ఇది మెరుగైనది.

నిజమైన పరిస్థితిలో పరీక్షించండి. ఒకే సమయంలో రెండు terminals నుంచి రెండు requests పంపి, రెండింటినీ monitor చేయండి. మొదటి request పూర్తయ్యే వరకు రెండవది ఏ output ఇవ్వకపోతే, parallel setting అమల్లోకి రాలేదు.

తగిన serving engine తన ఖర్చును సమర్థించడం ప్రారంభించే సందర్భం

GPUలో కొంత సామర్థ్యం మిగిలి ఉండి, సుమారు నాలుగు కంటే ఎక్కువ అభ్యర్థనలు నిజంగా ఒకేసారి ప్రాసెస్‌లో ఉన్నప్పుడు vLLM కోసం అదనపు setup సమర్థించబడుతుంది. దీని scheduler ప్రతి token స్థాయిలో పనిచేస్తుంది. దీని cache paged విధానంలో ఉంటుంది కాబట్టి ఖాళీ fragments ను మళ్లీ ఉపయోగించవచ్చు. ఉపయోగించకుండా మిగిలే VRAM ను concurrencyగా మార్చుతుంది. October 2026 నాటికి documented GPU install మరియు launch కు మూడు commands ఉన్నాయి. vLLM startup సమయంలో download చేసి compile చేయాల్సిన precompiled kernels ను vllm download-kernels fetch చేస్తుంది:

uv pip install vllm --torch-backend=auto
vllm download-kernels
vllm serve Qwen/Qwen2.5-1.5B-Instruct
curl http://localhost:8000/v1/chat/completions \
    -H "Content-Type: application/json" \
    -d '{
        "model": "Qwen/Qwen2.5-1.5B-Instruct",
        "messages": [{"role": "user", "content": "Say hello."}]
    }'

choices array ఉన్న reply అంటే server ప్రారంభమై, model load అయిందని అర్థం. Load సమయంలో ముఖ్యమైన రెండు knobs ఇవి: --max-num-seqs, అంటే “ఒక iterationలో ప్రాసెస్ చేయగల sequences గరిష్ఠ సంఖ్య”, మరియు --max-num-batched-tokens, అంటే “ఒక iterationలో ప్రాసెస్ చేయగల tokens గరిష్ఠ సంఖ్య”. మొదటిది concurrencyకి గరిష్ఠ పరిమితి విధిస్తుంది. రెండవది ముందుగా వివరించిన chunked prefill budget.

ఒకేసారి ప్రాసెస్‌లో ఉన్న అభ్యర్థనలు నాలుగు కంటే తక్కువగా ఉంటే, vLLM complexityని పెంచుతుంది కానీ ప్రయోజనం తక్కువగా ఉంటుంది. GPU ఇక అవసరం లేదు. October 2026 నాటికి CPU install guide, x86 మరియు Arm CPUsపై “basic model inferencing and serving” ను document చేస్తోంది. Version 0.17.0 నుంచి prebuilt x86 wheels మరియు ఒక CPU Docker image కూడా అందుబాటులో ఉన్నాయి. అయితే memory వినియోగ విధానం అలాగే ఉంటుంది. CPUపై ఇది system RAMకు అదే 0.92 utilisation fractionను వర్తింపజేస్తుంది. Weights ఉపయోగించిన తర్వాత మిగిలిన memoryని KV cacheకు కేటాయిస్తుంది. అందువల్ల defaultగా startup సమయంలో machine memoryలో ఎక్కువ భాగాన్ని claim చేస్తుంది. --kv-cache-memory-bytes తో cache పరిమాణానికి పరిమితి విధించకపోతే ఇది జరుగుతుంది. 4 నుంచి 8 GB VPSలో ఇది సరైన trade-off కాదు. అక్కడ తక్కువ context ఉన్న చిన్న model మరియు మీరు నియంత్రించే queue ఉత్తమ పరిష్కారం. Ollama మరియు vLLM serving enginesగా ఎలా భిన్నంగా ఉంటాయి ఎంపికను పూర్తిగా వివరిస్తుంది. VPSపై Qwen 3 8Bను నడపడం ఒక్క అదనపు userను చేర్చే ముందు mid-sized modelకు అవసరమయ్యే వనరులను చూపిస్తుంది.

దాచిపెట్టే సాధారణ నమ్మకంలోని రాజీ

Continuous batching మొత్తం throughput ను పెంచుతుంది. క్యూ‌లో ఉన్న అభ్యర్థన త్వరగా ప్రారంభమవుతుంది కాబట్టి median latency కూడా సాధారణంగా మెరుగుపడుతుంది. అయితే tail latency దీనికి విరుద్ధంగా మారుతుంది. ఈ అంశం గురించి చాలా తక్కువగా ప్రస్తావిస్తారు.

ఒక stepలో చేర్చే ప్రతి అదనపు sequence కొంత పనిని జోడిస్తుంది. అందువల్ల batch నిండుతున్నకొద్దీ అందరి ITL పెరుగుతుంది. కొత్తగా వచ్చిన అభ్యర్థనకు prefill అవసరమవుతుంది. దాని కోసం streaming users కు లభించాల్సిన stepలోని కొంత సమయం వినియోగించబడుతుంది. cache pressure ఉన్నప్పుడు scheduler preempt చేస్తుంది. అప్పుడు సగం వరకు రూపొందిన అభ్యర్థనను దాని prefill ప్రారంభానికి తిరిగి పంపుతుంది.

Chat UIలో averages కాకుండా tail latency కనిపిస్తుంది. మొత్తం completion సమయం మంచిగానే ఉన్నా, వాక్యం మధ్యలో stream రెండు seconds ఆగితే అది విఫలమైనట్లుగా అనిపిస్తుంది. మీరు ఆశించే load కింద p95 TTFT మరియు p95 ITL ను కొలవండి. Mean tokens per second ను అనుభవం యొక్క వివరణగా కాకుండా capacity సంఖ్యగా పరిగణించండి.

దీనినిబట్టి ఆచరణాత్మక setting నిర్ణయించాలి. Memory అనుమతించే పరిమితికి కొద్దిగా తక్కువగా concurrencyని cap చేయండి. అప్పుడు engine కు preempt చేయాల్సిన అవసరం ఉండదు. లోతైన batchలో thrash జరగడం కంటే, చిన్నదిగా మరియు ఊహించగలిగే queue మెరుగైనది. ఎందుకంటే నాలుగు seconds వేచి ఉన్న తర్వాత సజావుగా stream అయ్యే అనుభవం, వెంటనే ప్రారంభమై రెండుసార్లు ఆగిపోయే అనుభవం కంటే వినియోగదారుకు మెరుగ్గా ఉంటుంది.

నెమ్మదిగా ఉన్నప్పుడు పరిశీలించాల్సినవి

ప్రతి వినియోగదారుడి అభ్యర్థన సాధారణంగానే ఉంది, కానీ వేచి ఉండే సమయం ఎక్కువగా ఉంది. ఇది వేగ సమస్య కాదు; ఇది queue సమస్య. ముందుగా parallel setting ను పరిశీలించండి. Model సరిగ్గా సేవలు అందిస్తోంది, కానీ ఒకేసారి ఒక్క request మాత్రమే ప్రాసెస్ చేస్తోంది.

Ollama నుంచి HTTP 503 వస్తోంది. Queue నిండిపోయింది. Server నిజంగా తన capacity ను చేరి ఉండవచ్చు. లేదా load ను తగ్గించడానికి OLLAMA_MAX_QUEUE విలువను ఉద్దేశపూర్వకంగా తక్కువగా ఉంచి ఉండవచ్చు. ఆ setting ఉద్దేశించిన పని ఇదే.

CPU server పై load పెరిగినప్పుడు tokens per second గణనీయంగా తగ్గుతోంది. ఇది జరుగుతున్నప్పుడు vmstat 1 ను అమలు చేయండి. si మరియు so columns లో nonzero విలువలు ఉంటే machine swapping చేస్తోంది. అంటే ప్రతి token కోసం weights ను disk నుంచి చదువుతోంది. దీనిని configuration మార్పుతో పరిష్కరించలేరు. Model size లేదా slot count ను తగ్గించండి.

పది మంది వినియోగదారుల్లో ఒకరు మిగిలిన వారికంటే చాలా ఎక్కువసేపు వేచి ఉంటున్నారు. vLLM log లో preempted కోసం search చేయండి. సాధారణంగా preemption మరియు దాని recompute దీనికి కారణమవుతాయి. మీరు అనుమతించిన context length కు cache oversubscribed అయిందని దీని అర్థం.

Server idle గా ఉన్నప్పటికీ TTFT సరిగా లేదు. ఇది concurrency సమస్య కాదు; ఇది prefill సమస్య. మొదటి token కనిపించే ముందు long prompts కు వాస్తవ సమయం పడుతుంది. అందువల్ల hardware ను పరిశీలించే ముందు prompt size మరియు prefix caching ను పరిశీలించండి. Quiet stretch తర్వాత తిరిగి వచ్చిన మొదటి వ్యక్తికే ఎక్కువ wait కనిపించి, అతని తర్వాత అందరికీ సాధారణంగా ఉంటే, అది prefill కాదు. Ollama model ను unload చేసి, weights ను మళ్లీ disk నుంచి చదువుతూ ఉండవచ్చు. దీన్ని requests మధ్య model ను resident గా ఉంచడం ద్వారా నిర్ధారించండి.

FAQ

నా self-hosted LLMను రెండో వ్యక్తి ఉపయోగించినప్పుడు అది ఎందుకు నెమ్మదిస్తుంది?

చాలా సందర్భాల్లో అది నిజంగా నెమ్మదించదు. అభ్యర్థనలు queueలో వేచి ఉంటాయి. Ollamaలో OLLAMA_NUM_PARALLEL డిఫాల్ట్‌గా 1గా ఉంటుంది. అందువల్ల రెండో అభ్యర్థనకు, మొదటి అభ్యర్థన చివరి tokenను విడుదల చేసే వరకు వేచి ఉండాలి. ఒకరు streamను ఉపయోగిస్తున్నప్పుడు, మరొకరు వేచి ఉన్న పరిస్థితిలో సమయాన్ని కొలిచి ఈ రెండు పరిస్థితులను వేరు చేయండి: రెండో stream ప్రారంభమైన తర్వాత దాని tokens per second సాధారణంగా ఉంటే, అది queue సమస్య. parallel count పెంచడం ద్వారా దాన్ని పరిష్కరించవచ్చు. రెండు streams సగం వేగంతో నడిస్తే, memory bandwidth నిజంగా పంచబడుతోంది. అది hardware పరిమితి.

ఒక చిన్న GPU ఎన్ని concurrent usersకు సేవలు అందించగలదు?

users సంఖ్యను కాదు, memoryని లెక్కించండి. ముందుగా weightsను లెక్కించాలి. తరువాత KV cacheను లెక్కించాలి. ప్రతి active conversationలో ప్రతి tokenకు దాని ఖర్చు 2 times layers times key/value heads times head dimension times bytes. సాధారణ 8B modelలో 36 layers, 8 key/value heads, head dimension 128 ఉంటే, 16-bitలో ప్రతి tokenకు సుమారు 144 KiB అవసరం. అందువల్ల 8,192 tokenల conversationకు సుమారు 1.2 GB అవసరం. ఆ modelను 16-bitలో ఉంచిన 24 GB cardలో cache కోసం గరిష్ఠంగా సుమారు 6 GB మాత్రమే మిగులుతుంది. ఇది full contextతో సుమారు ఐదు conversationsకు సరిపోతుంది. contextను తగ్గిస్తే మరిన్ని conversationsను నిర్వహించవచ్చు.

continuous batching వల్ల ప్రతి user reply నెమ్మదిస్తుందా?

సాధారణంగా median latency మెరుగుపడుతుంది. ఎందుకంటే requests మొత్తం batch పూర్తయ్యే వరకు వేచి ఉండవు. అయితే tail latency పెరుగుతుంది. ప్రతి అదనపు sequence ప్రతి decoding stepలో అదనపు పనిని కలుపుతుంది. కొత్త request రావడం వల్ల streaming users కోసం ఒక stepలోని కొంత సమయం తగ్గుతుంది. preempt చేసిన requestకు రెండుసార్లు prefill చేయాల్సి ఉంటుంది. averageను మాత్రమే కాకుండా p95 inter-token latencyను కొలవండి. average దాచే విరామాలు chat windowలో స్పష్టంగా కనిపిస్తాయి.

నేను OLLAMA_NUM_PARALLELను పెంచాలా లేదా vLLMకు మారాలా?

మొదట parallel countను పెంచండి. దీనికి అదనపు ఖర్చు లేదు. ఒక drop-in fileతో ఇది పూర్తవుతుంది. ఒకరు ఇచ్చే దీర్ఘ సమాధానం వెనుక నలుగురు queueలో వేచి ఉండే సాధారణ పరిస్థితిని ఇది పరిష్కరిస్తుంది. పరిమితి memory. parallel requests మీరు నిల్వ చేయాల్సిన context పరిమాణాన్ని అనేక రెట్లు పెంచుతాయి. అందువల్ల layers CPUకి spill అవుతున్నాయా అని monitor చేయండి. మీ GPUలో తగినంత VRAM అందుబాటులో ఉండి, నిజంగా నాలుగు కంటే ఎక్కువ requests ఒకేసారి in flightలో ఉన్నప్పుడు vLLMకు మారండి. ఆ స్థాయిలో paged cache, per-token scheduling వాటి ఖర్చుకంటే ఎక్కువ ప్రయోజనం ఇస్తాయి.

ఎక్కువ CPU cores వల్ల నెమ్మదిగా ఉన్న LLM server వేగవంతమవుతుందా?

users ఎక్కువగా గమనించే భాగానికి సాధారణంగా కాదు. ప్రతి token కోసం decode మొత్తం modelను memory నుంచి చదువుతుంది. అందువల్ల అది RAM bandwidthపై ఆధారపడి ఉంటుంది. bandwidth పూర్తిగా వినియోగమైన తర్వాత అదనపు cores ఉపయోగపడవు. అయితే prefill coresతో scale అవుతుంది. కాబట్టి cores పెంచితే దీర్ఘ promptsలో first token వచ్చే సమయం తగ్గుతుంది. 4 నుంచి 8 GB VPSలో సాధారణంగా ప్రధాన పరిమితి memory capacity. అందువల్ల ఎక్కువ vCPUs కంటే చిన్న model లేదా తక్కువ context ఉపయోగించడం సమర్థవంతమైన పరిష్కారం.

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