SSD Nodes Learn Hosting plans →

VPS benchmark సరిగ్గా ఎలా చేయాలి

ముందుగా yabs.sh, తరువాత fio, sysbench, iperf3 run చేయండి. ప్రతి సంఖ్య అర్థం, VPSలో సమయానుసారం మారే ఫలితాలు, ఒక్క run ఎందుకు సరిపోదో తెలుసుకోండి.

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

VPS ను benchmark చేయడం అంటే ఏమిటి

VPS ను benchmark చేయడానికి నాలుగు విషయాలను కొలుస్తారు: ఒక CPU core ఎంత వేగంగా పనిచేస్తుందో, machine కు ఎంత memory bandwidth ఉందో, storage ప్రతి సెకనుకు ఎన్ని చిన్న random disk operations ను అందిస్తుందో, network link ఎంత throughput ను అందిస్తుందో. yabs.sh ను ఒక్కసారి run చేస్తే సుమారు పది నిమిషాల్లో CPU, disk, network ఫలితాలు లభిస్తాయి; memory bandwidth కోసం దిగువన ఉన్న ప్రత్యేక memory test ను ఉపయోగించండి. ఫలితాన్ని అర్థం చేసుకోవడం కష్టమైన భాగం. VPS ఇతర tenants తో physical hardware ను పంచుకుంటుంది. అందువల్ల అదే machine 03:00 సమయంలో ఒక విలువను, 20:00 సమయంలో చాలా భిన్నమైన విలువను చూపవచ్చు.

ఇక్కడి ప్రణాళిక ప్రకారం ముందుగా త్వరిత అంచనా కోసం yabs.sh ను run చేసి, తరువాత దాని కింద ఉన్న tools ను చేతితో run చేస్తాం. మీరు వాటిని స్వయంగా run చేసినప్పుడే ఒక flag ను మార్చి, సంఖ్య ఎలా మారుతుందో గమనించి, ఆ సంఖ్య నిజంగా ఏమి కొలుస్తుందో అర్థం చేసుకోవచ్చు. Machine setup పూర్తయిన తర్వాత దీన్ని చేయండి; అంతకు ముందు కాదు. కొత్త VPS లో మొదటి పది నిమిషాలు లోని దశలను ముందుగా పూర్తి చేయాలి. ఎందుకంటే మొదటి updates సమూహాన్ని ఇంకా apply చేస్తున్న box hardware తో సంబంధం లేని కారణాల వల్ల సరిగ్గా benchmark ఫలితాలను ఇవ్వదు.

కొలిచే ముందు యంత్రాన్ని పరిశీలించండి

ప్రతి చెడు బెంచ్‌మార్క్‌లో సగం కారణం, రచయితకు యంత్రం గురించి సరైన అవగాహన లేకపోవడమే.

nproc
lscpu | grep -E 'Model name|Hypervisor|Thread'
free -h
df -hT /
uname -r
systemd-detect-virt

Hypervisor vendor: KVM అంటే పూర్తి virtualization అని అర్థం. అందువల్ల మీరు మీ స్వంత kernel ను నడుపుతారు. systemd-detect-virt లో lxc లేదా openvz ముద్రితమైతే, అది container virtualization అని అర్థం. ఈ విధానంలో host kernel ను పంచుకుంటారు. మీ CPU మరియు memory పరిమితులు virtual hardware కాకుండా cgroup (control group) settings ద్వారా నిర్ణయించబడతాయి. cgroup v2 system లో మీ container యొక్క cgroup నుంచి CPU పరిమితిని చదవవచ్చు. ఆ cgroup ను /sys/fs/cgroup వద్ద mount చేసినప్పుడు కింది path వర్తిస్తుంది.

cat /sys/fs/cgroup/cpu.max

max 100000 అంటే ఈ cgroup కు స్వంత quota లేదని అర్థం. అయితే ancestor cgroups quota విధించగలవు. 200000 100000 అంటే ప్రతి 100000 microsecond period లో మీరు 200000 microseconds CPU ఉపయోగించవచ్చని అర్థం. ఇది రెండు cores quota కు సమానం. రెండు cores quota ఉన్న 4 vCPU plan, నాలుగు cores మాదిరి ఎప్పటికీ score సాధించదు. Benchmark tools ఈ పరిమితిని గుర్తించగలవు. Host చాలా ఎక్కువ CPUs ను అందుబాటులో ఉంచి, server వాటిలో కొన్నింటినే ఉపయోగించగలిగినప్పుడు, VoxelBench CPU quotas ను report చేసి shared లేదా throttled CPU ను flag చేస్తుంది.

