Why about half of a Mac's CPU energy has no owner
Updated 11 November 2026 · Who measures this.
Because macOS's energy counter for a process dies with the process, and the kernel's own work has no process at all. Sampling live processes names about half of CPU energy. A kernel ledger that outlives the task names more, most of all on a busy Mac. What stays without a name is kernel work, daemons we can't read and tasks with no survivor. This page is written for people building the same kind of tool.
| Mac | What it was doing | Windows | Named by live processes | Named with the ledger |
|---|---|---|---|---|
| 14-inch MacBook Pro, M3 Max | Xcode, a coding agent and a busy browser | 548 | 42% | 59% |
| 14-inch MacBook Pro, M1 Pro | Quieter everyday use, in 4 stretches | 1,026 | 48 to 56% | 49 to 56% |
Each stretch is about 2 days of everyday use on battery, from the app's own records. The M1 Pro's 4 stretches are spread over 86 days, and in none of them did the ledger add more than 1 point.
Why does per-process sampling miss energy?
Per-process attribution starts at proc_pid_rusage(pid, RUSAGE_INFO_V6).ri_energy_nj. Sample every few seconds, diff by matching pid,
and you have energy per process. What you do not have is anything that lived and died between 2 samples.
A Swift build makes the mechanism obvious: 161 distinct swift-frontend pids across 164 windows. Each one compiled something,
used power and was gone before the next sample, and all of it landed in a row labelled "system, no owner".
Does the load change it?
Yes, when the load is work that starts many short processes, such as a build. The M3 Max, running Xcode and a coding agent, is the example below: the ledger gave back 11 to 15 points below 8 W on the CPU energy channel and 26 to 43 points above it, though only 28 windows got that far, while live processes stayed near 40% from 1 W up. On the quieter M1 Pro the ledger added under 1 point over each stretch.
| CPU energy channel | Windows | Live processes | With the ledger |
|---|---|---|---|
| under 1 W | 63 | 53% | 65% |
| 1 to 2 W | 110 | 42% | 57% |
| 2 to 4 W | 205 | 41% | 52% |
| 4 to 8 W | 142 | 43% | 58% |
| 8 to 16 W | 23 | 42% | 68% |
| 16 to 32 W | 5 | 38% | 81% |
Where does a dead process's energy go?
XNU groups tasks into a coalition: the application, its helpers, its XPC services, its forks and every descendant. The coalition carries a
ledger, and when a task dies, its energy stays there. powermetrics --show-process-coalition reads the same ledger through the same syscall, and Chrome calls it in shipping builds. No root, no entitlement.
There is no public header, so the 3 calls go through dlsym:
| Call | What it gives |
|---|---|
proc_listcoalitions(1, 0, buf, sz) | Every resource-type coalition, including the empty ones |
coalition_info_resource_usage(cid, buf, 512) | The ledger itself |
proc_pidinfo(pid, 20, …) | Which coalition a pid belongs to |
Why do empty coalitions matter?
The obvious way to enumerate coalitions is to walk live pids and collect the coalitions they belong to. Chromium does exactly that. It loses the case that matters: an application whose every process has already exited. Counted on a live machine: 1600 coalitions, of which only 729 had a live task. The other 871 carry the energy of processes that no longer exist.
Who gets the energy of tasks that died?
Per coalition, per tick: take the ledger delta, subtract the sum of deltas from its own live members, and what remains belonged to tasks that died. Give it to the coalition leader rather than splitting it across members, because the work was caused by the application as a whole and belongs in its row.
2 rules keep that honest. A coalition seen for the first time cannot be booked whole: its counter has been running since before you were watching, so the first sighting sets a baseline and books nothing. And the leader has to be chosen deliberately, not taken as whichever member happened to be enumerated first.
What stays without a name?
Kernel work, daemons under another user and coalitions with no survivor. kernel_task gives no reading through
proc_pid_rusage, daemons running under another uid cannot be read by an app, and once every member of a coalition has died there is no name
left to give its energy to. Handing that to the neighbours would charge a row for work it did not do, so WattMate keeps it in a row of its own.
What does reading the ledger cost?
About 2 ms per tick, on top of the 0.95 ms already spent walking proc_pid_rusage: proc_listcoalitions takes 0.089 ms and
reading 1600 ledgers takes 2.0 ms. At our sampling rate that is a tiny fraction of one core, and it wakes no new timer.
The rule this broke
The old invariant was that a row never receives more energy than its own counter recorded. That rule is what produced the hole: it is correct per process and wrong per application, because an application is not one process. Chrome held a median of 16 to 29 processes across our runs, peaking at 47.
How it was measured
| The shares in both tables | WattMate's own records on battery, completed windows with the CPU energy channel measured: 548 on a 14-inch MacBook Pro with M3 Max on macOS 26.5, and 1,026 on a 14-inch MacBook Pro with M1 Pro on macOS 26.3, in 4 stretches. A share divides energy by energy in the same window. |
| Live processes | The sum of the per-process counters in a window, without what the ledger returned. |
| Coalitions, the build and the cost of reading | One session on the 14-inch MacBook Pro with M3 Max, then on macOS 15: the 1600 coalitions, the 161 build processes and the timings of the calls. |
What this doesn't show
- A Mac doing nothing. These are windows of everyday use on battery. In the quietest fifth of them the CPU channel ran at 0.3 to 1.1 W, but apps were open.
- macOS 27. There the CPU counter advances in bursts minutes apart, so a single window cannot be split this way.
- Why the ledger gave the M1 Pro so little. We have not found out.
- Graphics. macOS gives a total for GPU energy and no owner for it, so any split between apps is inferred from a per-app GPU counter that macOS names accumulated GPU time, though it measures neither energy nor how long the GPU was busy. How we count says so, and has the rest of the method, including the parts that stay unsolved.
- The App Store version. The ledger is in the direct download. In the App Store version rows miss helpers that start and finish between 2 readings.
Related: what each app actually costs, measured · watts by workload · what macOS means by "using significant energy" · all the guides
See per-app energy measured this way
10 days free, no card · Requires macOS 14 or later · Apple silicon