为什么这个记忆食客真的不吃记忆？

Question

我想创建一个程序来模拟Unix服务器上的内存不足（OOM）情况。我创造了这个超级简单的记忆食客：

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

unsigned long long memory_to_eat = 1024 * 50000;
size_t eaten_memory = 0;
void *memory = NULL;

int eat_kilobyte()
{
    memory = realloc(memory, (eaten_memory * 1024) + 1024);
    if (memory == NULL)
    {
        // realloc failed here - we probably can't allocate more memory for whatever reason
        return 1;
    }
    else
    {
        eaten_memory++;
        return 0;
    }
}

int main(int argc, char **argv)
{
    printf("I will try to eat %i kb of ram\n", memory_to_eat);
    int megabyte = 0;
    while (memory_to_eat > 0)
    {
        memory_to_eat--;
        if (eat_kilobyte())
        {
            printf("Failed to allocate more memory! Stucked at %i kb :(\n", eaten_memory);
            return 200;
        }
        if (megabyte++ >= 1024)
        {
            printf("Eaten 1 MB of ram\n");
            megabyte = 0;
        }
    }
    printf("Successfully eaten requested memory!\n");
    free(memory);
    return 0;
}

它消耗的内存与memory_to_eat中定义的一样多，现在正好是50

问题是它是有效的。即使在具有1的系统上

当我检查top时，我看到这个过程消耗了50

系统规范：Linux内核3.16（Debian）很可能启用了Overmit（不知道如何检查），没有交换和虚拟化。

Answer 1

这里正在进行合理的优化。在您使用内存之前，运行时实际上不会获取内存。

一个简单的memcpy就足以避免这种优化。（您可能会发现，在使用点之前，calloc仍然优化了内存分配。）

Answer 2

所有虚拟页面开始时都映射到同一个归零的物理页面。要使用物理页面，您可以通过向每个虚拟页面写入一些内容来弄脏它们。

如果以root身份运行，则可以使用mlock（2）或mlockall（2）让内核在分配页面时连接页面，而不必弄脏页面。（正常非根用户的ulimit-l只有64kiB。）

正如许多其他人所建议的那样，Linux内核似乎并不真正分配内存，除非您对其进行写入

这也修复了printf格式字符串与memory_to_eat和eaten_memory类型不匹配的问题，使用%zi打印size_t整数。要占用的内存大小（以kiB为单位）可以选择指定为命令行参数。

使用全局变量的凌乱设计并以1k而不是4k的页面增长，没有改变。

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

size_t memory_to_eat = 1024 * 50000;
size_t eaten_memory = 0;
char *memory = NULL;

void write_kilobyte(char *pointer, size_t offset)
{
    int size = 0;
    while (size < 1024)
    {   // writing one byte per page is enough, this is overkill
        pointer[offset + (size_t) size++] = 1;
    }
}

int eat_kilobyte()
{
    if (memory == NULL)
    {
        memory = malloc(1024);
    } else
    {
        memory = realloc(memory, (eaten_memory * 1024) + 1024);
    }
    if (memory == NULL)
    {
        return 1;
    }
    else
    {
        write_kilobyte(memory, eaten_memory * 1024);
        eaten_memory++;
        return 0;
    }
}

int main(int argc, char **argv)
{
    if (argc >= 2)
        memory_to_eat = atoll(argv[1]);

    printf("I will try to eat %zi kb of ram\n", memory_to_eat);
    int megabyte = 0;
    int megabytes = 0;
    while (memory_to_eat-- > 0)
    {
        if (eat_kilobyte())
        {
            printf("Failed to allocate more memory at %zi kb :(\n", eaten_memory);
            return 200;
        }
        if (megabyte++ >= 1024)
        {
            megabytes++;
            printf("Eaten %i  MB of ram\n", megabytes);
            megabyte = 0;
        }
    }
    printf("Successfully eaten requested memory!\n");
    free(memory);
    return 0;
}

Answer 3

当您的malloc（）实现（通过sbrk（）或mmap（）系统调用）从系统内核请求内存时，内核只会注意到您已经请求了内存以及它将放置在您的地址空间中的位置。它实际上还没有映射这些页面。

当进程随后访问新区域内的内存时，硬件识别出分段错误并提醒内核注意该情况。然后内核在自己的数据结构中查找页面，发现您应该在那里有一个零页面，因此它映射到一个零页面（可能首先从页面缓存中驱逐一个页面）并从中断中返回。您的进程没有意识到发生了这些事情，内核操作是完全透明的（除了内核工作时的短暂延迟）。

这种优化允许系统调用快速返回，最重要的是，它避免了在映射时将任何资源投入到您的流程中。这允许进程保留在正常情况下不需要的相当大的缓冲区，而不用担心占用太多内存。

因此，如果你想编程一个内存食客，你绝对必须对你分配的内存做些什么。为此，您只需要在代码中html" target="_blank">添加一行：

int eat_kilobyte()
{
    if (memory == NULL)
        memory = malloc(1024);
    else
        memory = realloc(memory, (eaten_memory * 1024) + 1024);
    if (memory == NULL)
    {
        return 1;
    }
    else
    {
        //Force the kernel to map the containing memory page.
        ((char*)memory)[1024*eaten_memory] = 42;

        eaten_memory++;
        return 0;
    }
}

请注意，在每个页面中写入一个字节（在X86上包含4096个字节）就足够了。这是因为从内核到进程的所有内存分配都是在内存页面颗粒度下完成的，这反过来又是因为硬件不允许以较小的粒度分页。