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

VPS లో CPU steal time అంటే ఏమిటి? ఎలా గుర్తించాలి?

vmstat లో st కాలమ్ ద్వారా CPU steal time ను ఎలా అర్థం చేసుకోవాలో తెలుసుకోండి. మీ సర్వర్ లోడ్ వల్ల సమస్య ఉందో లేదా పక్కన ఉన్న నోడ్ లోని noisy neighbour వల్ల వేగం తగ్గిందో గుర్తించండి.

Verified Every command ran end-to-end on a fresh Ubuntu 24.04 server, August 7, 2026.

CPU steal time వాస్తవానికి దేనిని కొలుస్తుంది

CPU steal time అనేది మీ వర్చువల్ CPU రన్ అవ్వడానికి సిద్ధంగా ఉండి, వేచి ఉండాల్సిన పని ఏమీ లేనప్పుడు, హైపర్‌వైజర్ ఆ ఫిజికల్ కోర్‌ను మరొక గెస్ట్‌కు కేటాయించిన సమయం. ఆ పని క్యూలో ఉండిపోయింది. ఆ కోర్ వేరే చోట బిజీగా ఉంది. Linux ఆ సైకిళ్లను విడిగా లెక్కించి st గా చూపిస్తుంది. దీని ద్వారానే "నా సర్వర్ బిజీగా ఉంది" అని మరియు "నా సర్వర్ తన వంతు కోసం వేచి ఉంది" అని మీరు గుర్తించగలరు.

ఈ వ్యత్యాసాన్ని గుర్తించడమే ఈ కౌంటర్ ఉనికికి ప్రధాన కారణం. మీ సొంత ప్రాసెస్‌లు CPUపై గడిపే సమయాన్ని us (user) లేదా sy (system) గా రిపోర్ట్ చేస్తారు. ఒక టాస్క్ స్టోరేజ్ కోసం వేచి ఉంటూ బ్లాక్ అయిన సమయాన్ని wa (I/O wait) గా చూపిస్తారు. ఒక vCPU (virtual CPU) రన్ అవ్వడానికి సిద్ధంగా ఉండి, రన్ క్యూలో కూర్చుని, ఎటువంటి I/O పెండింగ్‌లో లేకపోయినా, ఇంకా ఎగ్జిక్యూట్ అవ్వకపోతే, దానిని st గా రిపోర్ట్ చేస్తారు. మీ సర్వర్ లోపల ఏదీ ఈ స్థితిని మార్చలేదు, ఎందుకంటే షెడ్యూలింగ్ నిర్ణయం మీ కంటే ఒక పొర కింద, హోస్ట్ స్థాయిలో జరుగుతుంది.

ఇది ఒక VPS ఒక ఫిజికల్ మెషీన్‌ను అనేక గెస్ట్‌ల మధ్య ఎలా పంచుకుంటుంది అనే అంశం నుండి నేరుగా వస్తుంది. దీనికి సాధారణ కారణం పొరుగున ఉన్న మరొక గెస్ట్: అదే నోడ్‌లో ఉన్న మరొక గెస్ట్ అధిక లోడ్‌తో నడుస్తుంటే, హోస్ట్ కోర్లను మీ మధ్య పంచుతుంది. దీనికి మరొక కారణం కూడా ఉంది, అది తరచుగా గమనించబడదు. చాలా మంది ప్రొవైడర్లు షేర్డ్ vCPUని ఫిజికల్ కోర్‌లో కొంత భాగానికి పరిమితం చేస్తారు (cap). అనేక హైపర్‌వైజర్లలో, ఆ విధంగా విధించిన పరిమితిని గెస్ట్ లోపల steal గా పరిగణిస్తారు. కాబట్టి, అధిక st రీడింగ్ కనిపిస్తే, ఆ కోర్ మీకు కేటాయించబడలేదని అర్థం. కానీ అది ఎవరి వల్ల జరిగిందో అది ఎల్లప్పుడూ చెప్పదు.

Steal విలువ ఎక్కడి నుంచి వస్తుంది