వేరే కారణంతో df -hT / కూడా ముఖ్యమైనది: Type column. దాని విలువ overlay అయితే, మీరు container లో ఉన్నారని అర్థం. అప్పుడు మీ disk results, ఆ overlay కింద ఉన్న storage పనితీరును వివరిస్తాయి. దీన్ని ఇప్పుడే గమనించండి.

Steal time ను మొత్తం సమయం పర్యవేక్షించండి

Steal time అనేది hypervisor మీ virtual CPU ను schedule చేయకుండా ఉంచినప్పుడు, అది తప్పనిసరిగా వేచి గడిపిన సమయపు వాటా. అందుబాటులో లేని CPU సమయాన్ని గుర్తించడానికి ఇది ఉపయోగకరమైన సంకేతం. అయితే busy neighbours వల్లనా లేదా provider మీ CPU quota ను అమలు చేయడం వల్లనా అనేది ఇది వేరు చేయదు.

vmstat 1 10

కుడివైపున ఉన్న st column ను చదవండి. నిరంతరం కనిపించే steal time అంటే guest కు CPU సమయం అందుబాటులో లేదని అర్థం. అయితే 5% కంటే ఎక్కువ విలువ ఉన్నంత మాత్రాన host oversubscribed అని నిరూపించదు. Providers CPU quota అమలును ఉద్దేశపూర్వకంగా steal time గా చూపించవచ్చు. top, CPU line లోని %st చూపించే అదే విలువను చూపిస్తుంది. మీరు benchmark నిర్వహిస్తున్నప్పుడు vmstat 1 ను రెండవ SSH session లో నడుస్తూ ఉంచండి. ప్రతి ఫలితం పక్కన steal విలువను రాసుకోండి.

yabs.sh తో ప్రారంభించండి

yabs.sh (Yet Another Bench Script) అనేది fio, iperf3, Geekbench ను అమలు చేసి ఒకే సారాంశాన్ని చూపించే shell script. ఇవి ఇప్పటికే install అయి ఉంటే fio మరియు iperf3 ను ఉపయోగిస్తుంది. లేకపోతే static binaries ను download చేస్తుంది. VPS benchmark చర్చల్లో ఇది సాధారణంగా ఉపయోగించే ప్రమాణం. అందువల్ల మరొకరితో benchmark వివరాలను పోల్చడానికి yabs output అత్యంత వేగవంతమైన మార్గం.

ఈ project అందించే one-line రూపం ఇది.

curl -sL yabs.sh | bash

ఇది URL ప్రస్తుతం అందించే ఏదైనా కంటెంట్‌ను నేరుగా shell కు pipe చేస్తుంది. ముందుగా download చేసి, చదివి, తరువాత run చేయండి.

curl -sLo yabs.sh https://raw.githubusercontent.com/masonr/yet-another-bench-script/master/yabs.sh
less yabs.sh
bash yabs.sh

Pipe చేస్తున్నప్పుడు flags ను -s -- తర్వాత ఉంచాలి. Local copy ను run చేస్తున్నప్పుడు filename తర్వాత నేరుగా ఉంచాలి. ఉపయోగకరమైన flags ఇవి: -f disk test ను దాటవేస్తుంది, -i network test ను దాటవేస్తుంది, -g Geekbench ను దాటవేస్తుంది, -r iperf3 locations ను మూడుకు పరిమితం చేస్తుంది, -j results ను JSON గా చూపిస్తుంది, -w results.json ఆ JSON ను ఒక file కు రాస్తుంది.

bash yabs.sh -r -w yabs-run1.json

మొదటిసారి run చేయడానికి ముందు రెండు విషయాలు తెలుసుకోవాలి. Geekbench మీ result ను upload చేసి, public browser.geekbench.com URL ను చూపిస్తుంది. కాబట్టి ఆ link ఉన్న ఎవరైనా మీ CPU model మరియు scores ను చూడగలరు. -g ఆ test ను పూర్తిగా దాటవేస్తుంది. రెండవది, iperf3 దశలో అనేక regions లోని servers కు నిజమైన network traffic పంపబడుతుంది. ఇది మీ monthly bandwidth allowance నుంచి తగ్గుతుంది. 1 Gbit/s link పై పూర్తి network దశలో tens of gigabytes వరకు traffic వెళ్లవచ్చు. అందువల్ల allowance తక్కువగా ఉంటే -r ను, metered link అయితే -i ను ఉపయోగించండి.

