Linux Developers Propose 64KB Page Sizes for Process Isolation and x86 Performance Boost

In a groundbreaking session at the 2026 Linux Storage, Filesystem, Memory Management, and BPF Summit, developers outlined two innovative paths to enable 64KB base pages on systems running 4KB kernels. The proposals promise significant performance gains for memory-intensive applications while avoiding the resource overhead typically associated with larger pages.

Most Important Fact

Linux memory management experts are exploring two distinct methods to allow processes to utilize 64KB page sizes even when the kernel itself is compiled with 4KB page support. The first approach grants each process the ability to choose its own page size, while the second aims to bring 64KB page functionality to x86 architectures, where such large base pages are not natively supported.

"This is a major step forward for workloads that suffer from high TLB miss rates," said a lead kernel memory management contributor during the summit. "By decoupling page sizes from kernel configuration, we can offer better performance without sacrificing flexibility."

Background

Modern CPUs support multiple base page sizes—typically 4KB, 2MB, and 1GB—though the kernel must be compiled for a single size. Larger pages reduce translation lookaside buffer (TLB) misses and improve memory throughput, but they increase memory fragmentation and overall consumption. Until now, kernel-wide page size was fixed at boot time; applications had no choice but to inherit that setting.

At the summit, two sessions in the memory-management track tackled this limitation. The first, titled “Per-Process Page Size,” focused on letting individual processes request a different base page size than the kernel’s. The second, “64KB Pages on x86,” examined the feasibility of making the x86 architecture—traditionally limited to 4KB base pages—support 64KB pages through hardware or software emulation.

First Approach: Per-Process Page Size

Proponents of the per-process model argue that it allows fine-grained control without affecting the entire system. "A database server can run with 64KB pages while the rest of the system keeps 4KB pages, reducing memory pressure," explained a developer involved in the design. The implementation would likely involve a new system call or extension to mmap() to set the page size for a specific memory region.

However, critics warn of increased complexity in the memory manager and potential security implications if page-size switching is not properly isolated. The session concluded that a prototype exists but need more testing on NUMA and virtualized environments.

Second Approach: 64KB Pages on x86

The second session proposed a more radical change: enabling 64KB base pages on x86 processors, which currently lack hardware support for that specific size. Developers discussed using advanced feature like Intel’s Linear Address Masking or AMD’s Extended Page Tables to emulate 64KB pages, or even modifying the TLB to handle 64KB granularity. “This would require minimal kernel changes, but we need CPU vendors to expose new architectural capabilities,” one panelist noted.

Early performance simulations showed up to 35% improvement in database and HPC workloads due to reduced TLB misses. However, the overhead of emulation could negate gains in I/O-bound tasks. The group agreed to form a mailing list to coordinate with hardware vendors.

What This Means

If either approach succeeds, applications that currently rely on hugepages (2MB or 1GB) could benefit from similar performance jumps with lower memory waste. Cloud providers may particularly welcome per-process page sizes, as they can optimize virtual machine memory consumption without rebooting hosts. Moreover, bringing 64KB pages to x86 would standardize large-page support across architectures, simplifying cross-platform development.

Still, challenges remain: kernel-side compatibility with existing filesystem and device driver assumptions, potential fragmentation in the page cache, and the need for userspace tooling to detect optimal page sizes. The next steps involve broader community review and, for the x86 case, collaboration with Intel and AMD. A decision on whether to merge either proposal into the mainline kernel is expected by the 2027 merge window.

Additional Context

For a deeper dive into the technical details, read the original coverage on LWN.net. The summit recordings are also available on the Linux Foundation’s YouTube channel.