Чому цей пожирач пам'яті насправді не їсть пам'ять?

Я хочу створити програму, яка буде імітувати ситуацію поза пам'яттю (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 Гб фізичної пам'яті.

Коли я перевіряю зверху, я бачу, що процес з’їдає 50 ГБ віртуальної пам’яті і лише менше 1 Мб пам'яті резидента. Чи існує спосіб створити пам'ять, яка дійсно споживає його?

Характеристики системи: Ядро Linux 3.16 ( Debian ), швидше за все, з увімкненою надмірною передачею (не впевнений, як це перевірити) без заміни та віртуалізації.

Коли 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некористувачі мають лише 64 Кб.)

Як багато інших пропонували, схоже, що ядро ​​Linux насправді не виділяє пам'ять, якщо ви не пишете на неї

Вдосконалена версія коду, яка робить те, чого хотіла ОП:

Це також виправляє невідповідність рядків формату printf з типами memory_to_eat та eaten_memory, використовуючи %ziдля друку size_tцілі числа. Розмір пам'яті, яку потрібно з'їсти, в кіБ, необов'язково може бути вказаний як аргумент командного рядка.

Безладний дизайн, що використовує глобальні змінні, і зростає на 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може лише оновити зберігання пам'яті ядра. Фактична оперативна пам’ять може бути виділена лише тоді, коли ми фактично намагаємося отримати доступ до пам'яті.