The Multi-Generational LRU: A Promising Memory Reclaim Solution Facing Integration Hurdles

Introduction

Memory reclaim is a fundamental operation within operating systems, responsible for identifying and freeing memory pages that can be repurposed more effectively. The Linux kernel has long relied on the Least Recently Used (LRU) algorithm for this task, but as workloads and hardware evolved, so too did the need for a more efficient reclaim mechanism. Enter the Multi-Generational LRU (MGLRU), a promising replacement that aims to improve upon the traditional approach. However, its integration into the mainline kernel has proven more complex than anticipated, sparking dedicated sessions at the 2026 Linux Storage, Filesystem, Memory Management, and BPF Summit. This article explores what MGLRU is, why it matters, and the challenges that remain.

Understanding Memory Reclaim and the Traditional LRU

Memory reclaim is the process of finding pages that are no longer actively used and making them available for new allocations. The traditional LRU algorithm maintains a single list of pages ordered by access recency, with the least recently used pages at the tail being the first candidates for reclaim. While simple and effective for many scenarios, this approach suffers from several limitations:

• Single perspective: It cannot distinguish between pages accessed frequently in the past but now idle, versus those accessed only once recently.
• Scan overhead: During heavy memory pressure, scanning the entire list can become expensive.
• Poor adaptability: It struggles to react quickly to shifting workloads, often evicting pages that will be needed soon.

These shortcomings spurred the development of MGLRU, which aims to address them by maintaining multiple generations of pages based on both recency and frequency of access.

The Rise of MGLRU: A New Approach

MGLRU, or Multi-Generational LRU, introduces a tiered structure where pages are grouped into several "generations" according to their access patterns. Pages that are frequently accessed are promoted to higher generations, while rarely used pages remain in lower ones. The reclaim process then focuses on the lowest generation first, ensuring that only truly inactive pages are evicted. This design brings several advantages:

• Improved accuracy: By considering both recency and frequency, MGLRU reduces the chance of evicting hot pages.
• Reduced overhead: Scanning is limited to the relevant generation rather than the entire list.
• Better performance: Workloads with high locality benefit from less cache thrashing.

Initially developed by Google for Android devices, MGLRU demonstrated significant improvements in memory efficiency and responsiveness. This success prompted efforts to upstream the code into the mainline Linux kernel, where it could benefit a wider range of systems—from embedded devices to servers.

Complications on the Path to Full Integration

Despite its promise, MGLRU's integration has not been smooth. The algorithm introduces new complexities in memory management that require careful handling. Three key sessions at the 2026 Linux Summit were dedicated to MGLRU, highlighting persistent issues:

Android-Specific Problems

Android devices, where MGLRU originated, present unique challenges. The platform's aggressive use of memory for background applications and its reliance on low-memory killer daemons can interact poorly with MGLRU's generation promotion logic. Some device configurations have reported increased jank (stuttering) during app switching, caused by premature eviction of app data. Developers are working on tuning the generation thresholds and adding hooks for Android-specific memory pressure signals.

Performance Tuning for Diverse Workloads

Another challenge is achieving consistent performance across heterogeneous workloads. MGLRU's parameters—such as the number of generations and promotion/demotion criteria—need to be calibrated for desktop, server, and mobile use cases. Early adopters have found that out-of-the-box settings sometimes lead to higher cache miss rates in database workloads or increased latency in real-time applications. The community is exploring adaptive tuning mechanisms that can self-adjust based on observed access patterns.

The 2026 Linux Summit: A Focus on MGLRU

At the 2026 edition of the Linux Storage, Filesystem, Memory Management, and BPF Summit, three memory-management-track sessions were entirely devoted to MGLRU. These discussions aimed to chart a path toward full integration and optimization:

Session Highlights

• Integration roadmap: Proposals for merging MGLRU as the default reclaim mechanism, replacing the traditional LRU entirely, with careful deprecation timelines.
• Performance benchmarks: Presenters shared data from large-scale tests showing MGLRU reducing major page faults by up to 40% in certain Android workloads, but also revealed regressions in NUMA-heavy server setups.
• Android fixes: Collaborative efforts to patch the low-memory killer integration and to introduce new sysctl knobs for fine-grained control on mobile devices.
• Future research: Exploration of machine learning–based generation prediction to further improve eviction decisions.

Future Outlook

MGLRU represents a significant step forward in memory reclaim technology, but its journey toward widespread adoption is far from over. The kernel community is actively working on resolving the issues identified during the summit, with several patches already in progress. Key milestones include stabilizing the Android-specific fixes and developing a robust benchmarking suite that covers all major use cases. If successful, MGLRU could become the default reclaim algorithm in a future Linux kernel release, delivering tangible performance gains across the ecosystem.

Conclusion

The Multi-Generational LRU is more than just an incremental improvement—it's a rethinking of how memory reclaim should work in modern systems. While its integration has been complicated, the focused attention at the 2026 Linux Summit signals a strong commitment to overcoming these hurdles. For developers and system administrators, staying informed about MGLRU's progress is essential, as it promises to reshape memory management in Linux for years to come.