Ich möchte ein Programm erstellen, das eine OOM-Situation (Out-of-Memory) auf einem Unix-Server simuliert. Ich habe diesen supereinfachen Speicheresser erstellt:

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

Es isst so viel Speicher wie in @ definiememory_to_eat das sind jetzt genau 50 GB RAM. Es ordnet den Speicher um 1 MB zu und gibt genau den Punkt aus, an dem keine weitere Zuordnung möglich ist, sodass ich weiß, welchen Maximalwert es essen konnte.

Das Problem ist, dass es funktioniert. Auch auf einem System mit 1 GB physischem Speicher.

Wenn ich nach oben schaue, sehe ich, dass der Prozess 50 GB virtuellen Speicher und nur weniger als 1 MB residenten Speicher belegt. Gibt es eine Möglichkeit, einen Speicherfresser zu erstellen, der ihn wirklich verbraucht?

Systemspezifikationen: Linux-Kernel 3.16 Debian) höchstwahrscheinlich mit aktiviertem Overcommit (nicht sicher, wie es ausgecheckt werden soll) ohne Swap und virtualisiert.