le9-patch

If the computer is slow enough under load, you can use wall clock to count many seconds it takes to start a program that needs to load many libs and data (LibreOffice, Firefox, Blender, GIMP). You can also watch FPS of supertuxkart when the system is under load: https://www.youtube.com/watch?v=c5bAOJkX_uc https://github.com/hakavlad/le9-patch But yes, we need a popular well behaved benchmark to measure desktop responsiveness.

Oh that’s a known problem. There are many kernel patches floating around that fix it by triggering the OOM killer when the system is thrashing. Here’s one based on ChromeOS’s solution: https://github.com/hakavlad/le9-patch I’ve never had this specific problem back when I was daily driving desktop Linux, but I did run into 1000 other ones that needed bandaid solutions just like this. It’s death of a thousand cuts: https://news.ycombinator.com/item?id=28490753 I see that nothing’s changed in the last couple of years.

As long as you have only spinning rust for swap I disable it. After reading that article some time ago I tried to add a little swap to my shared general purpose machines (running quite a mixed workload that sometimes tends to explode e.g. matrix synapse is famous for that) and the box still grinded into an unresponsive state even with just 4GB swap. Maybe I did something wrong - But I'd rather tolerate an OOM kill (mostly contained by cgroups/container/lxd) and a few seconds (or minutes) of unresponsiveness instead of a complete lockup that results in a hard reset. Not sure if it's better on SSD. I've enabled zswap for 1/8 of memory on the Desktop and this seems to improve things but as long as you have spinning rust or other slow storage my experience is that the machine will die a slow death as long as swap is active. There is some inte

The reason the OOM killer never kicks in is because you actually never run into an OOM, or almost never. What usually happens is that in near-OOM conditions, the kernel starts reclaiming memory pages backed by file (sometimes called "trashing"). This operation manages to keep some extra memory available, but it makes the system almost unresponsive because it's constantly copying memory back and forth from the disk. It may take anywhere between minutes to hours before the system finally OOMs and the OOM killer is invoked. This problem has been there forever but has been made worse by the improved speeds of modern storage technologies: with slower disk I/O, the OOM condition was reached sooner. There are several solutions: - Buy more RAM: if your system routinely goes nearly OOM something is not right. - Add a (small) swap. It doesn't have

related: [1] https://github.com/hakavlad/le9-patch [2] https://www.phoronix.com/scan.php?page=news_item&px=le9-Linu...

The amount of dirty pages the kernel keeps in RAM is configurable through sysctl. If the buffer is full any further write blocks the process. If you have less free RAM than the allowed dirty page buffer what you said is correct though. There is a new patch[1] that allows to set a soft and hard minimum of RAM reserved for clean pages. This fixes the problem almost completely even under the heaviest loads. cgroups like a silbling post mentioned can also help by setting soft limits for heavy background tasks like compile jobs. Setting a soft limit will give them as much RAM as is available, or swap them out completely when things are heavily contented, effectively pausing the processes. It requires some setting up though, so it's not a solution for all cases, but it can make sense even without the thrashing problem. [1]: https://github.com/h

While that is true, you can invoke the OOM killer at any time you want by pressing Ctrl+Alt+Print("SysRq")+F(uck?). Given the letter they picked it seems like they're fully aware of the deficiency. As to why it was never really addressed, that's a good question. The recent le9[1] patch addresses the most annoying symptom of running out of memory by keeping some amount of RAM reserved for clean pages (like static program code) so that those won't get swapped in and out so much. That greatly improves responsiveness under low memory conditions. [1]: https://github.com/hakavlad/le9-patch

I wonder how does this compare to the state of the art solutions from the author of Nohang: https://github.com/hakavlad/prelockd https://github.com/hakavlad/memavaild https://github.com/hakavlad/le9-patch in terms of % saved memory or % prevented hangs/OOM / lost base runtime performance

Regarding the file pages this is the solution https://github.com/hakavlad/le9-patch

How will systemd-oomd communicate to the user? I was using https://github.com/hakavlad/nohang And it sent notification signaling to save your work before the application X will be killed. (I always wanted a way to click somewhere on the notification to prevent nohand from killing it when unwanted) Also nohang use PSI data does oomd does it too? Finally the author of nohang is working on arguably superior solutions: https://github.com/hakavlad/prelockd https://github.com/hakavlad/memavaild https://github.com/hakavlad/le9-patch It's unfortunate that systemd has chosen to integrate an inferior solution