Почему этот пожиратель памяти действительно не ест память?

Я хочу создать программу, которая будет имитировать ситуацию нехватки памяти (OOM) на сервере Unix. Я создал этот супер-простой едок памяти:

#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 МБ и печатает именно ту точку, где не удается выделить больше, так что я знаю, какое максимальное значение ему удалось съесть.

Проблема в том, что это работает. Даже в системе с 1 ГБ физической памяти.

Когда я проверяю top, я вижу, что процесс съедает 50 ГБ виртуальной памяти и только менее 1 МБ резидентной памяти. Есть ли способ создать пожиратель памяти, который действительно потребляет его?

Спецификации системы: ядро ​​Linux 3.16 ( Debian ), скорее всего, с включенной функцией overcommit (не знаю, как это проверить), без подкачки и виртуализации.

Когда ваша malloc()реализация запрашивает память у системного ядра (через sbrk()или mmap()системный вызов), ядро ​​только отмечает, что вы запросили память и где она должна быть размещена в вашем адресном пространстве. На самом деле он еще не отображает эти страницы .

Когда процесс впоследствии обращается к памяти в новом регионе, оборудование распознает ошибку сегментации и предупреждает ядро ​​об этом состоянии. Затем ядро ​​просматривает страницу в своих собственных структурах данных и обнаруживает, что у вас должна быть нулевая страница, поэтому она отображается на нулевой странице (возможно, сначала удаляя страницу из кеша страниц) и возвращается из прерывания. Ваш процесс не осознает, что все это произошло, работа ядра совершенно прозрачна (за исключением небольшой задержки, пока ядро ​​выполняет свою работу).

Эта оптимизация позволяет системному вызову возвращаться очень быстро, и, что наиболее важно, она позволяет избежать выделения каких-либо ресурсов для вашего процесса при сопоставлении. Это позволяет процессам резервировать довольно большие буферы, которые им никогда не нужны в нормальных условиях, не опасаясь сожрать слишком много памяти.

Итак, если вы хотите запрограммировать пожиратель памяти, вам действительно нужно что-то делать с выделенной вам памятью. Для этого вам нужно всего лишь добавить одну строку в ваш код:

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;
    }
}

Обратите внимание, что вполне достаточно написать один байт на каждой странице (который содержит 4096 байт в X86). Это связано с тем, что все выделение памяти от ядра процессу выполняется с гранулярностью страниц памяти, что, в свою очередь, связано с аппаратным обеспечением, которое не допускает разбиение на страницы при меньших гранулярностях.

Все виртуальные страницы начинаются копированием при записи, сопоставленными с одной и той же обнуленной физической страницей. Чтобы использовать физические страницы, вы можете испачкать их, записав что-то на каждую виртуальную страницу.

Если вы работаете от имени пользователя root, вы можете использовать mlock(2)или mlockall(2)заставить ядро ​​подключать страницы, когда они выделены, без необходимости их пачкать. (обычные пользователи без ulimit -lполномочий root имеют размер только 64 КБ.)

Как и многие другие предположили, кажется, что ядро ​​Linux на самом деле не выделяет память, если вы не пишете в нее

Улучшенная версия кода, которая делает то, что хотел OP:

Это также исправляет несоответствие строки формата printf с типами memory_to_eat и eaten_memory, используемыми %ziдля печатиsize_t целых чисел. Объем используемой памяти в килобайтах необязательно может быть указан в командной строке arg.

Грязный дизайн с использованием глобальных переменных и ростом на 1 Кб вместо 4 Кб страниц не изменился.

#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;
}

Здесь проводится разумная оптимизация. Среда фактически не приобретает память , пока вы не используете его.

Простого memcpyбудет достаточно, чтобы обойти эту оптимизацию. (Вы можете обнаружить, что это callocоптимизирует распределение памяти до момента использования.)

Не уверен насчет этого, но единственное объяснение, которое я могу понять, это то, что linux - это операционная система копирования при записи. При вызове forkоба процесса указывают на одну и ту же физическую память. Память копируется только один раз, когда один процесс действительно ЗАПИСЫВАЕТ в память.

Я думаю здесь, фактическая физическая память выделяется только тогда, когда кто-то пытается что-то записать в нее. Звонок sbrkили mmapвполне может только обновить память ядра памяти. Фактическая RAM может быть выделена только тогда, когда мы действительно пытаемся получить доступ к памяти.