yabs output లోని ప్రతి భాగం అర్థం

డిస్క్ విభాగం 4k, 64k, 512k మరియు 1m అనే నాలుగు block sizes వద్ద 50/50 read మరియు write మిశ్రమంతో fio ను నడుపుతుంది. ప్రతి block size కు IOPS (input/output operations per second) మరియు bandwidth ను చూపిస్తుంది. Database, mail server లేదా అనేక చిన్న writes చేసే ఏదైనా సేవకు 4k row ముఖ్యమైనది. ఎక్కువ server IO చిన్న పరిమాణంలో, చెల్లాచెదురుగా జరుగుతుంది. Backupలు మరియు video కోసం 1m row ఉపయోగకరం. వీటిలో వరుసగా ఉన్న పెద్ద byte పరిమాణాలను తరలిస్తారు.

Network విభాగం అనేక regions లోని public servers కు iperf3 ను రెండు దిశల్లో parallel streams తో నడుపుతుంది. ఇక్కడ తక్కువ సంఖ్య కనిపిస్తే దాన్ని తుది నిర్ణయంగా కాకుండా పరిశీలించాల్సిన సూచనగా చూడాలి. Public iperf3 servers ఇతర వినియోగదారులతో పంచుకోబడతాయి మరియు తరచుగా saturation కు చేరుతాయి. అందువల్ల తక్కువ ఫలితానికి కారణం దూరంలోని server వైపు కూడా ఉండవచ్చు.

Geekbench విభాగం single core score మరియు multi core score ను ఇస్తుంది. Single core score ద్వారా ఒక request, ఒక compile లేదా ఒక query ఎంత వేగంగా పూర్తవుతుందో అంచనా వేయవచ్చు. Multi core score ప్రధానంగా మీకు వాస్తవంగా ఎన్ని cores లభించాయో తెలియజేస్తుంది.

డిస్క్: fio ను స్వయంగా అమలు చేయండి

yabs లోని disk విభాగం వెనుక పనిచేసే సాధనం fio (flexible IO tester). దీన్ని నేరుగా అమలు చేసినప్పుడు flags అర్థవంతంగా మారతాయి.

sudo apt update && sudo apt install -y fio sysbench iperf3

మీకు నిజంగా అవసరమైన filesystem పై, queue depth 32తో 4k random read test:

fio --name=randread4k --filename=./fio-testfile --size=2G --bs=4k \
  --rw=randread --ioengine=libaio --iodepth=32 --direct=1 \
  --runtime=60 --time_based --group_reporting

Output నుంచి చదవాల్సిన summary line ఇలా ఉంటుంది.

read: IOPS=184k, BW=719MiB/s (754MB/s)(42.1GiB/60001msec)

దాని కింద fio ఒక clat percentiles block ను ముద్రిస్తుంది. పేర్కొనదగిన గణాంకం 99.00th percentile. 100 requests లో అత్యంత నెమ్మదిగా పూర్తైన ఒక request ఎంతసేపు వేచి ఉందో ఇది చూపిస్తుంది. Average latency వినియోగదారుడు గమనించే stalls ను దాచిపెడుతుంది.

  • --direct=1 తో file ను O_DIRECT ఉపయోగించి తెరుస్తుంది. అందువల్ల reads kernel page cache ను దాటిపోతాయి. ఇది లేకపోతే, 8G RAM ఉన్న machine పై 2G file ను రెండోసారి చదివినప్పుడు data memory నుంచి అందుతుంది. అప్పుడు fio IOPS ను millions లో చూపిస్తుంది. ఆ సంఖ్య నిజమే, కానీ అది memory పనితీరును సూచిస్తుంది.
  • --ioengine=libaio asynchronous requests ను submit చేస్తుంది. అందువల్ల --iodepth=32 ఒకేసారి 32 requests ను in flight లో ఉంచగలదు. psync వంటి synchronous engine తో iodepth 1 కంటే ఎక్కువగా ఉన్నా ఎలాంటి ప్రభావం ఉండదు. అప్పుడు ఒక్కోసారి ఒక request ను మాత్రమే కొలుస్తారు.
  • --time_based --runtime=60 నిర్ణీత amount of work కు బదులుగా fixed 60 seconds పాటు test ను నడుపుతుంది. అందువల్ల fast disk మరియు slow disk రెండింటికీ ఒకే wall clock సమయం ఉంటుంది, కాబట్టి పోలిక న్యాయంగా ఉంటుంది.
  • --size=2G test file size ను నిర్ణయిస్తుంది. ఇది మార్గంలోని ఏ cache కంటే పెద్దదిగా ఉండాలి. ముందుగా తగినంత free space ఉందో లేదో తనిఖీ చేయండి.

