Single Process Maximum Possible Memory in x64 Linux

Question

is there any memory limit for a single process in x64 Linux?

we are running a Linux Server with 32Gb of RAM and I'm wondering if I can allocate most of it for a single process I'm coding which requires lots of RAM!

Answer 1

Certain kernels have different limits, but on any modern 64-bit linux the single-process limit is still far over 32GB (assuming that process is a 64-bit executable). Various distributions may also have set per-process limits using sysctl , so you'll want to check your local environment to make sure that there aren't arbitrarily low limits set (also check ipcs -l on RPM-based systems).

The Debian port documentation for the AMD64 port specifically mentions that the per-process virtual address space limit is 128TiB (twice the physical memory limit), so that should be the reasonable upper bound you're working with.

Answer 2

Current 64bit Linux kernel has limit to 64TB of physical RAM and 128TB of virtual memory (see RHEL limits and Debian port ). Current x86_64 CPUs (ie. what we have in the PC) has (virtual) address limit 2^48=256TB because of how the address register in the CPU use all the bits (upper bits are used for page flags like ReadOnly, Writable, ExecuteDisable, PagedToDisc etc in the pagetable), but the specification allows to switch to true 64bit address mode reaching the maximum at 2^64=16EB (Exa Bytes). However, the motherboard and CPU die does not have so many pins to deliver all 48 bits of the memory address to the RAM chip through the address bus, so the limit for physical RAM is lower (and depends on manufacturer), but the virtual address space could by nature reach more than the amount of RAM one could have on the motherboard up to virtual memory limit mentioned above.

The limit per process are raised by how the memory virtual address space for the process is set, because there could be various sizes for stack, mmap() area (and dynamic libraries), program code itself, also the kernel is mapped into the process space. Some of these settings could be changed by passing argument to the linker, sometimes by special directive in the source code, or by modifying the binary file with the program directly (binary has ELF format). Also there are limits the administrator of the machine (root) has set or the user has (see output of the command "ulimit -a"). These limits could be soft or hard and the user is unable to overcome hard limit.

Also the Linux kernel could be set to allow memory overcommit allocation. In this case, the program is allowed to allocate a huge amount of RAM and then use only a few of pages (see sparse arrays, sparse matrix), see Linux kernel documentation . So in this case, the program will fail only after filling up the requested memory by data, but not at the time of memory allocation.

Answer 3

The resource limits are set using setrlimit syscall. You can change them with a shell builtin (eg ulimit on bash, limit with zsh).

The practical limit is also related to RAM size and swap size. The free command show these. (Some systems are overcommitting memory, but that is risky).

A process actually don't use RAM, it consumes virtual memory using system calls like mmap (which may get called by malloc ). You could even map a portion of a file into memory with that call.

To learn about the memory map of a process 1234, look into the /proc/1234/maps file. From your own application, read the /proc/self/maps . And you have also /proc/1234/smaps and /proc/self/smaps . Try the command cat /proc/self/maps to understand the memory map of the process running that cat .

On a 32Gb RAM machine, you can usually run a process with 31 Gb of process space (assuming no other big process exist). If you had also 64Gb of swap, you could run a process of at least 64Gb but that would be unbelievably slow (most of the time would be spent on swapping to disk). You can add swap space (eg by swapping to a file, initialized with dd then mkswap , and activated with swapon ).

If coding a server, be very careful about memory leaks . The valgrind tool is helpful to hunt such bugs. And you could consider using Boehm's garbage collector