Policy Groups: Rethinking Memory Management in Linux

At the 2026 Linux Storage, Filesystem, Memory Management, and BPF Summit, Chris Li introduced a concept called policy groups to address gaps in the kernel's existing control-group subsystem. While control groups have served well for resource management, they fall short in other scenarios. This Q&A explores the problem, the proposed solution, and the ongoing debate in the community.

What are control groups and how do they manage memory?

Control groups (cgroups) are a Linux kernel feature that isolates, prioritizes, and accounts for the resource usage of groups of processes. For memory management, cgroups allow administrators to set limits (e.g., memory.max) and track usage per group. They work well for coarse-grained resource partitioning, such as guaranteeing a certain amount of RAM to a container. However, Chris Li argues that this model is rigid and lacks flexibility for more nuanced policies, such as tiered reclaim behavior or application-specific memory pressure handling.

What limitations of control groups does the proposed policy groups aim to solve?

Control groups are designed primarily for resource limiting and accounting, but they are not well-suited for policy enforcement that might depend on context or workload characteristics. For instance, a database may want to balance memory between a hot cache and cold storage, or a web server may want different eviction priorities for user sessions vs. static assets. Current cgroups do not allow such fine-grained, dynamic policy definitions without complex workarounds. Policy groups aim to separate the policy logic from the resource tracking mechanism, enabling flexible memory management based on rules rather than fixed limits.

What exactly are policy groups as described by Chris Li?

Policy groups are an enhancement to the kernel's memory management subsystem that allow attaching a set of rules – or policies – to a group of processes. Unlike control groups, which simply set hard limits, policy groups can define behaviors like preferred eviction order, memory pressure thresholds, or even quality-of-service (QoS) targets. For example, a policy could state: “If the group's memory usage exceeds 80%, start reclaiming from anonymous pages first.” Li envisions policy groups as a separate hierarchy from cgroups, but capable of being linked to them, giving administrators more granular control without breaking existing workflows.

How do policy groups differ from existing memory management features like memcg or KSM?

The existing memory-control group (memcg) subsystem handles accounting and limits, while Kernel Same-page Merging (KSM) reduces duplication. Neither offers a programmable framework for memory policy. Policy groups are not a replacement but an abstraction layer that can leverage memcg data and other kernel mechanisms. For instance, a policy could instruct the kernel to use an LRU variant different from the global one for specific processes. This contrasts with today's one-size-fits-all approach, where the kernel applies the same reclaim algorithm across all cgroups.

What was the community's response at the 2026 summit?

Chris Li's presentation sparked a lively debate. Some developers welcomed the idea, citing real-world pain points in datacenter operations where cgroups alone are insufficient. Others raised concerns about complexity, potential performance overhead, and the risk of creating an overly configurable system that might be misused. A key point of contention was whether policy groups should be built into the core MM subsystem or implemented as a higher-level framework in user space. Li acknowledged that consensus remains distant, but the discussion was a crucial step toward a more flexible future.

What is the likely path forward for policy groups in the Linux kernel?

Given the early stage of the proposal and the lack of consensus, policy groups are not expected to be merged soon. The immediate next steps likely involve gathering more use cases, prototyping a minimal implementation, and comparing it with alternative approaches, such as extending BPF for memory policies. Chris Li plans to release a patch set for further review. The community will need to weigh the benefits of flexibility against the added maintenance burden. If successful, policy groups could eventually complement cgroups, providing memory management that adapts to application needs without sacrificing isolation.