Random write కోసం ఇదే command ను --rw=randwrite తో ఉపయోగించండి. దీన్ని విడిగా అమలు చేసి, తరువాత file ను delete చేయండి.

fio --name=randwrite4k --filename=./fio-testfile --size=2G --bs=4k \
  --rw=randwrite --ioengine=libaio --iodepth=32 --direct=1 \
  --runtime=60 --time_based --group_reporting
rm -f ./fio-testfile

నిజమైన network traffic కు మరింత దగ్గరగా ఉండే mix కోసం --rw=randrw --rwmixread=70 ఉపయోగించండి. మీరు ఉపయోగిస్తున్న storage class ఈ ఫలితాలను ఏ flag కంటే ఎక్కువగా మార్చగలదు. ఆ తేడాను VPS లో NVMe మరియు SATA SSD storage మధ్య తేడా లో వివరించారు.

fio Unknown error -1 వద్ద ఆగినప్పుడు

ప్రతి filesystem Direct IO ను అందుబాటులో ఉంచదు. అందువల్ల fio మొదటి request వద్దనే --direct=1 సెట్ చేసి విఫలమైతే, ముందుగా Direct IO ను పరిశీలించాలి. వైఫల్యం ఇలా కనిపించవచ్చు:

fio: io_u error on file ./fio-testfile: Unknown error -1: read offset=0, buflen=4096
fio: pid=1234, err=-1/file:ioengines.c:321, func=get_events, error=Unknown error -1

ముందుగా df -hT . ను అమలు చేయండి. Container కు Docker default గా ఇచ్చే Type అయిన overlay స్వయంగా కారణం కాదు. overlayfs, దిగువన ఉన్న filesystem కు O_DIRECT ను పంపిస్తుంది. ఆ filesystem Direct IO చేయలేనప్పుడు మాత్రమే దాన్ని తిరస్కరిస్తుంది. అందువల్ల ext4 లేదా xfs పై ఉన్న overlay లో --direct=1 --ioengine=libaio పనిచేస్తుంది. Test file ఉన్న filesystem వాస్తవంగా Direct IO చేయలేకపోతే, file ను తెరిచే సమయంలో fio సాధారణంగా ఆ విషయాన్ని తెలియజేస్తుంది: fio: looks like your file system does not support direct=1/buffered=0. అప్పుడు --filename ను bind mounted volume వంటి నిజమైన local storage path కు సూచించండి. లేదా container లో కాకుండా host పై fio ను అమలు చేయండి. నిజమైన storage అందుబాటులో లేకపోతే, buffered synchronous run కనీసం command సరైనదని నిర్ధారిస్తుంది.

fio --name=randread4k-buffered --filename=./fio-testfile --size=256M --bs=4k \
  --rw=randread --ioengine=psync --direct=0 --numjobs=1 \
  --runtime=15 --time_based --group_reporting
rm -f ./fio-testfile

ఆ run ఏమి నిరూపిస్తుందో స్పష్టంగా గుర్తుంచుకోండి. మొదటి pass తర్వాత 256M file page cache లో ఉంటుంది. అందువల్ల IOPS సంఖ్య మీ RAM పనితీరును వివరిస్తుంది. fio install అయిందని, flags సరిగ్గా parse అవుతున్నాయని నిర్ధారించడానికి మాత్రమే దీన్ని ఉపయోగించండి. దీన్ని disk ఫలితంగా ఎప్పుడూ పేర్కొనవద్దు.

dd ఎందుకు disk benchmark కాదు

VPS చర్చల్లో dd తరచుగా కనిపిస్తుంది. ఇది ఒక పరిమిత ప్రశ్నకు మాత్రమే సమాధానం ఇస్తుంది.

dd if=/dev/zero of=./ddtest bs=1M count=1024 oflag=direct conv=fdatasync
rm -f ./ddtest