మీ kernel స్వయంగా steal సమయాన్ని కొలవలేదు, ఎందుకంటే దానికి host కనిపించదు. ఆ విలువను hypervisor అందిస్తుంది. KVMలో host ప్రతి vCPU కోసం ఒక counter ను guestతో sharedగా ఉన్న pageలో రాస్తుంది. kernel CONFIG_PARAVIRT_TIME_ACCOUNTING తో build అయి ఉంటే guest ఆ విలువలను మొత్తం కలుపుతుంది. ప్రతి distribution kernelలో ఇది enabledగా ఉంటుంది. Xen తన runstate area ద్వారా ఇదే సమాచారాన్ని అందిస్తుంది. ఈ మొత్తం userspaceకు కచ్చితంగా ఒకే చోట అందుతుంది:

head -1 /proc/stat

ఆ cpu lineలో boot అయినప్పటి నుంచి USER_HZ ticksలో పది counters ఉంటాయి. వాటి క్రమం: user, nice, system, idle, iowait, irq, softirq, steal, guest, guest_nice. Label తర్వాత steal ఎనిమిదవ విలువ. క్రింద ఉన్న ప్రతి tool, vmstat, top, mpstat మరియు ఏ Prometheus exporter అయినా ఇదే fieldను చదివి, రెండు samples ఆధారంగా percentageను లెక్కిస్తుంది.

ఇందులోని ఒక పరిణామం మిగతావాటికంటే ముఖ్యమైనది. hypervisor ఈ counterను ఎగుమతి చేయకపోతే field ఎప్పటికీ zeroగానే ఉంటుంది. దానిపై ఆధారపడిన ప్రతి tool host అధిక loadలో ఉన్నప్పటికీ ప్రశాంతమైన 0.0 ను చూపిస్తుంది. KVM మరియు Xen దీన్ని export చేస్తాయి. VMware, Hyper-V సహా ఇతర platformలలో steal కనిపిస్తుందా అనేది host ఏ సమాచారాన్ని expose చేస్తుందో, guest kernel దేనికి support ఇస్తుందో దానిపై ఆధారపడి ఉంటుంది. అందువల్ల అక్కడ స్థిరంగా కనిపించే zero ఒక్కదానితో ఏ విషయాన్నీ నిర్ధారించలేరు. Zeroను నమ్మే ముందు platformను తనిఖీ చేయండి:

systemd-detect-virt

ఇది platform పేరును ముద్రిస్తుంది. ఉదాహరణకు kvm, xen, vmware లేదా microsoft కనిపించవచ్చు. Bare metalలో none కనిపిస్తుంది. Containerలో ఇది runtimeను చూపిస్తుంది. ఉదాహరణకు lxc, docker లేదా podman కనిపించవచ్చు. ఇది container గురించి సమాచారం ఇస్తుంది, దాని కింద ఉన్న machine గురించి కాదు. kvmలో zero కనిపిస్తే host మీకు తగిన వనరులు అందిస్తోందని చెప్పడానికి అది నిజమైన ఆధారం. Fieldను ఎప్పుడూ నింపని platformలో zero కనిపించడం ఎలాంటి ఆధారం కాదు. అటువంటి సందర్భంలో నిజమైన పని చేసే సమయంలో timingను కొలిచి contentionను అంచనా వేయాలి.

VPSలో CPU steal time ను ఎలా పరిశీలించాలి?

vmstat అనేది procps package నుంచి వస్తుంది. ఇది దాదాపు ప్రతి Ubuntu మరియు Debian VPS imageలో ఉంటుంది. అయితే కొన్ని minimal container imagesలో ఉండకపోవచ్చు. కాబట్టి దానిపై ఆధారపడే ముందు దాన్ని install చేయండి.

sudo apt-get update
sudo apt-get install -y procps
vmstat --version
vmstat 1 5

vmstat --version, vmstat from procps-ng 4.0.4 వంటి ఒక lineను print చేస్తుంది. అది print అయితే tool install అయి ఉందని, మీరు kernel counters నుంచి నిజమైన విలువలను చదువుతున్నారని అర్థం. తరువాత vmstat 1 5 ఐదు reportsను print చేస్తుంది: మొదటిది boot అయినప్పటి నుంచి ఉన్న average, తరువాతి నాలుగు one-second samples.

procs -----------memory---------- ---swap-- -----io---- -system-- -------cpu-------
 r  b   swpd   free   buff  cache   si   so    bi    bo   in   cs us sy id wa st gu
 1  0      0 3216484  98304 1284360    0    0     4    18   62  110  3  1 96  0  0  0
 2  0      0 3216232  98304 1284360    0    0     0     0  248  431  6  2 84  0  8  0

