CPU overcommit is the practice of allocating more virtual CPUs (vCPUs) than physical CPU cores or threads on a host, so that the total processing capacity promised to virtual machines exceeds what the hardware can deliver at once. In virtualization and in cloud platforms, it works because most workloads are idle most of the time, and the hypervisor scheduler can time-slice physical cores among many vCPUs.
The technique raises consolidation density and lowers cost per workload, but it trades away guaranteed performance. When too many vCPUs want to run simultaneously, they wait in the scheduler queue, and that waiting surfaces as CPU ready time, latency spikes and inconsistent throughput.
How the hypervisor schedules overcommitted vCPUs
A hypervisor treats each vCPU as a schedulable entity, similar to a thread in an operating system, and maps it onto a physical core or hardware thread only when the guest has work to do. When a guest executes a halt instruction because it is idle, the hypervisor deschedules the vCPU and gives the physical core to another one that is ready to run.
Overcommit is therefore not a fixed partition but a statistical bet on demand. The scheduler, such as the ESXi CPU scheduler, the Linux Completely Fair Scheduler used by KVM, or the Xen credit scheduler, divides time into slices measured in milliseconds. As long as the aggregate demand stays below physical capacity, every vCPU runs almost as soon as it becomes ready, and the overcommit is invisible to the guests.
Contention appears when demand exceeds supply. A ready vCPU that cannot get a core waits, and the guest experiences this as stolen time: its clock advances while its code does not run. Linux guests report this as steal in tools such as top, while VMware reports it as CPU ready and Hyper-V exposes a comparable metric called CPU wait time per dispatch.
The following table summarizes the main scheduler mechanisms that determine how overcommit behaves under load.
| Mechanism | What it does | Effect under contention |
|---|---|---|
| Time slicing | Rotates vCPUs on a physical core | Adds queueing delay per vCPU |
| Shares or weights | Sets relative priority between VMs | Favored VMs get cores first |
| Reservations | Guarantees a minimum of CPU capacity | Protects critical VMs from starvation |
| Limits or caps | Sets a ceiling on CPU consumption | Prevents one VM from dominating |
| Co-scheduling | Runs sibling vCPUs of one VM together | Wide VMs wait longer for free cores |
Overcommit ratios and how to measure contention
The overcommit ratio is the total number of vCPUs on a host divided by the number of physical cores, written as a value such as 4:1. Whether hyperthreads count as cores varies between operators, so a ratio is only meaningful when the counting method is stated. A simultaneous multithreading sibling typically adds roughly 10 to 30 percent throughput, not a full core.
Ratios alone do not predict performance, because the same ratio can be harmless for idle desktops and harmful for busy databases. The decisive metric is measured contention, chiefly CPU ready or steal time. The ranges below are widely used rules of thumb rather than formal standards, and the right tolerance depends on the application.
| Workload class | Common vCPU to core ratio | Reason |
|---|---|---|
| Latency-sensitive databases | 1:1 or no overcommit | Sustained load and strict response times |
| General server workloads | 2:1 to 4:1 | Moderate, uneven utilization |
| Virtual desktops (VDI) | 4:1 to 10:1 | Bursty, mostly idle user sessions |
| Development and test VMs | 6:1 to 12:1 | Long idle periods, tolerant users |
| Burstable cloud instances | Governed by CPU credits | Baseline share plus earned bursts |
Monitoring should track contention per VM, not only the host average, because a single busy neighbor can degrade others while host utilization still looks acceptable.
| Indicator | Typical healthy range | Warning sign |
|---|---|---|
| CPU ready per vCPU | Below 5 percent | Above 10 percent sustained |
| Guest steal time | Below 2 to 5 percent | Persistent double digits |
| Co-stop (wide VMs) | Near zero | Above 3 percent |
| Host CPU utilization | Below about 80 percent | Near 100 percent with rising ready time |
CPU overcommit compared with related resource techniques
CPU overcommit is one of several resource overcommitment techniques, and it is the most forgiving of them. Excess CPU demand produces slowness, not failure, because a waiting vCPU simply runs later. Memory overcommit is riskier, since exhausting physical memory forces ballooning, compression, swapping or, in the worst case, the termination of guests.
| Concept | What is shared or promised | Failure mode when exhausted |
|---|---|---|
| CPU overcommit | Processor time across vCPUs | Queueing delay and latency |
| Memory overcommit | RAM pages across guests | Swapping, ballooning, guest kills |
| Storage thin provisioning | Disk capacity across volumes | Write failures when the pool fills |
| CPU pinning | Dedicated cores per vCPU | No sharing, so no contention |
| Nested virtualization | Hardware support for inner hypervisors | Compounded scheduling overhead |
CPU pinning is the opposite policy: it binds a vCPU to a specific physical core and removes overcommit entirely, which suits real-time and network function workloads. Live migration complements overcommit by letting operators move busy VMs to quieter hosts when contention builds.
Sizing VMs and setting policy on overcommitted hosts
The most effective control is right-sizing virtual machines. A VM with eight vCPUs that uses only one still forces the scheduler to manage eight entities, and on hypervisors that use relaxed co-scheduling, wide VMs can suffer co-stop delays while waiting for enough free cores. Assigning the smallest vCPU count that meets peak demand usually improves performance on a shared host.
- Group workloads with complementary peak times on the same host or cluster.
- Use reservations or dedicated hosts for latency-critical services instead of tightening the global ratio.
- Keep VMs within one NUMA node where possible, because crossing nodes adds memory latency.
- Leave headroom for failover, since a host failure moves its VMs onto survivors and raises their ratios.
- Review contention metrics after every major change rather than relying on a ratio chosen once.
Public cloud providers apply the same principle commercially. Burstable instance families grant a baseline share of a core and accumulate credits during idle periods, while dedicated or metal instances remove sharing for tenants who need predictable performance.
Risks and common misconceptions
The main risk is noisy-neighbor interference: one VM that runs a CPU-heavy job can raise ready time for every other guest on the host. Because the guests cannot see each other, the symptoms often look like application bugs, such as timeouts, jitter in response times and garbage collection pauses that last longer than expected.
- Adding vCPUs to a slow VM on a contended host often makes it slower, because it raises scheduling pressure.
- Low average host utilization does not prove the absence of contention; short bursts can still queue.
- Guest-reported CPU usage is unreliable under overcommit, since stolen time distorts the guest view.
- Timing-sensitive software, such as audio processing or trading engines, may misbehave even at modest ratios.
Put simply
CPU overcommit is like a restaurant that takes more reservations than it has tables, knowing that diners arrive at different times and many leave early. Most evenings everyone is seated without a wait. On a busy night, some guests stand by the door until a table frees up.
A server does the same with its processor cores. It promises more virtual processors than it physically has, because most programs sit idle much of the time. The benefit is lower cost; the price is occasional waiting when everyone needs the processor at once.
In practice
A university IT team runs 120 virtual desktops for a computer lab on three hosts, each with 32 physical cores. Every desktop has two vCPUs, so the cluster carries 240 vCPUs on 96 cores, a ratio of 2.5:1. During lectures, students mostly read documents and browse, and CPU ready time stays below 2 percent.
Problems begin in exam week, when every student compiles code at once. Ready time climbs above 15 percent, and desktops freeze for seconds. The team reacts by moving a build server off the cluster, setting shares that favor lab desktops, and keeping one host’s worth of capacity in reserve. With those changes, ready time stays under 5 percent even at peak, and the lab avoids buying a fourth host.