Linux – Decline malloc for memory hungry application

limitlinuxmemoryout of memory

Is it possible to deny malloc instead of killing process selected by OOM killer? I think out of memory can be at least logged by the process which is better than being killed. Also, part of the problem is that system is unresponsive for long time (couple of minutes) before killing the offensive process.

Are control groups better tool to guarantee other processes memory?

Best Answer

You can set limits before starting the process. For example set the virtual (soft) memory limit for the current shell to 1G

ulimit -S 1048576

You can also set such limits system wide, for example I have this:

/etc/security/limits.conf:

*               soft    as             25165824
*               hard    as             25165824

/etc/systemd/system.conf:
```
DefaultLimitAS=25769803776
```

To limit all processes to 24G on my 32G systems. Although two processes together could still cause such OOM situation, it never happened in practice.

Regarding "unresponsive for long time before killing the offensive process":

Don't use a swap partition, then things will be killed quickly.

Note, actually the malloc (virtual memory) is not the real problem. OOM happens only when the process starts using that malloc'ed memory. Unfortunately on Linux you cannot limit the resident memory. See "memory overcommit":

Related Solutions

Linux – How to the HDD swap without a swap partition

It isn't writing anything to the disk; it is reading from it. Swap is only used to hold data that is not backed by another file. Data, including program code, that is backed by another file can simply be discarded when it has not been modified. So what you are seeing is your programs being discarded to free up some ram, then having to be read in from the disk again.

If you set /proc/sys/vm/overcommit_memory to 2 and /proc/sys/vm/overcommit_ratio to 90, this will have the kernel simply refuse to allocate more than 90% of your ram. This will make sure you never get too low on ram. In practice though, you will end up with much more than 10% free ram before allocations fail, because most applications do not use all of the ram they allocate.

OOM Killer value always one less than set

oom_adj is deprecated and provided for legacy purposes only. Internally Linux uses oom_score_adj which has a greater range: oom_adj goes up to 15 while oom_score_adj goes up to 1000.

Whenever you write to oom_adj (let's say 9) the kernel does this:

oom_adj = (oom_adj * OOM_SCORE_ADJ_MAX) / -OOM_DISABLE;

and stores that to oom_score_adj. OOM_SCORE_ADJ_MAX is 1000 and OOM_DISABLE is -17.

So for 9 you'll get oom_adj=(9 * 1000) / 17 ~= 529.411 and since these values are integers, oom_score_adj will hold 529.

Now when you read oom_adj the kernel will do this:

oom_adj = (task->signal->oom_score_adj * -OOM_DISABLE) / OOM_SCORE_ADJ_MAX;

So for 529 you'll get: oom_adj = (529 * 17) / 1000 = 8.993 and since the kernel is using integers and integer arithmetic, this will become 8.

So there... you write 9 and you get 8 because of fixed point / integer arithmetic.

Best Answer

Related Solutions

Linux – How to the HDD swap without a swap partition

OOM Killer value always one less than set

Related Question