కుడి వైపున ఉన్న cpu blockలో st columnను కనుగొనండి. ప్రస్తుత procps-ng builds దాని తరువాత KVM guest time కోసం gu columnను print చేస్తాయి. అందువల్ల st చివరి column కాకుండా కుడి నుంచి రెండవ columnగా ఉంటుంది. Column స్థానాన్ని బట్టి కాకుండా header name ఆధారంగా చదవండి. Releases మధ్య ఆ స్థానం మారింది.

విలువను సరిగ్గా అర్థం చేసుకోవడానికి రెండు విషయాలు గుర్తుంచుకోండి. మొదటి data line boot అయినప్పటి నుంచి ఉన్న average. కాబట్టి దాన్ని పక్కన పెట్టి, దాని తరువాతి linesను చదవండి. అలాగే ఒక sampleతో measurement చేయలేరు, ఎందుకంటే steal burstsగా వస్తుంది. vmstat 1 61 ను run చేయండి. ఇది boot అయినప్పటి line తరువాత అరవై one-second samples ఇస్తుంది. నిర్ణయం తీసుకునే ముందు పూర్తి ఒక నిమిషం పరిశీలించండి.

top తన %Cpu(s) summary lineలో, stగా గుర్తించిన fieldలో అదే సంఖ్యను report చేస్తుంది:

%Cpu(s):  6.2 us,  2.1 sy,  0.0 ni, 83.9 id,  0.0 wa,  0.0 hi,  0.3 si,  7.5 st

ప్రతి coreకు సంబంధించిన వివరాల కోసం sysstatను జోడించండి:

sudo apt-get install -y sysstat
mpstat -P ALL 1 5

mpstat ప్రతి CPUకు ఒక rowను print చేస్తుంది. అందులోని %steal column ప్రతి vCPU ప్రభావితమైందా లేదా ఒక్కదానిపైనే సమస్య ఉందా చూపిస్తుంది. Support ticket కోసం అవసరమైన historyను screenపై చదివి నమోదు చేయకుండా samplesను భద్రపరచండి:

date -u | tee -a ~/steal.log
mpstat -P ALL 1 5 | tee -a ~/steal.log

మీరు సమస్యను అనుమానిస్తున్న గంటల సమయంలో cron ద్వారా దీన్ని run చేయండి. అప్పుడు ఆ file providerకు “నిన్న రాత్రి నెమ్మదిగా అనిపించింది” అని చెప్పడం మరియు ఖచ్చితమైన పది నిమిషాల ఆధారాన్ని చూపించడం మధ్య తేడాగా ఉంటుంది.

steal సంఖ్యల అర్థం ఏమిటి?

  • స్థిరమైన 0.0. ఇది ఆరోగ్యకరమైన స్థితిని సూచిస్తుంది లేదా ఆ platform steal ను అసలు నివేదించదు. సంతోషించే ముందు systemd-detect-virt తో నిర్ధారించండి.
  • కొన్ని సెకన్ల పాటు ఉండే కొన్ని శాతం spikeలు. ఏ shared nodeలోనైనా ఇది సాధారణమే. పొరుగు వినియోగదారుడి build ప్రారంభమై ఉండవచ్చు లేదా host తన backups ను అమలు చేస్తూ ఉండవచ్చు.
  • shared planలో 1 నుంచి 5 శాతం వరకు నిరంతరం ఉండటం. ఇది ఊహించదగినదే. ధరలో ప్రతిబింబించేది shared CPU వినియోగమే.
  • 5 నుంచి 10 శాతం వరకు నిరంతరం ఉండటం. కొలవగల slowdown ఇది. ఆధారాలను నమోదు చేయడం ప్రారంభించి, అనేక రోజులలో అదే గంటలను పోల్చండి.
  • ఒకేసారి గంటలపాటు 10 శాతానికి మించి ఉండటం. మీ workloadకు nodeలో తగినంత సామర్థ్యం లేకపోవచ్చు లేదా మీ plan యొక్క CPU limit అమలులో ఉండవచ్చు. కొంతమంది providerలు ఆ limitను stealగా నివేదిస్తారు. Support ticket నమోదు చేయడానికి లేదా వేరే planకు మారడానికి ఇది సరైన స్థాయి.

