A typical VPS gives you fair-share vCPUs: your virtual cores are scheduled onto physical cores that other tenants also use, so you get a fair slice of CPU time plus some burst headroom. A VDS gives you reserved physical cores: specific cores are pinned to your machine and never run anyone else's work. Inside the guest you can't see the pinning directly, but the CPU model, the instruction flags and the steal time give you a reliable picture, and the commands are below.
Both are virtual machines
Start with what doesn't change. On most modern providers, a VPS and a VDS are both full KVM virtual machines. Each runs its own kernel, gets its own RAM allocation and its own disk, and you have root. If you run a detection tool on either, you get the same answer:
systemd-detect-virt
# kvm
So "VPS" vs "VDS" is not about the kind of virtualization. It is about how the host's scheduler treats your vCPUs.
Fair-share vCPU: what it means
On a fair-share host, each guest vCPU is just a thread on the host. The host's Linux scheduler moves those threads across physical cores and gives every tenant a fair share of CPU time. When neighbours are quiet, you can often use more than your "share" for a while (burst headroom). When they are busy, your vCPU sometimes has to wait for a physical core to free up.
That waiting has a name: steal time. It's the time your vCPU was ready to run but the hypervisor was running something else. The guest kernel counts it, so you can measure it.
Fair-share hosts also tend to expose a generic virtual CPU model to guests. That lets a VM live-migrate between hosts with different hardware, but it also means some instruction-set extensions may be hidden from you.
None of this makes a VPS bad. Most web workloads are bursty: a request comes in, a core works for a few milliseconds, then everything goes idle. Fair-share scheduling is very good at that, and it's why a VPS costs less.
Reserved cores: what it means
On a VDS, specific physical cores are pinned to your VM. The host never schedules another tenant's work on them. Two things follow from that:
- Your CPU time doesn't depend on what the neighbours are doing. A job that takes 40 seconds at 3 p.m. should still take about 40 seconds at 3 a.m.
- Because the VM is tied to known hardware, the provider can pass through the host CPU model with its full instruction set. If the hardware supports AVX2, your code can use it.
Here's the honest caveat that marketing pages tend to skip. Pinned cores aren't the same as bare metal. On the same host you still share the L3 cache, memory bandwidth, disks and network with other VMs, so a memory-heavy neighbour can still affect a cache-sensitive workload. What you get is consistency, not extra peak speed. A reserved core isn't faster than a fair-share vCPU on an idle host. It just behaves the same way every minute of the day.
How to check what you actually have
You can't run ls /proc/pinning from inside the guest. You collect evidence instead. Run these on the server you're paying for.
1. CPU model
lscpu | grep -E 'Model name|Hypervisor vendor|Virtualization type'
On a generic-model VPS you'll often see something like QEMU Virtual CPU, Common KVM processor or a family-level name with no specific SKU. With host passthrough you'll usually see the real part name, the same string you'd get on bare metal. A real model name is a good sign but doesn't prove pinning, because some fair-share providers pass the host model through as well.
2. Instruction-set flags
If your software needs AVX2, AES-NI or AVX-512 (video encoders, compression tools, some databases and ML libraries do), check for the flags directly:
grep -m1 -o -w -E 'avx2|avx512f|aes|sha_ni' /proc/cpuinfo | sort -u
-m1 stops after the first CPU's flags line, and -o -w prints each matching flag on its own line. If avx2 is missing, that software falls back to a slower code path or refuses to start. That matters more than any core count on the order page.
3. Steal time, right now
top shows steal as st on the %Cpu(s) line:
%Cpu(s): 12.3 us, 2.1 sy, 0.0 ni, 83.9 id, 0.2 wa, 0.0 hi, 0.1 si, 1.4 st
vmstat 1 has an st column too, and mpstat -P ALL 1 (from the sysstat package) breaks %steal down per vCPU.
4. Steal time over a window
A single glance at top can mislead you. This snippet reads the cumulative counters in /proc/stat twice and works out the steal percentage between the two reads. The first eight fields on the cpu line are user, nice, system, idle, iowait, irq, softirq and steal:
read -r _ u n s i w q sq st _ < /proc/stat
sleep 60
read -r _ u2 n2 s2 i2 w2 q2 sq2 st2 _ < /proc/stat
t1=$((u+n+s+i+w+q+sq+st)); t2=$((u2+n2+s2+i2+w2+q2+sq2+st2))
awk -v d=$((st2-st)) -v t=$((t2-t1)) 'BEGIN { printf "steal: %.2f%%\n", 100*d/t }'
Run it while your real workload is busy, and at different times of day. A quiet VM shows close to zero steal on almost any host, because nothing is waiting to run.
5. Run-time consistency
Steal tells you about waiting. Consistency tells you whether the waiting matters. Time the same fixed amount of work a few times (needs bc; run it in bash, which has time built in, so nothing else to install):
TIMEFORMAT='%R s'
for i in 1 2 3 4 5; do
time bc -l <<< "scale=3000; 4*a(1)" > /dev/null
done
Repeat it at a busy hour and a quiet hour. On reserved cores the times should be tight. On a fair-share VPS they usually are too, but if they spread out when steal goes up, you've found the reason.
Quick reference
| Check | Fair-share VPS (typical) | Reserved-core VDS (typical) |
|---|---|---|
systemd-detect-virt |
kvm |
kvm |
lscpu model name |
Generic virtual model | Real host CPU model |
/proc/cpuinfo flags |
May hide AVX2 and newer extensions | Host's full set (e.g. avx2) |
Steal under load (st) |
Usually low, can rise when neighbours are busy | Should stay at or near zero |
| Repeated job timings | Can spread when the host is busy | Tight |
| Still shared | CPU time, cache, memory bandwidth, disk, network | Cache, memory bandwidth, disk, network |
When to pick which
- Most websites, APIs, staging boxes and small databases: a VPS. The load is bursty and fair-share handles it well.
- Steady, CPU-bound work (transcoding, heavy cron and batch jobs, ERP or accounting software where users notice slow screens, CI runners that must finish on time): a VDS.
- Software that needs a specific instruction set: check the flags first. If the VPS hides them, you need host passthrough.
- Memory-bound work: more cores won't fix it. Look at RAM and memory bandwidth instead.
- Not sure yet? Start on a VPS, run the steal and timing checks under real load, and move only if the numbers say so.
Where we fit
Disclosure: this was written by the Bigdomainhost team. We're an Indian hosting provider launched in September 2026 (not connected with the US company Big Domain Host LLC).
We sell both products from data centres in Mumbai and Delhi NCR, and the split is the one described above. Our KVM VPS plans use fair-share vCPUs with a generic CPU model, reserved RAM and local NVMe. Our VDS plans with pinned physical cores expose the host CPU model and its full instruction set, with the same caveat about shared cache, memory bandwidth, disk and network. The advice we give customers is the last bullet above: run it on a VPS first, and move to a VDS if steal or uneven run times show up in your monitoring. If you're comparing providers in India more broadly, we also keep a VPS buying checklist for India that covers what to ask any host, us included.
If you'd rather not paste these commands one by one, we put the same checks into a small free script: vcpu-check on GitHub.
Top comments (0)