High Linux Load? Check What’s Waiting Before Adding CPUs
High Linux load with idle CPU can point to waiting tasks. Use vmstat, thread states and pressure signals to choose the next investigation before buying more capacity.
RB
Imagine an export job slowing down just as a backup starts on your Linux server. The load average has climbed, but the CPU chart still shows idle time. You’re considering a larger VM because the current one looks overloaded.
Before buying more CPUs, find out what the tasks are waiting for. Linux load average includes runnable tasks and tasks in uninterruptible sleep; it isn’t a CPU-utilization percentage. Compare task states, resource pressure and application performance during the same busy window. That gives you a reason to choose CPU, memory or an I/O investigation instead of guessing from one number.
This is a hypothetical troubleshooting scenario, not a Krova customer incident or a benchmark. The commands below are read-only guidance for a Linux guest with procps tools and /proc available. They have not been executed against a customer server.
Start with the time window, not a threshold
The first three values in /proc/loadavg describe load over one, five and fifteen minutes. The Linux manual explains that the count includes tasks ready to run as well as tasks in uninterruptible wait. A high number tells you there is work running or waiting; it doesn’t identify the scarce resource.
In our export example, comparing a five-minute load value with a CPU chart from after the backup ended could create a false mystery. Write down when the export slowed, which input it processed and whether request latency or job completion time actually worsened. Then collect observations while that workload is happening.
TZ=Asia/Kolkata date -Is
cat /proc/loadavg
vmstat 1 6This short sample is a starting view, not a complete workload measurement. In procps vmstat, the first report’s rate statistics summarize time since boot; subsequent reports cover the sampling interval. Process and memory values are instantaneous. Don’t mistake the first CPU/I/O rates for the last second’s behavior.
Watch r for runnable processes and b for processes blocked waiting for I/O. Read those alongside the CPU columns: us and sy account for user and kernel execution, while id accounts for idle time. These are clues to compare over repeated intervals, not a universal pass/fail test based on load divided by vCPU count.
Give the wait a name
If the guest remains partly idle while the load stays elevated, inspect its threads during the slowdown:
ps -eLo pid,tid,stat,wchan:32,commThis procps ps view includes thread IDs, state and the kernel wait location when visible. R means running or runnable. D is uninterruptible sleep, usually associated with I/O. The wchan name can point toward the path a sleeping task is in, but it doesn’t establish the root cause.
Repeated D observations deserve investigation; they don’t, by themselves, prove a disk fault or a provider problem. A single snapshot can miss a short wait, and unavailable wait-location information is a visibility limit. Keep process names and thread IDs with your timestamps so you can connect the observation to the export or backup rather than an unrelated service.
Use the same restraint with I/O-wait CPU accounting. The kernel’s /proc documentation describes limitations in interpreting iowait. It isn’t the percentage of your requests waiting for storage. Don’t turn one CPU column into an application diagnosis.
Check whether resource waits overlap the slowdown
Where the kernel exposes Pressure Stall Information, read the three resource files:
cat /proc/pressure/cpu
cat /proc/pressure/io
cat /proc/pressure/memoryThe kernel PSI documentation defines some as time when at least some tasks are stalled on that resource. Its avg10, avg60 and avg300 values are percentage trends over ten, sixty and three hundred seconds. They help distinguish resource waits from a load number that combines different task states.
For a system-wide CPU reading, use some: CPU full is undefined at that level and is reported as zero for compatibility. If a pressure file is absent or unreadable, record that limit. It doesn’t mean pressure is zero. Guest-level readings also cannot explain every delay in an external database, network service or application queue.
Choose the next investigation from the combination
Return to the export that started this investigation. These are suggested next steps, not diagnoses established by one sample:
- Runnable work, busy CPUs and CPU pressure rise together while useful throughput falls: investigate CPU demand and concurrency. If the app is containerized, check its CPU ceiling before choosing a bigger guest; Krova’s Docker CPU throttling guide covers that narrower case.
- Repeated blocked tasks and I/O pressure accompany the slowdown while CPUs have idle time: trace the waiting task’s I/O path. Check which job and resource are involved before assuming more CPUs will help.
- Memory pressure appears alongside swapping activity: investigate memory headroom and the working set. Use the Linux VM memory guide for that sizing decision.
- Load is elevated but current intervals and application outcomes are healthy: collect another representative busy window. A historical burst or unrelated background job may explain the mismatch.
- The application is slow with little visible local pressure: follow its own timings into dependencies, locks and queues. These guest observations leave that part of the investigation open.
The useful distinction is whether extra CPU addresses an observed constraint. More runnable work can justify a CPU experiment; more waiting on another resource calls for a different experiment. Neither is a promise that a larger VM will improve the export.
Make the capacity decision reviewable
Before changing the server, leave a short record that another operator can follow:
- Name the user-visible problem: slow exports, request latency or another concrete outcome.
- Record the matching workload window and input, including competing jobs such as the backup.
- State the suspected constraint and the observations supporting it, plus anything you couldn’t inspect.
- Choose one controlled change in a suitable test environment and define the application outcome that would justify keeping it.
Repeat a comparable workload after that change. If you change job concurrency and VM size together, you lose the ability to tell which mattered. A lower load average alone also doesn’t show that the application became more useful or less expensive.
For a self-managed Krova Cube, this is a practical way to approach sizing: measure the Linux workload you operate, then choose resources around the constraint you can explain. In our hypothetical, the first worthwhile result is a defensible next step—not an unverified claim that the export needs more CPUs.
Choose Cube resources with a workload in mind
Review Cube’s compute options, then bring your busy-window observations to the sizing decision.
Creation note: This article and its conceptual cover were created with AI assistance from the linked sources. The scenario is hypothetical, and no customer testing, measured performance improvement or human review is claimed.