ఈ శాతాలను specificationగా కాకుండా అంచనా వేసే మార్గదర్శకంగా పరిగణించండి. shared planలో ఏ provider కూడా stealకు హామీని ప్రచురించదు. మీరు నడిపే workload ఆధారంగా వాటిని అంచనా వేయండి. రాత్రంతా నడిచే batch job 15 శాతం stealను తట్టుకోగలదు; ఎవరూ గమనించకపోవచ్చు. latency-sensitive serviceలో సగటు విలువ ఆందోళనకరంగా కనిపించకముందే p99లో ప్రభావం కనిపిస్తుంది. అందుకే trading bots వంటి latency-sensitive workloads ను dedicated coresపై ఉంచాలి.

Steal time మీకు ఎంత ఖర్చు అవుతుంది?

దీని గణన చాలా చిన్నది. మీ CPU సమయంలో s వంతును వేరే వారు తీసుకుంటే, ఒక నిర్దిష్ట CPU సమయం అవసరమైన పని పూర్తి కావడానికి గడియారంలో 1 / (1 - s) రెట్లు ఎక్కువ సమయం పడుతుంది. 60 సెకన్ల CPU సమయం అవసరమైన ఒక పని కోసం:

చార్ట్Wall clock time for a job needing 60 seconds of CPU
ఈ చార్ట్ వెనుక ఉన్న డేటా
[
  {
    "steal_percent": 0,
    "wall_clock_seconds": "60.0"
  },
  {
    "steal_percent": 3,
    "wall_clock_seconds": "61.9"
  },
  {
    "steal_percent": 8,
    "wall_clock_seconds": "65.2"
  },
  {
    "steal_percent": 15,
    "wall_clock_seconds": "70.6"
  },
  {
    "steal_percent": 25,
    "wall_clock_seconds": "80.0"
  },
  {
    "steal_percent": 40,
    "wall_clock_seconds": "100.0"
  }
]

సాధారణ shared-plan రీడింగ్ అయిన 3 శాతం వద్ద, ఆ పనికి 60.0 సెకన్లకు బదులుగా 61.9 సెకన్లు పడుతుంది. దీని కోసం ఎవరూ టికెట్ రైజ్ చేయరు. 8 శాతం వద్ద ఇది 65.2 సెకన్లు అవుతుంది. 40 శాతం వద్ద అదే పనికి 100.0 సెకన్లు పడుతుంది, దీనివల్ల ఒకప్పుడు ఖాళీ అయ్యే క్యూ (queue) ఇప్పుడు పెరగడం మొదలవుతుంది.

ఇవి కేవలం గణనలు మాత్రమే, కొలతలు కావు. ఈ నమూనా ఒకే runnable thread ఉందని మరియు steal సమయం అంతటా సమానంగా పంపిణీ చేయబడిందని భావిస్తుంది. వాస్తవ సేవలు ఈ వక్రరేఖ (curve) కంటే అధ్వాన్నంగా అనిపిస్తాయి, ఎందుకంటే ఒక stolen slice అభ్యర్థన మధ్యలో వస్తుంది, తద్వారా ఆ అభ్యర్థన కోసం వేచి ఉన్న ప్రతిదీ మళ్ళీ జాప్యాన్ని భరించాల్సి వస్తుంది. ఫార్ములాపై ఆధారపడకుండా మీ స్వంత గణాంకాలను పొందడానికి, తక్కువ రద్దీ ఉన్న సమయంలో మరియు ఎక్కువ రద్దీ ఉన్న సమయంలో benchmark the VPS చేయండి, ఆ రెండు సమయాల్లోనూ st ను రికార్డ్ చేయండి.

ఇది steal ఆ, లేక మరేదైనా సమస్యనా?