ఇది ఒక thread మరియు ఒక in-flight request తో sequential write throughput ను కొలుస్తుంది. ఇది ప్రాథమిక sanity check గా ఉపయోగపడుతుంది. Random IO గురించి ఇది ఏమీ చెప్పదు. ఒకేసారి 32 requests వచ్చినప్పుడు ఏమి జరుగుతుందో కూడా ఇది చూపదు. oflag=direct ను తొలగిస్తే writes page cache ద్వారా సాగుతాయి. అయితే conv=fdatasync ఉన్నంత వరకు command పూర్తయ్యే ముందు output data storage కు రాయబడిందని నిర్ధారిస్తుంది. దానిని కూడా తొలగిస్తే, kernel writes ను memory లోకి ఎంత వేగంగా స్వీకరిస్తుందోనే ఫలితం ప్రధానంగా కొలవవచ్చు. అందుకే forum posts లో పేర్కొనే dd విలువలు తరచుగా అసంబద్ధంగా ఉంటాయి.

CPU: sysbench cpu

sysbench cpu --cpu-max-prime=20000 --threads=1 run
sysbench cpu --cpu-max-prime=20000 --threads=$(nproc) run

గమనించాల్సిన సంఖ్య events per second. ముందుగా single threaded విధంగా అమలు చేయండి. ఒక PHP అభ్యర్థన ఎంత వేగంగా పూర్తవుతుంది లేదా ఒక compile job ఎంత త్వరగా పూర్తవుతుంది అనే విషయాన్ని ఈ సంఖ్య నిర్ణయిస్తుంది. అదే ధరలోని hosts మధ్య ఎక్కువగా మారేది కూడా ఇదే. తరువాత ప్రతి thread తో అమలు చేయండి. దీనివల్ల మీకు కేటాయించిన vCPUs అంతటా throughput ఎలా పెరుగుతుందో తెలుస్తుంది.

ఇది ఏమి కొలుస్తుందో స్పష్టంగా తెలుసుకోండి: sysbench cpu trial division ఉపయోగించి prime numbers ను పదేపదే కనుగొంటుంది. ప్రతి candidate కోసం ఇది double precision square root ను లెక్కిస్తుంది. తరువాత 64 bit integer modulo ఉపయోగించి divisors ను పరీక్షిస్తుంది. ప్రతి divisor ను ఆ floating point limit తో పోల్చుతుంది. అందువల్ల ఇది integer మరియు floating point పనులను కలిపి కొలుస్తుంది. ఇది memory bandwidth, vector units లేదా cache ను వాస్తవ workload ను పోలిన విధంగా stress చేయదు. కాబట్టి రెండు hosts ను ర్యాంక్ చేయడానికి ఇది ఉపయోగకరం. కానీ మీ application ఎలా నడుస్తుందో అంచనా వేయడానికి ఇది సరైనది కాదు.

Ubuntu 24.04 లో sysbench 1.0.20 విడుదల అవుతుంది. ఇందులో test name ముందుగా వస్తుంది. పాత post లోని --test=cpu ఉన్న command ను copy చేస్తే మీకు WARNING: the --test option is deprecated వస్తుంది. sysbench 0.4 మరియు sysbench 1.0 నుంచి వచ్చిన scores అసలు పోల్చలేనివి. అందువల్ల version పేర్కొనని published number తో మీ ఫలితాన్ని ఎప్పుడూ పోల్చవద్దు.

Memory: sysbench మెమరీ

sysbench memory --memory-block-size=1M --memory-total-size=20G --memory-oper=write --threads=1 run
sysbench memory --memory-block-size=1M --memory-total-size=20G --memory-oper=read --threads=1 run

ఫలితం MiB/sec లో ఉంటుంది. --memory-block-size ను 1M వద్ద ఉంచండి. మీరు పోల్చే ప్రతి host లోనూ దాన్ని ఒకేలా ఉంచండి. 1K వద్ద సంఖ్య గణనీయంగా పడిపోతుంది. కారణం, ప్రతి operation కు వచ్చే overhead ను వెయ్యి రెట్లు ఎక్కువసార్లు చెల్లించాల్సి రావడం. అందువల్ల మీరు మెమరీ bandwidth కంటే loop cost ను కొలుస్తారు. ప్రచురితమైన మెమరీ స్కోర్లలో అత్యంత తరచుగా అసమానంగా ఉండే flag ఇదే.

నెట్‌వర్క్: iperf3

Throughput ను సరిగ్గా పరీక్షించాలంటే మీ నియంత్రణలో ఉన్న రెండవ machine కు వ్యతిరేకంగా పరీక్షించాలి. అప్పుడు రెండు చివరల్లో ఏమి జరుగుతుందో మీకు తెలుసు.

రిమోట్ చివరలో:

iperf3 -s

