On Tue, 13 Jan 2026 14:47:34 -0500 Mathieu Desnoyers mathieu.desnoyers@efficios.com wrote:
Use the precise, albeit slower, precise RSS counter sums for the OOM killer task selection and proc statistics. The approximated value is too imprecise on large many-core systems.
Thanks.
Problem: if I also queue your "mm: Reduce latency of OOM killer task selection" series then this single patch won't get tested, because the larger series erases this patch, yes?
Obvious solution: aim this patch at next-merge-window and let's look at the larger series for the next -rc cycle. Thoughts?
The following rss tracking issues were noted by Sweet Tea Dorminy [1], which lead to picking wrong tasks as OOM kill target:
Recently, several internal services had an RSS usage regression as part of a kernel upgrade. Previously, they were on a pre-6.2 kernel and were able to read RSS statistics in a backup watchdog process to monitor and decide if they'd overrun their memory budget. Now, however, a representative service with five threads, expected to use about a hundred MB of memory, on a 250-cpu machine had memory usage tens of megabytes different from the expected amount -- this constituted a significant percentage of inaccuracy, causing the watchdog to act.
This was a result of commit f1a7941243c1 ("mm: convert mm's rss stats into percpu_counter") [1]. Previously, the memory error was bounded by 64*nr_threads pages, a very livable megabyte. Now, however, as a result of scheduler decisions moving the threads around the CPUs, the memory error could be as large as a gigabyte.
This is a really tremendous inaccuracy for any few-threaded program on a large machine and impedes monitoring significantly. These stat counters are also used to make OOM killing decisions, so this additional inaccuracy could make a big difference in OOM situations -- either resulting in the wrong process being killed, or in less memory being returned from an OOM-kill than expected.
Here is a (possibly incomplete) list of the prior approaches that were used or proposed, along with their downside:
Per-thread rss tracking: large error on many-thread processes.
Per-CPU counters: up to 12% slower for short-lived processes and 9% increased system time in make test workloads [1]. Moreover, the inaccuracy increases with O(n^2) with the number of CPUs.
Per-NUMA-node counters: requires atomics on fast-path (overhead), error is high with systems that have lots of NUMA nodes (32 times the number of NUMA nodes).
The simple fix proposed here is to do the precise per-cpu counters sum every time a counter value needs to be read. This applies to the OOM killer task selection, to the /proc statistics, and to the oom mark_victim trace event.
Note that commit 82241a83cd15 ("mm: fix the inaccurate memory statistics issue for users") introduced get_mm_counter_sum() for precise proc memory status queries for _some_ proc files. This change renames get_mm_counter_sum() to get_mm_counter(), thus moving the rest of the proc files to the precise sum.
Please confirm - switching /proc functions from get_mm_counter_sum() to get_mm_counter_sum() doesn't actually change anything, right? It would be concerning to add possible overhead to things like task_statm().
This change effectively increases the latency introduced when the OOM killer executes in favor of doing a more precise OOM target task selection. Effectively, the OOM killer iterates on all tasks, for all relevant page types, for which the precise sum iterates on all possible CPUs.
As a reference, here is the execution time of the OOM killer before/after the change:
AMD EPYC 9654 96-Core (2 sockets) Within a KVM, configured with 256 logical cpus.
| before | after |----------------------------------|----------|----------| nr_processes=40 | 0.3 ms | 0.5 ms | nr_processes=10000 | 3.0 ms | 80.0 ms |
That seems acceptable.