Steal ను ఇతర లక్షణాలతో పొరబడటం సులభం. కౌంటర్లను ఒకే vmstat లైనులో కలిపి చదవండి.

  • st ఎక్కువగా ఉండి, r మరియు us తక్కువగా ఉంటే: హోస్ట్ మీకు కోర్ (core) కేటాయించడం లేదు. అదే steal.
  • r మీ vCPU సంఖ్య కంటే చాలా ఎక్కువగా ఉండి, us ఎక్కువగా మరియు st సున్నాకి దగ్గరగా ఉంటే: మీ CPUs సామర్థ్యం కంటే ఎక్కువ పనిని మీరు చేస్తున్నారు. r ను nproc అవుట్‌పుట్‌తో పోల్చి చూడండి. ఇది మీ సొంత oversubscription, పక్కన ఉన్నవారు (neighbour) కాదు.
  • wa ఎక్కువగా ఉండి st సున్నాకి దగ్గరగా ఉంటే: పనులు స్టోరేజ్ వద్ద నిలిచిపోయాయి (blocked), ఇది వేరే సమస్య మరియు దీనికి పరిష్కారం కూడా వేరుగా ఉంటుంది.
  • Load average ఎక్కువగా ఉండి st మరియు us రెండూ తక్కువగా ఉంటే: లోడ్ గణాంకాలు uninterruptible పనులను కూడా లెక్కిస్తాయి, కాబట్టి ఇది సాధారణంగా CPU సమస్య కాకుండా, నిలిచిపోయిన పరికరం (stuck device) లేదా నెట్‌వర్క్ మౌంట్ సమస్యను సూచిస్తుంది.

Burstable ప్లాన్‌ల గురించి ప్రత్యేకంగా చెప్పుకోవాలి. ఇవి మీకు క్రెడిట్ బ్యాలెన్స్‌ను ఇస్తాయి; మీరు ఖాళీగా ఉన్నప్పుడు ఇది పెరుగుతుంది, బిజీగా ఉన్నప్పుడు తగ్గుతుంది. అది అయిపోయినప్పుడు, ప్రొవైడర్ మిమ్మల్ని బేస్‌లైన్ రేటు వద్ద ఉంచుతారు. కొన్ని ప్లాట్‌ఫారమ్‌లలో ఆ throttling ను steal గా చూపిస్తాయి. మరికొన్నింటిలో ఇది లోపలి నుండి కనిపించదు, మీకు సెకనుకు తక్కువ సైకిల్స్ మాత్రమే అందుతాయి. పక్కన ఉన్నవారే కారణమని నిర్ణయించుకునే ముందు ప్లాన్ వివరణను చదవండి.

కంటైనర్ ఎందుకు steal time ను చూపదు

Steal అనేది వర్చువల్ మెషీన్ యొక్క లక్షణం, దాని లోపల నడుస్తున్న కంటైనర్ ది కాదు. మీ VPS లో నడుస్తున్న Docker కంటైనర్ హోస్ట్ యొక్క /proc ను పంచుకుంటుంది, కాబట్టి దాని లోపల కనిపించే st విలువ ఆ VPS యొక్క steal సమయమే, ఇది మీరు తెలుసుకోవలసినది. VPS గా విక్రయించబడే కంటైనర్-ఆధారిత వర్చువలైజేషన్ భిన్నంగా పనిచేస్తుంది. lxcfs అమల్లో ఉన్నప్పుడు, కంటైనర్ లోపల ఉండే /proc/stat అనేది cgroup అకౌంటింగ్ నుండి సేకరించబడుతుంది, మరియు డిజైన్ ప్రకారం steal విలువ సున్నాగా ఉంటుంది. కేవలం కంటైనర్ లోపలి నుంచే డేటాను సేకరించే మానిటరింగ్ స్టాక్, కింద ఉన్న ఫిజికల్ మెషీన్ వనరుల కొరతతో ఇబ్బంది పడుతున్నా, సున్నా అనే స్థిరమైన విలువను మాత్రమే చూపుతుంది.

కంటైనర్ లోపల, అదే అర్థాన్ని ఇచ్చే కౌంటర్ CPU quota throttling. cgroup v2 పై:

cat /sys/fs/cgroup/cpu.stat

nr_throttled అనేది గ్రూప్ తన CPU కోటాను దాటిన ఎన్‌ఫోర్స్‌మెంట్ పీరియడ్‌లను లెక్కిస్తుంది, మరియు throttled_usec అనేది అది నిలిపివేయబడిన (frozen) మొత్తం సమయాన్ని సూచిస్తుంది. nr_throttled పెరుగుతుందంటే మీ ప్రాసెస్ రన్ అవ్వడానికి సిద్ధంగా ఉన్నా రన్ అవ్వడం లేదని అర్థం; ఇది steal వంటి అనుభవమే, కానీ మీరు స్వయంగా విధించిన పరిమితి వల్ల ఇది జరుగుతుంది. హోస్ట్‌ను నిందించే ముందు మీ పరిమితులను తనిఖీ చేయండి, ముఖ్యంగా మీరు Docker compose ఫైల్‌లో CPU పరిమితులతో VPS పై సేవలను నడుపుతున్నప్పుడు ఇది ముఖ్యం. లేయర్డ్ వర్చువలైజేషన్ సమయం వృథా అవ్వడానికి మరొక కారణాన్ని జోడిస్తుంది, ఎందుకంటే మీ VPS లోపల ఉన్న VM మీ VPS యొక్క steal తో పాటు దాని స్వంత షెడ్యూలింగ్ జాప్యాన్ని కూడా భరిస్తుంది. మీరు VPS పై నెస్టెడ్ వర్చువలైజేషన్ నడుపుతున్నప్పుడు ఈ విషయాన్ని గుర్తుంచుకోండి.