ఇది TCP 5201 పై listen చేస్తుంది. మీరు పరీక్షించే address కు మాత్రమే ఆ port ను open చేయండి. పరీక్ష పూర్తయ్యాక దాన్ని close చేయండి. VPS పై Basic ufw firewall నియమాలు syntax ను వివరిస్తుంది.

పరీక్షిస్తున్న VPS నుంచి:

iperf3 -c 203.0.113.10 -t 30
iperf3 -c 203.0.113.10 -t 30 -R
iperf3 -c 203.0.113.10 -t 30 -P 8

మొదటి command పరీక్షిస్తున్న machine నుంచి జరిగే upload ను కొలుస్తుంది. -R దిశను reverse చేస్తుంది. ఇది download ను కొలుస్తుంది. -P 8 ఎనిమిది parallel streams ను open చేస్తుంది.

Single stream మరియు parallel version రెండింటినీ run చేయండి. అవి వేర్వేరు ప్రశ్నలకు సమాధానం ఇస్తాయి. ఒక TCP connection window అనుమతించేంత unacknowledged data ను మాత్రమే ఉంచగలదు. అందువల్ల దాని గరిష్ఠ పరిమితి సుమారుగా window size ను round trip time తో భాగించినంత ఉంటుంది. Latency 80 ms, window 4 MB గా ఉంటే, కింద ఉన్న link ఎంత వేగంగా ఉన్నా ఆ పరిమితి సుమారుగా 400 Mbit/s ఉంటుంది. Single stream ఫలితం ఒక download కు లభించే వేగాన్ని చూపుతుంది. Parallel ఫలితం link యొక్క capacity ను చూపుతుంది.

ఈ పరీక్షలు చేస్తున్నప్పుడు మీ bandwidth allowance ను గమనించండి. 1 Gbit/s వద్ద 30 seconds లో సుమారుగా 3.75 GB data బదిలీ అవుతుంది. ప్రతి దిశలో మీరు ఈ పరీక్షను అనేకసార్లు run చేస్తారు.

సూచనా గణాంకాలు మరియు మీ ఫలితాన్ని ఎలా చదవాలి

చార్ట్Typical published 4k random read IOPS by storage class
ఈ చార్ట్ వెనుక ఉన్న డేటా
[
  {
    "device": "Local NVMe",
    "iops_4k_read": "180,000"
  },
  {
    "device": "Local SATA SSD",
    "iops_4k_read": "90,000"
  },
  {
    "device": "Network block",
    "iops_4k_read": "12,000"
  },
  {
    "device": "Spinning disk",
    "iops_4k_read": "180"
  }
]

ప్రచురిత ఫలితాల్లో స్థానిక NVMe volume సాధారణంగా 180,000 4k random read IOPSకు సమీపంగా ఉంటుంది. స్థానిక SATA SSD సాధారణంగా 90,000 వద్ద ఉంటుంది. Network-attached block storageలో ప్రతి request diskకు చేరే ముందు network గుండా వెళ్తుంది. అందువల్ల ఇది సాధారణంగా 12,000కు సమీపంగా ఉంటుంది. Spinning disk సుమారు 180 IOPS నిర్వహిస్తుంది, ఎందుకంటే ప్రతి random request కోసం అది physical headను కదిలించాలి.

ఇవి ప్రతి storage వర్గానికి సాధారణంగా ప్రచురించే గణాంకాలు మాత్రమే. ఇవి ఒకే host నుంచి తీసిన measurements కావు. మీ స్వంత ఫలితం అదే order of magnitudeలో ఉందో లేదో తనిఖీ చేయడానికి మాత్రమే వీటిని ఉపయోగించండి. NVMeగా విక్రయించే plan 4k IOPSలో కొన్ని వేల స్థాయిలో benchmark ఫలితాన్ని ఇస్తే, ముందుగా --direct=1 onలో ఉందో నిర్ధారించండి. అది onలో ఉంటే, storage contention మరియు ప్రకటించిన hardwareతో పాటు plan యొక్క IOPS limits, burst creditsను కూడా తనిఖీ చేయండి.

ఒకసారి చేసిన పరీక్ష benchmark కాదు

