Policy Groups: A New Approach to Memory Management Beyond Control Groups

At the 2026 Linux Storage, Filesystem, Memory Management, and BPF Summit, Chris Li introduced a concept that could reshape how the kernel handles memory for different applications. While control groups (cgroups) have long been the go‑to for resource management, Li argued they fall short in several real‑world scenarios. His proposed solution—policy groups—aims to fill those gaps. Below, we explore the key questions surrounding this emerging feature.

What exactly are policy groups, and how do they differ from control groups?

Policy groups are a proposed kernel enhancement designed to manage memory according to high‑level policies rather than strict resource limits. Unlike control groups (cgroups), which primarily enforce hard caps on CPU, memory, and I/O usage, policy groups focus on behavioral rules. For example, a policy group might say “prefer to reclaim memory from this group before others” or “allow this group to exceed its nominal allocation when the system is underutilized.” This makes them better suited for scenarios where the goal is not to isolate resources but to influence how the kernel distributes memory in a more flexible manner. Cgroups are excellent for hard isolation (e.g., containers), but policy groups aim to handle cases where the system needs to prioritize certain workloads without imposing rigid boundaries. The two can coexist: policy groups could be layered on top of cgroup infrastructure to add policy‑driven decisions.

Policy Groups: A New Approach to Memory Management Beyond Control Groups

What specific shortcomings of control groups does Chris Li aim to address?

Li highlighted several pain points during his talk. First, cgroups are static—they define fixed limits that don’t adapt to changing system loads. For instance, a memory‑bound application might briefly need extra memory, but cgroups would throttle it even if other groups are idle. Second, cgroups lack the ability to express preferences or trade‑offs. A database server should ideally keep its cache warm, but under cgroups, it must stay within its limit even when the system has spare memory. Third, cgroups complicate debugging because their rigid boundaries can cause unexpected OOM kills or performance degradation. Policy groups would instead allow administrators to define intentions (e.g., “protect this workload’s memory footprint”) and let the kernel decide how to honor them, making memory management more adaptive and less prone to surprises.

How would policy groups work in practice? Can you give an example?

Imagine a machine running both a latency‑sensitive web server and a batch analytics job. With cgroups, you assign each a fixed memory limit. If the web server suddenly sees a spike in traffic, it might hit its limit and start swapping—even if the analytics job is using far less than its allocation. Under policy groups, you could create a policy that says: “The web server should be able to borrow memory from the analytics group when needed, as long as the analytics group’s own needs are not urgent.” The kernel would then monitor memory pressure and dynamically rebalance allocations. Policy groups would define criteria such as latency_sensitive=high or reclaim_priority=low. These are not hard limits but guidelines; the kernel uses them to make intelligent decisions about page reclaim, swap, and OOM selection. This brings memory management closer to the way cloud operators think about workloads: as services with service‑level objectives, not just resource consumers.

Why did Chris Li present this proposal at the 2026 Linux Storage, Filesystem, Memory Management, and BPF Summit?

The summit is a premier venue for discussing low‑level kernel changes, particularly those that touch on memory management, storage, and BPF. Li’s proposed policy groups touch all three areas: they would require changes to the memory controller, interact with the page cache (storage), and could benefit from BPF for dynamic policy evaluation. By presenting there, Li sought early feedback from kernel maintainers and researchers who understand the trade‑offs involved. The session was part of the memory‑management track, emphasizing that policy groups are fundamentally about improving how the kernel allocates and reclaims memory under diverse workloads. The summit’s focus on real‑world deployment and experimental features made it the ideal place to gauge consensus and gather implementation ideas.

What was the reaction to the policy groups proposal at the summit?

The response was cautious. While many attendees agreed that cgroups have limitations, there was no clear consensus on whether policy groups are the right solution. Some argued that the feature could add complexity to an already intricate memory management subsystem. Others worried about performance overhead from policy evaluation, especially under high memory pressure. A few suggested that existing mechanisms like memory.low and memory.reclaim in cgroups v2 could be extended instead of introducing a whole new concept. Li acknowledged these concerns but maintained that a dedicated policy framework would be cleaner and more powerful. The discussion highlighted a common tension in kernel development: the desire for flexibility versus the need to keep the core simple and maintainable. As of now, policy groups remain a proposal, with further discussion planned for follow‑up mailing list threads.

What are the next steps for policy groups, and when might they be available?

Li plans to release a patch set for review after incorporating feedback from the summit. The initial implementation will likely focus on memory only, with a small set of policy primitives (e.g., reclaim priority, latency sensitivity, burst allowance). Later iterations might extend to CPU or I/O if the concept proves useful. No timeline has been set for merging into the mainline kernel. Historically, features like this require multiple rounds of review, real‑world testing, and sometimes a proof‑of‑concept in a staging tree. Interested developers can follow the policy groups discussion on the linux‑mm mailing list. The earliest we could see an experimental version is in the 2027 kernel cycle, but only if the community reaches rough consensus on the design. For now, the proposal serves as a catalyst for rethinking how Linux should handle resource management in the age of diverse, dynamic workloads.