Sustained steal గురించి ఏమి చేయాలి

Guest లోని ఏ setting కూడా steal సమస్యను పరిష్కరించదు, ఎందుకంటే ఆ నిర్ణయం తీసుకునే scheduler guest వెలుపల నడుస్తుంది. Kernel upgrade చేసినా ఇది మారదు: Linux kernel 7.2లో చేర్చిన cache-aware scheduling, మీకు వాస్తవంగా కేటాయించిన cores మధ్య మీ tasks ను పునర్వ్యవస్థీకరిస్తుంది. ఇప్పటికే పొరుగు instance తీసుకున్న cycles ను అది తిరిగి పొందలేను. ఆచరణలో ఉపయోగపడే నాలుగు చర్యలు ఇవి.

ముందుగా ఆధారాలను సేకరించండి. Timestamps ను UTCలో నమోదు చేయండి. ప్రతి episode ఎంతసేపు కొనసాగిందో, అది ఎంత తరచుగా పునరావృతమవుతుందో, అలాగే mpstat ఒక vCPUపై ప్రభావం చూపుతుందా లేదా అన్నింటిపైనా చూపుతుందా నమోదు చేయండి. ఒక వారం పాటు log చేసిన samples, ఒక screenshot కంటే ఎక్కువ ఉపయోగకరం.

ఆ డేటాతో ticket తెరవండి. రెండు ప్రత్యక్ష ప్రశ్నలు అడగండి: ఈ సమయాల్లో node oversubscribed గా ఉందా? నా instance ను మరొక nodeకు తరలించగలరా? vmstat output మరియు ఖచ్చితమైన సమయాలను జతచేయండి. పునరావృతం చేయగల సమయ పరిధి ఉంటే providers దానిపై చర్య తీసుకుంటారు. “server slowగా ఉంది” అని మాత్రమే ఉన్న ticketకు, సాధారణంగా ఆ సమయ పరిధిని అడిగే సమాధానం వస్తుంది. ఈ పనిలో ఎంత భాగాన్ని providerకు అప్పగించగలరనేది managed మరియు unmanaged VPS మధ్య ఉన్న ఆచరణాత్మక తేడాల్లో ఒకటి.

Migration కోరండి. Guestను తక్కువ load ఉన్న nodeకు తరలించడం providerకు సాధారణ పని. సాధారణంగా దీనికి చిన్న reboot మాత్రమే అవసరం. దీనికి అదనపు ఖర్చు ఉండదు. ఒకే nodeపై ఒకేసారి అనేక heavy neighbours ఉండే సాధారణ సందర్భాన్ని ఇది పరిష్కరిస్తుంది.

Contentionను నివారించడానికి కొనుగోలు చేయండి. Dedicated vCPU plan మీ instance కోసం CPU capacityను reserve చేస్తుంది. Providerపై ఆధారపడి ఇది full core లేదా full hardware thread కావచ్చు. అందువల్ల neighbours మీ cyclesను తీసుకోలేరు. Counter సున్నా వద్ద లేదా దానికి చాలా దగ్గరగా ఉంటుంది. Hypervisor నిర్వహణ కోసం ఉపయోగించే cycles వల్ల కొద్దిగా residue మిగలవచ్చు. దీనికి ప్రతి నెలా ఎక్కువ ఖర్చవుతుంది. Varianceను భరించలేని workloadకు ఇది సరైన పరిష్కారం. ఇది కూడా సరిపోకపోతే, లేదా memory bandwidthను కూడా మీకే కేటాయించాలనుకుంటే, తదుపరి దశ VPSకు బదులుగా dedicated server.