ఒకే ఫలితం shared machine పై ఒక నిమిషానికి సంబంధించిన snapshot మాత్రమే. దాన్ని ఒక sample గా పరిగణించండి.

  • ప్రతి పరీక్షను కనీసం ఐదుసార్లు, వేర్వేరు గంటల్లో మరియు కనీసం రెండు వేర్వేరు రోజుల్లో నిర్వహించండి. Median మరియు spread ను నమోదు చేయండి. Spread లేకుండా ప్రచురించిన ఫలితం marketing figure మాత్రమే.
  • ప్రతి run పక్కన steal time ను నమోదు చేయండి. st ఎక్కువగా ఉన్న runs ను తొలగించకుండా ఉంచి, అవి contention ను ప్రతిబింబిస్తున్నాయా లేదా plan యొక్క CPU quota కారణంగా వచ్చాయా పరిశీలించండి. వాటిని తొలగిస్తే మీరు వాస్తవంగా పొందుతున్న పనితీరు దాగిపోవచ్చు.
  • Disk test ను రెండు durations తో నిర్వహించండి. అనేక plans కాలక్రమేణా refill అయ్యే burst IOPS allowance ను అందిస్తాయి. అయితే 60 second fio run లేదా --runtime=600 ద్వారా కొలిచిన ఫలితం కనిష్ఠ స్థాయి అని నిర్ధారించలేరు. AWS gp2 పూర్తి balance నుంచి కనీసం 30 minutes పాటు 3,000 IOPS ను sustain చేయగలదు. అందువల్ల రెండు runs కూడా burst performance ను కొలవవచ్చు. ఒక ఫలితాన్ని sustained performance గా పరిగణించే ముందు provider యొక్క credit model ను పరిశీలించి, credit balance ను monitor చేయండి.
  • మరేదీ నడవడం లేదని నిర్ధారించండి. CPU test మధ్యలో unattended-upgrades apt transaction ప్రారంభిస్తే నిజమైన points తగ్గుతాయి. ప్రతి run కు ముందు ps -e -o comm= | grep -E 'apt|dpkg' చేయడానికి ఒక second పడుతుంది.
  • ఒకసారి ఒక variable మాత్రమే మార్చండి. Tool versions, block sizes లేదా thread counts వేర్వేరుగా ఉంటే, అవి ఎంత సమానంగా కనిపించినా వాటి numbers ను పోల్చలేరు.

రెండు providers ను పోల్చేటప్పుడు, అదే రోజు అదే గంటలో వాటిపై tests నిర్వహించండి. లేకపోతే మీరు కొలిచింది time of day మాత్రమే అవుతుంది.

మీ స్వంత workload ను చివరగా benchmark చేయండి

Synthetic tools యంత్రాల పనితీరు క్రమాన్ని చూపుతాయి. కానీ ఒక యంత్రం సరిపోతుందో లేదో మీ స్వంత workload మాత్రమే చెబుతుంది. మీరు నిజంగా చేసే పనికి పట్టే సమయాన్ని కొలవండి.

time tar -czf /tmp/bench.tgz /usr/share
rm -f /tmp/bench.tgz

ఇది కొన్ని వందల megabytes ను compress చేస్తుంది. అందువల్ల CPU మరియు disk రెండింటినీ ఒకేసారి ఉపయోగిస్తుంది. వీటిలో ఏది మారినా ఫలితం మారుతుంది. Removing leading / from member names warning సాధారణమే. ఇంకా మంచిది, మీ స్వంత build, మీకు ఎక్కువ సమయం పట్టే query లేదా మీ స్వంత page render కు పట్టే సమయాన్ని కొలవండి. ఒక host పై build పూర్తవడానికి 4 minutes, మరో host పై 7 minutes పడితే, Geekbench ఏం చెప్పినా నిర్ణయం స్పష్టమవుతుంది. మరింత శక్తివంతమైన machine కోసం చెల్లించడం ఎప్పుడు ప్రయోజనకరం కాదో కూడా ఈ కొలత చెబుతుంది. VPS కు వాస్తవంగా నెలకు ఎంత ఖర్చవుతుందో చదవడానికి లేదా workload ను dedicated server పైకి మార్చడానికి ముందే ఇది తెలుసుకోవడం ఉపయోగకరం.

FAQ

ప్రతి సారి benchmark అమలు చేసినప్పుడు ఫలితం ఎందుకు మారుతుంది?

