KV cache మరియు prompt cache మధ్య తేడాలు ఏమిటి?
KV cache అనేది మీ సర్వర్ RAM వినియోగానికి సంబంధించినది, ఇది అయిపోతే మోడల్ లోడ్ అవ్వదు. Prompt cache అనేది బిల్లింగ్ తగ్గించే ఫీచర్. వీటి మధ్య ఉన్న కీలక వ్యత్యాసాలను ఇక్కడ తెలుసుకోండి.
KV cache మరియు prompt cache: క్లుప్త సమాధానం
KV cache మరియు ప్రొవైడర్ యొక్క prompt cache రెండింటిలోనూ 'cache' అనే పదం ఉన్నప్పటికీ, వాటి మధ్య పెద్దగా పోలిక లేదు. KV cache అనేది ప్రతి అభ్యర్థనకు (request) సంబంధించిన వర్కింగ్ మెమరీ. ఇది ఒక అభ్యర్థన జరుగుతున్నంత సేపు మీ సర్వర్ యొక్క RAM లేదా VRAM లో ఉంటుంది. అభ్యర్థన యొక్క context నిడివిని బట్టి మరియు మీరు ఒకేసారి ఎన్ని అభ్యర్థనలను రన్ చేస్తున్నారనే దానిపై ఇది పెరుగుతుంది. ప్రొవైడర్ prompt caching అనేది బిల్లింగ్ మరియు latency కి సంబంధించిన ఫీచర్. మీ ప్రాంప్ట్లోని స్థిరమైన ప్రిఫిక్స్ను ప్రొవైడర్ సర్వర్లలో భద్రపరుస్తారు, మీరు దానిని మళ్ళీ పంపినప్పుడు తక్కువ ధరకే ఛార్జ్ చేస్తారు.
ఒకటి మీరు హార్డ్వేర్గా కొనుగోలు చేసే మెమరీ. మరొకటి వేరొకరు నిల్వ చేసి, దాని కోసం మీ నుండి అద్దె వసూలు చేసే మెమరీ.
వీటి నిర్వచనాల కంటే ఆచరణాత్మక వ్యత్యాసం చాలా ముఖ్యం. KV cache అయిపోవచ్చు, అలా జరిగినప్పుడు మోడల్ లోడ్ అవ్వదు లేదా అభ్యర్థన తిరస్కరించబడుతుంది. మీరు prompt cache ను ఎప్పటికీ ఖాళీ చేయలేరు. మీరు దానిని సరిగ్గా ఉపయోగించుకోవడంలో విఫలమైతే, అదనపు ధర చెల్లించాల్సి వస్తుంది అంతే.
KV cache దేనిని కలిగి ఉంటుంది మరియు అది ఎందుకు అవసరం
ఒక transformer మోడల్ 500వ టోకెన్ను జనరేట్ చేస్తున్నప్పుడు, దానికి ముందున్న 499 టోకెన్లన్నింటినీ పరిగణనలోకి తీసుకోవాలి. ఆ ప్రతి టోకెన్ కోసం, ప్రతి లేయర్కు ఒక key vector మరియు value vector అవసరం. ప్రతి కొత్త టోకెన్ కోసం వీటిని మళ్లీ మళ్లీ లెక్కిస్తే, జనరేషన్ సమయం టోకెన్ల సంఖ్య యొక్క వర్గానికి (square of the length) అనుగుణంగా పెరుగుతుంది. అందుకే runtime వీటిని భద్రపరుస్తుంది. ఈ నిల్వనే KV cache (key/value cache) అంటారు.
ఇది ప్రతి అభ్యర్థనకు (request) ప్రత్యేకమైన స్థితి, ఎందుకంటే ఇది ఆ అభ్యర్థనలోని ఖచ్చితమైన టోకెన్ క్రమం ఆధారంగా నిర్మించబడుతుంది. ఇద్దరు వినియోగదారులు వేర్వేరు ప్రాంప్ట్లను పంపినప్పుడు వారు దీనిని పంచుకోలేరు. అయితే, runtime లో prefix caching అనే ప్రత్యేక ఫీచర్ ఉంటే అది వేరు, దీని గురించి తర్వాత వివరిస్తాము.
సర్వింగ్ రెండు దశల్లో జరుగుతుంది. Prefill దశలో మీ పూర్తి ప్రాంప్ట్ను చదివి cache ను నింపుతుంది, ఇది కంప్యూటింగ్ సామర్థ్యంపై ఆధారపడి ఉంటుంది. Decode దశలో ఒకసారి ఒక టోకెన్ను ఉత్పత్తి చేసి cache కు జోడిస్తుంది, ఇది మెమరీ బ్యాండ్విడ్త్పై ఆధారపడి ఉంటుంది. ఈ విభజన వల్లే ప్రాంప్ట్ ప్రాసెసింగ్ మరియు టోకెన్ జనరేషన్ వేగాలు భిన్నంగా ఉంటాయి, అందుకే మీరు మీ సొంత సర్వర్లో టోకెన్ల వేగాన్ని కొలిచినప్పుడు ఈ తేడా కనిపిస్తుంది.
KV cache ఎంత మెమరీని ఉపయోగిస్తుంది?
వెండర్ టేబుల్ కోసం వెతకాల్సిన అవసరం లేదు. దీని పరిమాణాన్ని ఏ మోడల్కైనా మీరు తిరిగి లెక్కించవచ్చు:
bytes per token = 2 * layers * kv_heads * head_dim * bytes per element2 అనేది key మరియు value లను సూచిస్తుంది. మిగిలిన ప్రతి సంఖ్య మోడల్ యొక్క config.json నుండి వస్తుంది, ఇది మోడల్ యొక్క Hugging Face పేజీలో ప్రచురించబడుతుంది.
Llama 3.1 8B ని ఉదాహరణగా తీసుకుందాం. దీని కాన్ఫిగరేషన్లో num_hidden_layers 32 మరియు num_key_value_heads 8 అని ఉంటుంది. 4096 యొక్క hidden_size ను 32 attention heads కు పంపిణీ చేస్తే, head dimension 128 వస్తుంది. f16 వద్ద ప్రతి ఎలిమెంట్ 2 bytes ఉంటుంది:
2 * 32 * 8 * 128 * 2 = 131072 bytes = 128 KiB per tokenదీనిని మీరు అడిగే context తో, ఆపై మీరు ఒకేసారి రన్ చేసే requests తో గుణించండి.
ఈ చార్ట్ వెనుక ఉన్న డేటా
[
{
"label": "2k context",
"one_request_gib": 0.25,
"four_requests_gib": 1
},
{
"label": "8k context",
"one_request_gib": 1,
"four_requests_gib": 4
},
{
"label": "32k context",
"one_request_gib": 4,
"four_requests_gib": 16
},
{
"label": "128k context",
"one_request_gib": 16,
"four_requests_gib": 64
}
]8k context వద్ద cache 1 GiB ఉంటుంది. 32k వద్ద ఇది 4 GiB ఉంటుంది, ఇది 4-bit weights పరిమాణంతో సమానంగా ఉంటుంది. మోడల్ యొక్క పూర్తి 128k context వద్ద, ఒక request కోసం ఇది 16 GiB ఉంటుంది, మరియు నాలుగు requests ఒక్కొక్కటిగా దీనిని నింపితే 64 GiB అవుతుంది. Weights మారవు, కేవలం cache మాత్రమే మారుతుంది.
Grouped query attention (GQA) ఈ సంఖ్యలో కీలక పాత్ర పోషిస్తుంది. Llama 3.1 8B లో 32 query heads కు సేవలు అందించడానికి 8 key/value heads ఉన్నాయి, కాబట్టి నాలుగు query heads ఒకే నిల్వ చేయబడిన key/value pair ను పంచుకుంటాయి. ఒక మోడల్ యొక్క num_key_value_heads దాని num_attention_heads కు సమానంగా ఉంటే, అదే పారామీటర్ సంఖ్య వద్ద అది నాలుగు రెట్లు ఎక్కువ cache ను ఉపయోగిస్తుంది. రెండు 8B మోడల్స్ సర్వ్ చేయడానికి ఒకే ఖర్చు అవుతుందని భావించే ముందు ఆ ఒక్క ఫీల్డ్ను తప్పకుండా తనిఖీ చేయండి.
2k వద్ద పనిచేసిన model 32k వద్ద load కావడానికి ఎందుకు నిరాకరిస్తుంది
model load అవుతున్నప్పుడు runtime KV cache కోసం memoryని reserve చేస్తుంది. ఈ పరిమాణం మీరు వాస్తవంగా పంపే prompt ఆధారంగా కాకుండా, configure చేసిన context length ఆధారంగా నిర్ణయించబడుతుంది. Ollama యొక్క default ఇక ఒకే సంఖ్య కాదు. October 2026 నాటికి, దాని context length documentation VRAM ఆధారంగా విలువను నిర్ణయిస్తుంది: 24 GiB కంటే తక్కువ ఉన్న machines పై 4k, 24 మరియు 48 GiB మధ్య ఉన్న machines పై 32k, 48 GiB లేదా అంతకంటే ఎక్కువ ఉన్న machines పై 256k. Cloud models కోసం default వాటి గరిష్ఠ విలువగా ఉంటుంది. CPU-only VPS లేదా చిన్న GPU 4kతో ప్రారంభమవుతుంది. దాన్ని 32kకు పెంచితే, ఒక్క token కూడా రాకముందే అదనంగా 4 GiB allocation అవసరమని మీరు runtimeను కోరినట్లవుతుంది. 24 GiB cardపై 32k ఇప్పటికే defaultగా ఉంటుంది. కాబట్టి మీరు ప్రత్యేకంగా అడగకపోయినా ఆ reservation జరుగుతుంది.
OLLAMA_CONTEXT_LENGTH=32768 ollama serveInteractive prompt నుంచి ప్రతి sessionకు ఇదే setting:
ollama run llama3.1:8b
/set parameter num_ctx 32768ప్రతి stackలో failure భిన్నంగా కనిపిస్తుంది. vLLM startup సమయంలో ఈ లెక్కను తనిఖీ చేసి, run కావడానికి నిరాకరిస్తుంది:
ValueError: To serve at least one request with the model's max seq len (131072), (16.0 GiB KV cache is needed, which is larger than the available KV cache memory (9.56 GiB). Based on the available memory, the estimated maximum model length is 78336. Try increasing `gpu_memory_utilization` (which also controls CPU memory on the CPU backend) or decreasing `max_model_len` when initializing the engine. See https://docs.vllm.ai/en/latest/configuration/conserving_memory/ for more details.Ollama లేదా llama.cpp నడుస్తున్న CPU-only VPSలో allocation సాధారణ system RAMలో జరుగుతుంది. RAM కొరత startup సమయంలో గుర్తించబడకపోవచ్చు. బదులుగా kernel యొక్క out-of-memory killer ఆ processను terminate చేస్తుంది. దీనికి సంబంధించిన ఆధారాన్ని kernel ring bufferలో చూడవచ్చు:
dmesg -T | grep -i "killed process"మీ serving process పేరును చూపించే line, ఆ machine వద్ద అందుబాటులో ఉన్నదానికంటే ఎక్కువ memory అవసరమని సూచిస్తుంది. పరిష్కారం పెద్ద swap file కాదు; చిన్న contextను ఉపయోగించాలి. Diskకు paged చేసిన KV cacheను ప్రతి generated token సమయంలో చదవాలి. అందువల్ల generation ఉపయోగించలేనంత నెమ్మదిగా మారుతుంది. సరైన విలువను ఎంచుకునే విధానం Ollamaలో num_ctx మరియు context length పై మా guideలో ఉంది.
కన్కరెన్సీ సంఖ్యపై చూపే ప్రభావం
ప్రతి ఇన్-ఫ్లైట్ అభ్యర్థన (in-flight request) తన సొంత KV cache ను కలిగి ఉంటుంది. కెపాసిటీ ప్లానింగ్లో చాలామంది విస్మరించే అంశం ఇదే. 32k కాంటెక్స్ట్ను కలిగి ఉన్న నలుగురు వినియోగదారులకు, మోడల్ వెయిట్స్తో పాటు అదనంగా 16 GiB మెమరీ అవసరమవుతుంది.
ఈ విషయంలో రన్టైమ్ల మధ్య వ్యత్యాసాలు ఉన్నాయి. Ollama మరియు llama.cpp మోడల్ లోడ్ అయినప్పుడే మీరు కోరిన కాంటెక్స్ట్ను రిజర్వ్ చేస్తాయి, కాబట్టి ఎవరైనా వాడుతున్నా లేకపోయినా ఆ మెమరీ కేటాయించబడుతుంది. vLLM పూల్ను స్థిరమైన పరిమాణం గల బ్లాకులుగా విభజించి, ప్రతి అభ్యర్థన పెరిగే కొద్దీ వాటిని కేటాయిస్తుంది; కాబట్టి 500-token అభ్యర్థన కేవలం 500 టోకెన్లకు సరిపడా స్థలాన్ని మాత్రమే తీసుకుంటుంది. ఏది ఏమైనప్పటికీ, ఈ పూల్ పరిమితమైనది. అది నిండిపోయిన తర్వాత, కొత్త అభ్యర్థనలు రన్ అవ్వడానికి బదులుగా క్యూలో (queue) వేచి ఉంటాయి. ఆ క్యూయింగ్ రెస్పాన్స్ టైమ్స్పై ఎలాంటి ప్రభావం చూపుతుందో ఒక self-hosted LLM ఎంతమంది ఏకకాల వినియోగదారులకు సేవ అందించగలదు అనే విభాగంలో వివరించబడింది.
KV cache పరిమాణాన్ని తగ్గించడానికి నాలుగు మార్గాలు
- Context length ను తగ్గించండి. ఇది అత్యంత ప్రభావవంతమైన మార్గం మరియు సాధారణంగా తక్కువ ఖర్చుతో కూడుకున్నది. చాలా వరకు చాట్ వర్క్లోడ్లు 32k పరిమితికి చేరుకోవు.
- Cache ను Quantise చేయండి. Ollama యొక్క
OLLAMA_KV_CACHE_TYPEడిఫాల్ట్గాf16ని ఉపయోగిస్తుంది మరియుq8_0ని అనుమతిస్తుంది, ఇది సుమారు సగం మెమరీని మాత్రమే వాడుకుంటుంది. అలాగేq4_0ని ఉపయోగిస్తే పావు వంతు మెమరీ సరిపోతుంది. llama.cpp లో దీనికి సమానమైనవి-ctk q8_0మరియు-ctv q8_0. - తక్కువ key/value heads లేదా తక్కువ layers ఉన్న మోడల్ను ఎంచుకోండి. 40 GB బరువున్న ఫైళ్లను డౌన్లోడ్ చేసే ముందు
config.jsonని చదవండి. - ఒకేసారి తక్కువ అభ్యర్థనలను (requests) సర్వ్ చేయండి మరియు మిగిలిన వాటిని క్యూ (queue) లో ఉంచండి.
q4_0 వద్ద Llama 3.1 8B గణాంకం ప్రతి token కు 128 KiB నుండి సుమారు 32 KiB కి పడిపోతుంది. కాబట్టి 32k context కోసం 4 GiB కి బదులుగా సుమారు 1 GiB ఖర్చవుతుంది. ఈ ఆదా ఉచితం కాదు. Key మరియు value లు తక్కువ precision తో నిల్వ చేయబడతాయి, కాబట్టి మీరు దీన్ని ఖాయం చేసుకునే ముందు మీ స్వంత ప్రాంప్ట్లపై అవుట్పుట్ను సరిపోల్చి చూడండి.
Provider prompt caching ద్వారా వాస్తవంగా లభించేది
Provider prompt caching అనేది వేరే ఉత్పత్తి. ఇందులో లెక్కించే ప్రమాణం కూడా వేరుగా ఉంటుంది. స్థిరంగా ఉండే prefix ను మీరు గుర్తిస్తే, provider దాన్ని నిల్వ చేస్తుంది. తరువాత అదే prefix ను అచ్చుగా పునరావృతం చేసే calls కు పూర్తి input ధరకు బదులుగా తగ్గించిన రేటుతో బిల్లింగ్ జరుగుతుంది.
October 2026 నాటికి Anthropic ప్రచురించిన multipliers ఇవి: 5-minute cache write కు base input token ధరకు 1.25 రెట్లు ఖర్చవుతుంది. 1-hour write కు 2 రెట్లు ఖర్చవుతుంది. చాలా models లో cache read కు 0.1 రెట్లు ఖర్చవుతుంది. తాజా models లో read ధర ఇంకా తక్కువగా ఉంటుంది: Claude Opus 5.5 మరియు Sonnet 5.5 పై 0.05 రెట్లు, Claude Fable 5.1 మరియు Mythos 5.1 పై 0.025 రెట్లు. ప్రామాణిక సంఖ్యలతో 20,000-token system prompt ను cache వెనుక ఉంచితే, ఈ విధానం ఎలా పనిచేస్తుందో స్పష్టమవుతుంది.
ఈ చార్ట్ వెనుక ఉన్న డేటా
[
{
"label": "No caching, every call",
"billed_token_equivalents": "20,000"
},
{
"label": "First call, 5 minute cache write",
"billed_token_equivalents": "25,000"
},
{
"label": "First call, 1 hour cache write",
"billed_token_equivalents": "40,000"
},
{
"label": "Every later call, cache hit",
"billed_token_equivalents": "2,000"
}
]దీన్ని arithmetic గా చూడండి. మొదటి call లో 5-minute write premium 5,000 token equivalents: uncached గా పంపితే 20,000 అయ్యే బిల్లింగ్కు బదులుగా 25,000. ఆ window లోని ప్రతి తదుపరి call కు 20,000 బదులుగా 2,000 బిల్ అవుతుంది. అంటే 18,000 token equivalents ఆదా అవుతాయి. అందువల్ల 5-minute cache రెండో call నుంచే లాభదాయకంగా ఉంటుంది.
1-hour cache వేరే నిర్ణయం. write సమయంలో 40,000 బిల్ అవుతుంది. అంటే 20,000 token equivalents అదనపు ఖర్చవుతుంది. కాబట్టి ఒక గంటలో రెండు hits వచ్చిన తరువాతే అది లాభదాయకమవుతుంది. ఇది model కు సంబంధించిన విషయం కాదు; మీ traffic pattern కు సంబంధించిన విషయం. Window ను ఎలా ఎంచుకోవాలో సహా పూర్తి లెక్క Claude prompt caching కోసం break-even math లో ఉంది.
మీకు cache hit లభిస్తుందా లేదా అనేది రెండు వివరాలు నిర్ణయిస్తాయి. మొదటిది, model నిర్దేశించిన కనిష్ఠ పొడవుకంటే చిన్న prefix ను నిశ్శబ్దంగా cache చేయరు. October 2026 నాటికి documentation ప్రకారం Claude Opus 5, Opus 5.5 మరియు Sonnet 5.5 కు కనిష్ఠ పరిమాణం 512 tokens. Claude Sonnet 5 కు అది 1,024 tokens. అంతకంటే చిన్న request సాధారణంగా process అవుతుంది; error తిరిగి ఇవ్వరు. రెండవది, entry ను write చేసే లేదా read చేసే request ప్రారంభమైన సమయం నుంచి lifetime లెక్కించబడుతుంది. ప్రతి read అదనపు ఖర్చు లేకుండా lifetime ను మళ్లీ ప్రారంభిస్తుంది. అందువల్ల busy endpoint 5-minute cache ను నిరవధికంగా సజీవంగా ఉంచగలదు. ప్రతి పది నిమిషాలకు ఒకసారి మాత్రమే పిలవబడే endpoint ప్రతిసారీ write premium చెల్లిస్తుంది, కానీ ఎప్పుడూ cache read పొందదు.
ఊహించకుండా response ను తనిఖీ చేయండి. usage object cache_creation_input_tokens మరియు cache_read_input_tokens ను report చేస్తుంది. ప్రతి call లో read count సున్నాగా ఉంటే, మీరు writes కోసం చెల్లిస్తున్నారు, కానీ దాని నుంచి ఏ ప్రయోజనం పొందడం లేదు.
రెండు cacheలు కలిసే స్థానం
పొడవైన system prompt అనేది ఈ రెండు cache విధానాలు కలిసే స్థానం. దీనికి రెండువైపులా ఒకేసారి ఖర్చు చెల్లించాలి.
స్థానికంగా, f16 వద్ద Llama 3.1 8B serverలో 20,000-token system prompt సుమారు 2.4 GiB KV cacheను ఆక్రమిస్తుంది. దాన్ని కలిగి ఉన్న ప్రతి concurrent requestకు ఈ cache విడిగా అవసరం అవుతుంది. Remoteగా, అదే prefixకు మొదటి సారి ఒక cache write అవసరం. తరువాతి ప్రతి callలో input ఖర్చులో 0.1 రెట్లు మాత్రమే ఖర్చవుతుంది; కొత్త modelsలో ఇది ఇంకా తక్కువగా ఉండవచ్చు. స్థానిక ఖర్చు మీ users సంఖ్యతో పెరుగుతుంది. Remote ఖర్చు మీ trafficతో పెరుగుతుంది. మీరు idleగా ఉన్నప్పుడు అది reset అవుతుంది.
Provider prompt cachingలా కనిపించే ఒక local feature ఉంది. దాన్ని తరచుగా దానితో కలిపి భావిస్తారు: prefix caching. vLLM documentation automatic prefix cachingను ఇలా వివరిస్తుంది: “ఇప్పటికే ఉన్న queries యొక్క KV cacheను cache చేయడం. అందువల్ల కొత్త queryకు, ఇప్పటికే ఉన్న queriesలో ఒకదానితో అదే prefix ఉంటే, ఆ KV cacheను నేరుగా తిరిగి ఉపయోగించవచ్చు.” ప్రస్తుత vLLMలో ఇది defaultగా enabledగా ఉంటుంది. llama.cpp serverలో ప్రతి slotకు prompt cache defaultగా ఉంటుంది. --cache-reuse N అది తిరిగి ఉపయోగించడానికి ప్రయత్నించే కనిష్ఠ chunk పరిమాణాన్ని నిర్దేశిస్తుంది.
Prefix caching వల్ల prefill compute ఆదా అవుతుంది. మీ 20,000-token system prompt ప్రతి requestలో మళ్లీ process చేయకుండా ఒక్కసారి మాత్రమే process అవుతుంది. దీంతో మొదటి token వచ్చే సమయం గణనీయంగా తగ్గుతుంది. vLLMలో shared blocksను duplicate చేయకుండా తిరిగి ఉపయోగిస్తారు. అందువల్ల memory వినియోగం కూడా మెరుగుపడుతుంది. అయితే ప్రస్తుతం liveగా ఉన్న tokens కోసం మీరు తప్పనిసరిగా ఉంచాల్సిన cache పరిమాణాన్ని ఇది ఎప్పుడూ తగ్గించదు. Requests మధ్య weightsను residentగా ఉంచడం దీనికి సంబంధం ఉన్నప్పటికీ వేరే విధానం. దీని గురించి requests మధ్య Ollama modelను loadedగా ఉంచడం లో వివరించారు.
మీ స్వంత బాక్స్లో ఏమి కొలవాలి
మీ లక్ష్య context వద్ద modelను load చేసి, estimateను నమ్మకుండా వాస్తవ సంఖ్యలను చదవండి.
ollama ps
nvidia-smi --query-gpu=memory.used,memory.total --format=csv
free -gollama ps load చేసిన modelను దాని size, load చేసిన context, అలాగే అది GPUపై లేదా CPUపై నడుస్తుందా అనే వివరాలతో చూపిస్తుంది. ముందుగా context columnను పరిశీలించండి, ఎందుకంటే default ఇప్పుడు మీ VRAMపై ఆధారపడి ఉంటుంది. పూర్తిగా GPUపై ఉండాలని మీరు భావించిన modelలో CPU split కనిపిస్తే, KV cacheలో కొంత భాగాన్ని బయటకు నెట్టిందని అర్థం. అందువల్ల generation speed తగ్గుతుంది. nvidia-smi నిజమైన VRAM సంఖ్యను ఇస్తుంది. CPU-only VPSలో free -g అదే పని చేస్తుంది. Contextను దశలవారీగా పెంచి, మళ్లీ load చేసి, సంఖ్య ఎలా మారుతుందో గమనించండి. మీ లెక్కలు మరియు చూపించిన సంఖ్య దాదాపు సమానంగా ఉండాలి. అవి సరిపోకపోతే, ఆ తేడా సాధారణంగా formulaలోని లోపం కాదు; runtime ఉపయోగించే స్వంత compute buffers కారణంగా ఉంటుంది.
ఆ సంఖ్యల ఆధారంగా మీరు అద్దెకు తీసుకోవాలనిపించని hardware వైపు మొగ్గితే, ప్రతి tokenకు చెల్లించడంతో పోలికను GPU VPS మరియు API tokensలో వివరించాం.
FAQ
KV cache prompt cachingతో సమానమేనా?
కాదు. KV cache అనేది serving process లో ప్రతి requestకు సంబంధించిన memory. ప్రస్తుత contextలోని ప్రతి token కోసం key మరియు value vectors ను ఇది ఉంచుతుంది. ఇది మీ RAM లేదా VRAMలో ఉంటుంది. Request ముగిసినప్పుడు ఇది విడుదల అవుతుంది. Provider prompt caching అనేది billing feature. ఇది provider infrastructureలో స్థిరమైన prompt prefixను నిల్వ చేసి, అదే prefixను మళ్లీ పంపినప్పుడు తక్కువ రుసుము వసూలు చేస్తుంది. KV cache అయిపోతే model load కాదు. Prompt cache లేకపోతే invoice మరియు first token వచ్చే సమయం మాత్రమే పెరుగుతాయి.
2k context వద్ద model load అవుతుంది, కానీ 32k వద్ద ఎందుకు విఫలమవుతుంది?
Runtime load సమయంలో మొత్తం KV cacheను allocate చేస్తుంది. ఇది మీరు పంపే prompt పరిమాణం ఆధారంగా కాకుండా, మీరు configure చేసిన context length ఆధారంగా పరిమాణాన్ని నిర్ణయిస్తుంది. f16లో Llama 3.1 8B కోసం ప్రతి tokenకు cache 128 KiB ఉంటుంది. అందువల్ల 2k contextకు 0.25 GiB, 32k contextకు 4 GiB అవసరం. రెండు సందర్భాల్లోనూ weights memoryలో సరిపోతాయి. విఫలమయ్యేది memory reservation. vLLM దీన్ని ValueErrorగా report చేస్తుంది. అందులో అవసరమైన KV cache memory, అందుబాటులో ఉన్న memory, estimated maximum model length చూపిస్తుంది. అలాగే gpu_memory_utilization పెంచాలని లేదా max_model_len తగ్గించాలని సూచిస్తుంది. Ollama లేదా llama.cpp నడుస్తున్న CPU-only boxలో kernel out-of-memory killer processను terminate చేయవచ్చు. దీన్ని dmesg -T | grep -i "killed process"తో నిర్ధారించవచ్చు.
నా model కోసం KV cache పరిమాణాన్ని ఎలా లెక్కించాలి?
2ను layer count, key/value heads సంఖ్య, head dimension, bytes per elementతో గుణించండి. ఫలితం ప్రతి tokenకు అవసరమైన bytes. తరువాత దాన్ని మీ context lengthతో, concurrent requests సంఖ్యతో గుణించండి. Layer మరియు head countsను model యొక్క config.json నుంచి తీసుకోండి. f16 లేదా bf16 కోసం ప్రతి elementకు 2 bytes ఉపయోగించండి. q8_0 cache దాదాపు దాని సగం ఉంటుంది. q4_0 cache దాదాపు దాని పావు ఉంటుంది.
Prompt caching వల్ల నా స్వంత serverకు అవసరమైన memory తగ్గుతుందా?
Provider prompt caching మీ hardwareపై ఎలాంటి ప్రభావం చూపదు. ఎందుకంటే storage provider వైపే ఉంటుంది. Local equivalentను prefix caching అంటారు. దీన్ని vLLM మరియు llama.cpp server రెండూ అందిస్తాయి. Shared prefix కోసం ఇప్పటికే లెక్కించిన key మరియు value vectorsను ఇది మళ్లీ ఉపయోగిస్తుంది. దాంతో prefill compute ఆదా అవుతుంది, first token వచ్చే సమయం తగ్గుతుంది. vLLMలో shared blocksను duplicate చేయకుండా మళ్లీ ఉపయోగిస్తారు. అందువల్ల memory వినియోగం కూడా మెరుగుపడుతుంది. ప్రస్తుతంలో processingలో ఉన్న tokensకు అవసరమైన cache పరిమాణాన్ని ఈ రెండు featuresలో ఏదీ తగ్గించదు. కాబట్టి context మరియు concurrency లెక్కలే కనీస memory అవసరాన్ని నిర్ణయిస్తాయి.
నేను ఒక్కసారి మాత్రమే పంపే promptను cache చేయడం ప్రయోజనకరమా?
కాదు. సాధారణ input కంటే cache writeకు ఎక్కువ ఖర్చవుతుంది. October 2026 నాటికి 5-minute option కోసం ఇది base rateకి 1.25 రెట్లు ఉంది. కాబట్టి ఆ windowలో మళ్లీ పంపని prefixను cache చేయడం నేరుగా నష్టమే. అదే prefix మళ్లీ మళ్లీ ఉపయోగించినప్పుడు caching ప్రయోజనకరంగా ఉంటుంది. ఉదాహరణకు, పొడవైన system prompt లేదా అనేక ప్రశ్నలు అడగబోయే document ఇందుకు సరిపోతాయి. Writeలకు కాకుండా hitsకు ఛార్జ్ అవుతున్నదో నిర్ధారించడానికి API responseలోని cache_read_input_tokensను పరిశీలించండి.