ఇవేవైనా అమలు అయ్యే వరకు, steal ప్రభావాన్ని తగ్గించండి. మీ vCPUs సంఖ్య కంటే తక్కువ worker threads నడపండి. Core పొందలేని threads అదనపు context switchesను మాత్రమే సృష్టిస్తాయి. Node ప్రశాంతంగా ఉండే సమయాల్లో batch workను నడపండి. ఆ సమయం ఏదో మీ స్వంత log ఇప్పుడు చూపిస్తుంది. తరువాత అదే commandను అదే సమయ పరిధిలో మళ్లీ అమలు చేసి measure చేయండి. అప్పుడు మార్పు పనిచేసిందో లేదో ఊహించకుండా స్పష్టంగా చెప్పగలరు.

FAQ

VPSలో సాధారణ CPU steal time ఎంత ఉండాలి?

Shared planలో స్వల్పకాలిక spikes మరియు సుమారు 5 శాతం కంటే తక్కువగా నిరంతరంగా ఉండే విలువ సాధారణమే. కారణం, shared CPUలో host భౌతిక coresను guestల మధ్య పంచుతుంది. గంటల పాటు sustained double digits ఉండటం సాధారణం కాదు; దాని గురించి support ticket నమోదు చేయాలి. Dedicated vCPU planలో reading 0.0 వద్ద లేదా దానికి చాలా సమీపంగా ఉండాలి. Hypervisor housekeeping కొంత CPU సమయాన్ని తీసుకోవచ్చు. అందువల్ల దానికంటే ఎక్కువగా నిరంతర steal ఉండటం report చేయాల్సిన లోపం. మీ స్వంత workload ఆధారంగా ఆ సంఖ్యను అంచనా వేయండి. Overnight batch job కొంత stealను తట్టుకోగలదు, కానీ latency-sensitive API తట్టుకోలేకపోవచ్చు.

పెద్ద plan తీసుకుంటే high steal time పరిష్కారమవుతుందా?

అది ఒక్కటే సరిపోదు. అదే shared nodeపై vCPUs పెంచితే, అదే ఒత్తిడిలో ఉన్న భౌతిక cores కోసం పోటీపడే virtual CPUs సంఖ్య పెరుగుతుంది. అందువల్ల శాతం ముందున్న స్థాయిలోనే ఉండవచ్చు. దాదాపు మొత్తం stealను తొలగించేది dedicated CPU allocation లేదా తక్కువ load ఉన్న nodeకు migration. Busy machineలో పెద్ద share తీసుకున్నా, అది busy machineలోని shareగానే ఉంటుంది.

నా VPS స్పష్టంగా slowగా ఉన్నప్పటికీ 0 steal time ఎందుకు చూపిస్తుంది?

దీనికి రెండు సాధారణ కారణాలు ఉన్నాయి. Hypervisor counterను export చేయకపోవచ్చు. Host మరియు guest kernel ఆధారంగా కొన్ని platformsలో ఇలా జరుగుతుంది. అందువల్ల hostలో ఏం జరిగినా field zeroగానే ఉంటుంది. మీరు ఏ platformపై ఉన్నారో చూడటానికి systemd-detect-virt అమలు చేయండి. లేకపోతే bottleneck మరెక్కడో ఉంటుంది. Storage waits కోసం waను పరిశీలించండి. మీ స్వంత overload కోసం r మరియు nprocను పోల్చండి. Quota throttling కోసం containersలో /sys/fs/cgroup/cpu.statను పరిశీలించండి.

నా serverలోపల నుంచే steal timeను తగ్గించగలనా?

Guestలోపల నుంచే host schedulingను మార్చలేరు. అది కలిగించే ప్రభావాన్ని మాత్రమే తగ్గించగలరు. మీ వద్ద ఉన్న vCPUs కంటే తక్కువ worker threadsను అమలు చేయండి. అప్పుడు అందుబాటులోకి రాని core కోసం తక్కువ పని run queueలో వేచి ఉంటుంది. Nodeపై load తక్కువగా ఉండే గంటలకు batch jobsను మార్చండి. ఫలితాలను cache చేయండి, తద్వారా requestsకు CPU అవసరం తగ్గుతుంది. Stealను నిజంగా తొలగించే మార్పులు, అంటే మరో nodeకు migration లేదా dedicated cores, provider వైపు చేయాల్సినవి.

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