How a Linux Kernel Patch Could Breathe New Life Into Your Aging Gaming Rig

If you're a Linux gamer running on hardware that's seen better days, there's some promising kernel development on the horizon that could make a big difference. A proposed patch series, called "sched: Flatten the pick," aims to fix a long-standing scheduler flaw that disproportionately affects older and multi-core systems. We've broken down what the patch does, who's behind it, and what kind of performance gains you might expect, based on real-world testing. Read on for the full Q&A.

What exactly is the "sched: Flatten the pick" Linux kernel patch?

This patch series, authored by kernel developer Peter Zijlstra, tackles a specific inefficiency in how the Linux scheduler handles cgroup scheduling. In Linux, tasks are often grouped into cgroups for resource management. The problem Zijlstra identified is a formula that fragments a cgroup's total priority weight across every CPU on the system. On a machine with many cores, this means each individual CPU sees only a tiny sliver of the cgroup's intended priority, effectively making the group run at a much lower priority than expected. The fix, as Zijlstra describes it, is to "flatten" the picking process by collapsing multiple levels of cgroup hierarchy into a single level, which simplifies and speeds up the scheduler's task selection.

Why does this scheduler flaw hurt gaming performance, especially on old hardware?

When you run a game on Linux, it's typically competing for CPU time with background processes like Discord, a web browser with many tabs, or system updates. All these tasks are often placed into separate cgroups. The current scheduler's weight fragmentation issue means that even if your game's cgroup is set to a high priority, on a system with many CPU cores (or many logical threads), the effective priority per core can drop drastically. For example, on a 64-core server, a cgroup's weight can be reduced to what Zijlstra calls "roughly a nice 19 task worth of priority per CPU." As core counts climb, the problem gets worse. This is especially painful on older hardware where every bit of CPU performance counts, but it also hurts modern high-core-count systems.

How did Peter Zijlstra test the patch, and what were the results?

Zijlstra ran a practical test using an older Intel Core i7-2600K processor (4 cores, 8 threads) paired with an AMD Radeon RX 580 graphics card. He launched the game Shadows: Awakening via Lutris using GE-Proton10-34 and Steam Runtime 3. To simulate real-world background load, he added 8 CPU-spinning processes (one per thread). Under the default kernel settings, the game became almost unplayable—frame rates tanked, and stutter was severe. He then changed the scheduler's time slice to one-tenth of the default value (a system-level tuning) and recorded both sessions with MangoHud. The improvement was dramatic, as shown in the table below:

Performance Comparison: Default vs. Shortened Slice

• Minimum FPS: 3.8 → 20.6
• Average FPS: 48.0 → 57.2
• Maximum FPS: 87.4 → 80.3 (slight decrease, but frame times improved)
• Minimum frame time (ms): 9.4 → 8.4
• Average frame time (ms): 34.5 → 19.5
• Maximum frame time (ms): 107.4 → 37.2

The shorter slice reduced maximum frame time by over 65%, eliminating the worst stutters. The test used a kernel with the flattened scheduling applied to isolate the scheduler behavior, though Zijlstra noted he hasn't compared against a kernel without the flatten patch yet.

What specific part of the scheduler does the patch fix?

Zijlstra broke the problem into two parts. First, the current scheduler inflates a cgroup's weight by the number of CPUs to compensate for fragmentation, but if all load from that cgroup ends up on a single CPU, the inflated weight becomes absurdly high—beyond nice -20 (the maximum priority). That breaks the math used for time-sharing. Second, the scheduler's task selection process has to step through multiple cgroup levels (hierarchy) to pick the next runnable task. The patch simplifies this by flattening the hierarchy into a single level, letting the scheduler pick directly. This not only avoids the weight inflation issue but also reduces overhead when many cgroups are active.

Will this patch benefit only old hardware, or also modern systems?

While Zijlstra tested on an old i7-2600K (4 cores, 8 threads), the impact is actually broader. The fragmentation issue scales with core count, not age. On modern systems with 16, 32, or even 256 cores, the problem is worse because the formula splits the cgroup weight across more CPUs. So a high-end server or a workstation running multiple containers or VMs alongside a game would see similar benefits. The patch helps any system where CPU resources are shared among many cgroups—which is nearly every modern Linux desktop, especially when running a game, browser, chat apps, and background services simultaneously.

Is this patch already merged into the mainline Linux kernel?

No, the patch series is still under review. It was posted as a second version (v2) on the kernel mailing list and needs approval from the relevant maintainers. It will almost certainly go through several revisions before being accepted into a future kernel release. That means Linux gamers won't see these improvements in the current stable kernel (e.g., 6.x) for some time. However, if you build your own kernel or use a distribution that backports patches (like Arch's linux-mainline, or certain custom kernels), you might be able to test it early. Zijlstra's work is a strong indication that the kernel community is actively addressing real-world scheduling pain points.

What should Linux gamers do now to benefit from this fix?

For now, the best course is to monitor the status of the patch series. Keep an eye on Phoronix or the Linux kernel mailing list for updates. Once the patch is merged, you can either upgrade to a newer kernel or build a custom one with the patch applied. In the meantime, you can experiment with other scheduler tunables—such as adjusting the sched_wakeup_granularity or using chrt to change a process's scheduling priority and time slice length. Zijlstra's test used chrt to set a shorter slice, which provided a good approximation of the flattened scheduler's behavior on the core i7-2600K. However, manual tuning is no substitute for the structural fix the patch provides.