Dlaczego ten pożeracz wspomnień naprawdę nie zjada pamięci?

Chcę utworzyć program, który będzie symulował sytuację braku pamięci (OOM) na serwerze Unix. Stworzyłem ten super prosty pożeracz pamięci:

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

Zjada tyle pamięci, ile zdefiniowano, w memory_to_eatktórej teraz jest dokładnie 50 GB pamięci RAM. Alokuje pamięć o 1 MB i drukuje dokładnie punkt, w którym nie może przydzielić więcej, dzięki czemu wiem, jaką maksymalną wartość udało mu się zjeść.

Problem w tym, że to działa. Nawet w systemie z 1 GB pamięci fizycznej.

Kiedy sprawdzam górę, widzę, że proces zjada 50 GB pamięci wirtualnej i tylko mniej niż 1 MB pamięci rezydentnej. Czy istnieje sposób na stworzenie pożeracza pamięci, który naprawdę ją pochłania?

Specyfikacje systemu: jądro Linuksa 3.16 ( Debian ) najprawdopodobniej z włączonym overcommitem (nie wiem jak to sprawdzić) bez wymiany i zwirtualizowane.

Kiedy twoja malloc()implementacja żąda pamięci od jądra systemu (przez wywołanie systemowe sbrk()lub mmap()), jądro tylko zauważa, że ​​zażądałeś pamięci i gdzie ma ona zostać umieszczona w twojej przestrzeni adresowej. W rzeczywistości nie mapuje jeszcze tych stron .

Gdy proces następnie uzyskuje dostęp do pamięci w nowym regionie, sprzęt rozpoznaje błąd segmentacji i ostrzega jądro o stanie. Następnie jądro wyszukuje stronę w swoich własnych strukturach danych i stwierdza, że ​​powinieneś mieć tam stronę zerową, więc odwzorowuje stronę zerową (prawdopodobnie najpierw wykluczając stronę z pamięci podręcznej stron) i wraca z przerwania. Twój proces nie zdaje sobie sprawy, że coś takiego się wydarzyło, operacja jądra jest całkowicie przezroczysta (z wyjątkiem krótkiego opóźnienia, w którym jądro wykonuje swoją pracę).

Ta optymalizacja umożliwia bardzo szybkie zwrócenie wywołania systemowego i, co najważniejsze, pozwala uniknąć przydzielenia zasobów do procesu podczas mapowania. Pozwala to procesom rezerwować dość duże bufory, których nigdy nie potrzebują w normalnych okolicznościach, bez obawy o pochłonięcie zbyt dużej ilości pamięci.

Tak więc, jeśli chcesz zaprogramować pożeracza pamięci, absolutnie musisz coś zrobić z przydzieloną pamięcią. W tym celu wystarczy dodać jedną linię do kodu:

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

Zauważ, że w zupełności wystarczy napisać do pojedynczego bajtu na każdej stronie (która zawiera 4096 bajtów na X86). Dzieje się tak, ponieważ cała alokacja pamięci z jądra do procesu odbywa się na poziomie szczegółowości strony pamięci, co z kolei jest spowodowane sprzętem, który nie pozwala na stronicowanie z mniejszą szczegółowością.

Wszystkie strony wirtualne rozpoczynają się od kopiowania przy zapisie mapowanych na tę samą zerowaną stronę fizyczną. Aby wykorzystać strony fizyczne, możesz je zabrudzić, pisząc coś na każdej stronie wirtualnej.

Jeśli pracujesz jako root, możesz użyć mlock(2)lub mlockall(2)zmusić jądro do łączenia stron, gdy są przydzielone, bez konieczności ich brudzenia. (zwykli użytkownicy ulimit -linni niż root mają tylko 64 kB.)

Jak sugerowało wielu innych, wydaje się, że jądro Linuksa tak naprawdę nie alokuje pamięci, chyba że do niej napiszesz

Ulepszona wersja kodu, która robi to, czego chciał OP:

To również rozwiązuje niezgodność łańcuchów formatu printf z typami memory_to_eat i eaten_memory, używając %zido drukowania size_tliczb całkowitych. Rozmiar pamięci do zjedzenia w kiB może być opcjonalnie określony jako argument wiersza poleceń.

Nieuporządkowany projekt wykorzystujący zmienne globalne i zwiększający się o 1 000 zamiast 4 000 stron pozostaje niezmieniony.

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

Przeprowadzana jest tutaj sensowna optymalizacja. Środowisko wykonawcze nie pobiera pamięci, dopóki jej nie użyjesz.

Prosty memcpywystarczy, aby obejść tę optymalizację. (Może się okazać, że callocnadal optymalizuje alokację pamięci do momentu użycia).

Nie jestem pewien co do tego, ale jedyne wyjaśnienie, jakie mogę sobie wyobrazić, to fakt, że Linux jest systemem operacyjnym typu „kopiuj przy zapisie”. Kiedy ktoś wywołuje, forkoba procesy wskazują na tę samą pamięć fizyczną. Pamięć jest kopiowana tylko wtedy, gdy jeden proces faktycznie ZAPISUJE do pamięci.

Myślę, że tutaj faktyczna pamięć fizyczna jest przydzielana tylko wtedy, gdy próbuje się coś do niej zapisać. Wywołanie sbrklub mmapmoże tylko zaktualizować księgę pamięci jądra. Rzeczywista pamięć RAM może zostać przydzielona tylko wtedy, gdy faktycznie próbujemy uzyskać dostęp do pamięci.