Perché questo mangiatore di memoria non mangia davvero memoria?

Voglio creare un programma che simuli una situazione di memoria insufficiente (OOM) su un server Unix. Ho creato questo semplicissimo mangiatore di memoria:

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

Mangia tutta la memoria definita in memory_to_eatcui ora sono esattamente 50 GB di RAM. Alloca memoria di 1 MB e stampa esattamente il punto in cui non riesce ad allocare di più, in modo che io sappia quale valore massimo è riuscito a mangiare.

Il problema è che funziona. Anche su un sistema con 1 GB di memoria fisica.

Quando controllo in alto vedo che il processo consuma 50 GB di memoria virtuale e solo meno di 1 MB di memoria residente. C'è un modo per creare un mangiatore di memoria che lo consumi davvero?

Specifiche di sistema: kernel Linux 3.16 ( Debian ) molto probabilmente con overcommit abilitato (non sono sicuro su come verificarlo) senza swap e virtualizzato.

Quando l' malloc()implementazione richiede memoria dal kernel di sistema (tramite una sbrk()o una mmap()chiamata di sistema), il kernel prende nota solo che è stata richiesta la memoria e dove deve essere collocata nel proprio spazio degli indirizzi. In realtà non mappa ancora quelle pagine .

Quando il processo accede successivamente alla memoria all'interno della nuova area, l'hardware riconosce un errore di segmentazione e avvisa il kernel della condizione. Il kernel quindi cerca la pagina nelle proprie strutture di dati e trova che dovresti avere una pagina zero lì, quindi mappa in una pagina zero (possibilmente prima sfrattando una pagina dalla cache della pagina) e ritorna dall'interrupt. Il tuo processo non si rende conto che tutto ciò è avvenuto, l'operazione dei kernel è perfettamente trasparente (tranne per il breve ritardo mentre il kernel fa il suo lavoro).

Questa ottimizzazione consente alla chiamata di sistema di tornare molto rapidamente e, soprattutto, evita che qualsiasi risorsa venga impegnata nel processo al momento della mappatura. Ciò consente ai processi di riservare buffer piuttosto grandi che non sono mai necessari in circostanze normali, senza il timore di divorare troppa memoria.

Quindi, se vuoi programmare un mangiatore di memoria, devi assolutamente fare qualcosa con la memoria che assegni. Per questo, devi solo aggiungere una singola riga al tuo codice:

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

Si noti che è perfettamente sufficiente scrivere su un singolo byte all'interno di ciascuna pagina (che contiene 4096 byte su X86). Questo perché tutta l'allocazione di memoria dal kernel a un processo viene eseguita con granularità della pagina di memoria, che è, a sua volta, a causa dell'hardware che non consente il paging con granularità più piccole.

Tutte le pagine virtuali iniziano copia su scrittura mappate sulla stessa pagina fisica azzerata. Per usare pagine fisiche, puoi sporcarle scrivendo qualcosa su ogni pagina virtuale.

Se eseguito come root, puoi usare mlock(2)o mlockall(2)fare in modo che il kernel colleghi le pagine quando vengono allocate, senza doverle sporcare. (i normali utenti non root hanno un valore ulimit -ldi soli 64 kB).

Come molti altri hanno suggerito, sembra che il kernel Linux non alloca realmente la memoria a meno che non ci si scriva

Una versione migliorata del codice, che fa ciò che l'OP desiderava:

Questo risolve anche la mancata corrispondenza della stringa del formato printf con i tipi di memory_to_eat e eaten_memory, usando %ziper stampare size_tnumeri interi. La dimensione della memoria da mangiare, in kiB, può essere facoltativamente specificata come arg della riga di comando.

Il design disordinato che utilizza variabili globali e cresce di 1k invece di 4k pagine, rimane invariato.

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

Qui è in corso un'ottimizzazione sensata. Il runtime non acquisisce effettivamente la memoria fino a quando non la si utilizza.

Un semplice memcpysarà sufficiente per aggirare questa ottimizzazione. (Potresti scoprire che callocottimizza ancora l'allocazione della memoria fino al punto di utilizzo.)

Non sono sicuro di questo, ma l'unica spiegazione di cui posso fare è che Linux è un sistema operativo copia su scrittura. Quando uno chiama forkentrambi i processi puntano alla stessa memoria fisica. La memoria viene copiata solo quando un processo in realtà SCRIVE sulla memoria.

Penso che qui, la memoria fisica effettiva sia allocata solo quando si cerca di scrivergli qualcosa. La chiamata sbrko mmappotrebbe anche solo aggiornare la memoria del kernel. La RAM effettiva può essere allocata solo quando si tenta effettivamente di accedere alla memoria.