ఒక VPS భౌతిక CPU, storage మరియు network వనరులను ఇతర tenants తో పంచుకుంటుంది. అందువల్ల ఆ సమయంలో వారు చేస్తున్న పనిపై మీ ఫలితం ఆధారపడి ఉంటుంది. పరీక్ష సమయంలో vmstat 1 అమలు చేసి, st column ను చూడండి. నిరంతర steal time అందుబాటులో లేని CPU సమయాన్ని నమోదు చేస్తుంది. అయితే provider మీకు కొనుగోలు చేసిన CPU allocation ను అమలు చేయడం వల్ల కూడా ఇది కనిపించవచ్చు. Host contention కూడా కారణం కావచ్చు. 5% కంటే ఎక్కువ విలువ కనిపించడం మాత్రమే కారణాన్ని నిర్ధారించదు. దీనికి tuning కంటే సరైన పద్ధతి ముఖ్యం. ప్రతి పరీక్షను వేర్వేరు గంటల్లో ఐదు లేదా అంతకంటే ఎక్కువ సార్లు అమలు చేయండి. తరువాత spread తో పాటు median ను నివేదించండి.

fio లక్షల IOPS ను ఎందుకు చూపిస్తుంది?

దాదాపు ఎల్లప్పుడూ --direct=1 లేకపోవడం కారణం. ఇది లేకపోతే fio kernel page cache ద్వారా చదువుతుంది. అందువల్ల మొదటి pass తర్వాత 2G test file RAM నుంచి అందించబడుతుంది. అప్పుడు మీరు కొలిచింది storage పనితీరు కాదు, memory bandwidth. --direct=1 ను జోడించండి. Test file ను path లోని ఏ cache కంటే పెద్దదిగా ఉంచండి. --direct=1 విఫలమైతే, df -hT . అమలు చేసి test file ఏ storage పై ఉందో తనిఖీ చేయండి. overlay type ఉండటం ఒక్కటే సమస్య కాదు. ఎందుకంటే overlayfs O_DIRECT ను దిగువన ఉన్న storage కు pass చేస్తుంది. కింద ఉన్న filesystem direct IO ను నిరాకరిస్తే మాత్రమే test file ను నిజమైన local storage కు తరలించండి.

yabs.sh ఒక్కటే సరిపోతుందా?

మొదటి పరిశీలనకు సరిపోతుంది. ఇది నాలుగు block sizes వద్ద fio ను, రెండు దిశల్లో iperf3 ను, అలాగే Geekbench ను అమలు చేస్తుంది. ఇతరులు చదవగలిగే ఒక summary ను కూడా ముద్రిస్తుంది. అయితే ఒక సంఖ్యకు కారణం ఏమిటో తెలుసుకోవాలనుకున్నప్పుడు ఇది సరిపోదు. ప్రతి test కు దాని flags ను విడిగా మార్చలేరు. yabs ఫలితం తప్పుగా కనిపించినప్పుడు, దాన్ని fio లేదా sysbench తో నేరుగా పునరావృతం చేయండి. ఒక్కోసారి ఒక flag మాత్రమే మార్చండి.

నా అప్లికేషన్ పనితీరు ఎలా అనిపిస్తుందో అంచనా వేయడానికి ఏ ఒక్క సంఖ్య ఉపయోగపడుతుంది?

చాలా web మరియు database workloads కు, ముందుగా single core CPU speed, తరువాత 4k random read latency ముఖ్యమైనవి. Throughput సంఖ్యలు ఆకట్టుకునేలా కనిపించినా సాధారణంగా నిర్ణయాత్మకంగా ఉండవు. కారణం, సాధారణ request చిన్నదిగా ఉంటుంది. సగటుకు బదులుగా fio clat percentiles block నుంచి 99th percentile ను ఇవ్వండి. ప్రతి వంద requests లో నెమ్మదిగా ఉండే ఒక request ను user గమనిస్తాడు.

Benchmarking కు ముందు ఏదైనా install చేయాలా?

fio, sysbench మరియు iperf3 Ubuntu మరియు Debian archives లోనే ఉన్నాయి: sudo apt install -y fio sysbench iperf3. yabs.sh Bash లో నడుస్తుంది. Downloads కోసం దీనికి curl లేదా wget అవసరం. Geekbench ను extract చేయడానికి tar అవసరం. tar లేకపోతే ఇది Geekbench ను skip చేస్తుంది. fio మరియు iperf3 install అయి ఉంటే వాటినే ఉపయోగిస్తుంది. అవి లేకపోతే static binaries ను download చేస్తుంది. పూర్తయిన తర్వాత ప్రతి test file ను delete చేయండి. 20G disk పై మిగిలిపోయిన 2G fio file, కొన్ని వారాల తరువాత disk full alert కు కారణమవుతుంది.

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

#benchmarks#fio#sysbench#yabs#iperf3#vps-performance