CPU overcommit

On this page 7

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.

MechanismWhat it doesEffect under contention
Time slicingRotates vCPUs on a physical coreAdds queueing delay per vCPU
Shares or weightsSets relative priority between VMsFavored VMs get cores first
ReservationsGuarantees a minimum of CPU capacityProtects critical VMs from starvation
Limits or capsSets a ceiling on CPU consumptionPrevents one VM from dominating
Co-schedulingRuns sibling vCPUs of one VM togetherWide VMs wait longer for free cores
Scheduler mechanisms that shape overcommit behavior

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 classCommon vCPU to core ratioReason
Latency-sensitive databases1:1 or no overcommitSustained load and strict response times
General server workloads2:1 to 4:1Moderate, uneven utilization
Virtual desktops (VDI)4:1 to 10:1Bursty, mostly idle user sessions
Development and test VMs6:1 to 12:1Long idle periods, tolerant users
Burstable cloud instancesGoverned by CPU creditsBaseline share plus earned bursts
Typical overcommit ratios by workload class

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.

IndicatorTypical healthy rangeWarning sign
CPU ready per vCPUBelow 5 percentAbove 10 percent sustained
Guest steal timeBelow 2 to 5 percentPersistent double digits
Co-stop (wide VMs)Near zeroAbove 3 percent
Host CPU utilizationBelow about 80 percentNear 100 percent with rising ready time
Contention indicators and their usual interpretation

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.

ConceptWhat is shared or promisedFailure mode when exhausted
CPU overcommitProcessor time across vCPUsQueueing delay and latency
Memory overcommitRAM pages across guestsSwapping, ballooning, guest kills
Storage thin provisioningDisk capacity across volumesWrite failures when the pool fills
CPU pinningDedicated cores per vCPUNo sharing, so no contention
Nested virtualizationHardware support for inner hypervisorsCompounded scheduling overhead
CPU overcommit versus neighboring concepts

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.