c - 具有 4 Gb RAM 和 10 Gb 交换分区的 32 位内核中的无限循环 malloc

Question

假设我有一个 32 位内核。 4 Gb RAM，10 Gb 交换分区。

我有一个在无限循环中有 malloc 的进程。因此，最终系统的 OOM 将终止该进程。这里有两个论点。

参数 1:因为它是 32 位内核，虚拟地址分割为 3:1，即 3Gb 用于用户空间，1Gb 用于内核空间。该进程将被分配 3 Gb 的内存，然后就没有更多的内存可以提供了。所以，OOM 会终止进程。

参数 2:因为它是 32 位内核，虚拟地址分割为 3:1，即 3Gb 用于用户空间，1Gb 用于内核空间。该进程将被分配 4 Gb 的内存，然后就没有更多的内存可以提供了。所以，OOM 会终止进程。

参数三:Malloc会先占用Ram的4Gb内存，然后会占用10Gb的Swap分区，然后OOM会kill进程。

哪些论点(如果有的话)是正确的？

论坛上还有其他答案，但我不确定这个问题的答案是否取决于它的 32 位内核还是 64 位内核？

Answer 1

为什么认为OOM会杀死进程？在您的示例中，您将在用完所有实际内存之前耗尽地址空间。因此，在您的示例(32 位)中，您将能够分配大约 3 GB 的地址空间(减去文本/数据/堆栈和其他段以及可能的内存碎片)，然后系统将只返回 ENOMEM。

如果您使用的是 64 位系统，事情会变得更有趣。现在结果将在很大程度上取决于你是否真的在使用这个内存。如果你不使用它(只是分配)，那么由于过度使用(当然，如果你没有禁用它)你将能够分配一些大量的地址空间，但如果你尝试使用它，这就是您将触发 OOM 的地方(大约 10+4 GB 边界)，这将终止程序。

更新

用这样的程序检查实际上很容易:

#include <errno.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

int main()
{
    static char *allocs[10 * 1024 * 1024];
    static unsigned int size;
    unsigned int i;
    unsigned int const chunk = 1024 * 1024;

    for (i = 0; i < (sizeof(allocs)/sizeof(allocs[0])); i++)
        if ((allocs[i] = malloc(chunk)) == NULL) {
            printf("failed to allocate after %u MB: %s\n", i, strerror(errno));
            break;
        }

    size = i;
    if (size == (sizeof(allocs)/sizeof(allocs[0])))
         printf("allocated %u MB successfully!\n", size);
    for (i = 0; i < size; i++) {
        memset(allocs[i], 1, chunk);
        if (i % 100 == 0)
            printf("memset %u MB\n", i);
    }
    return 0;
}

它尝试分配 10M 的内存块，每个大小为 1M，因此实际上是 10 TB。在具有 4 GB RAM 的 32 位系统上，它给出了这个结果(稍微缩短了一点):

failed to allocate after 3016 MB: Cannot allocate memory
memset 0 MB
memset 100 MB
...
memset 2900 MB
memset 3000 MB

正如预期的那样，地址空间不足，添加交换空间(我用 5GB 而不是 10GB 完成了我的测试)没有任何帮助。

对于 64 位，它的行为有点出乎意料(没有交换，只有 4 GB 的 RAM)，因为它不输出任何东西，只是在仍在进行分配时被 OOM killer 杀死。但看看 OOM killer 日志就可以解释了:

[  242.827042] [ 5171]  1000  5171 156707933   612960  306023        0             0 a.out
[  242.827044] Out of memory: Kill process 5171 (a.out) score 905 or sacrifice child
[  242.827046] Killed process 5171 (a.out) total-vm:626831732kB, anon-rss:2451812kB, file-rss:28kB

因此它能够分配大约 620 GB (!) 的虚拟内存，并真正映射了 2.4。还请记住，我们正在使用 malloc() 进行分配，因此 C 库必须进行自己的内务处理，即使您估计如此大的分配大约有 0.5% 的开销，您也会得到大量的数字仅此而已(为了避免这种开销，您可以尝试使用 mmap())。在这个阶段，我们有足够的内存用于短缺，所以进程在仍在进行分配时被杀死。如果你不那么贪婪并将 allocs 更改为 [100 * 1024](实际上只有 100 GB)，你可以很容易地看到交换的效果，因为在 4 GB 系统上没有它你有:

allocated 102400 MB successfully!
memset 0 MB
memset 100 MB
...
memset 2800 MB
memset 2900 MB
Killed

添加 5 GB 的交换空间:

allocated 102400 MB successfully!
memset 0 MB
memset 100 MB
...
memset 7900 MB
memset 8000 MB
Killed

一切如预期。