Maximaler Speicher, den malloc zuweisen kann

Ich habe versucht herauszufinden, wie viel Speicher ich auf meinem Computer maximal mallocieren kann (1 GB RAM 160 GB HD-Windows-Plattform).

Ich habe gelesen, dass der maximale Speicher, den Malloc zuweisen kann, auf den physischen Speicher (auf dem Heap) beschränkt ist.

Auch wenn ein Programm den Speicherverbrauch auf ein bestimmtes Niveau überschreitet, funktioniert der Computer nicht mehr, da andere Anwendungen nicht genügend Speicher erhalten, den sie benötigen.

Zur Bestätigung habe ich ein kleines Programm in C geschrieben:

int main(){  
    int *p;
    while(1){
        p=(int *)malloc(4);
        if(!p)break;
    }   
}

Ich hatte gehofft, dass es eine Zeit geben würde, in der die Speicherzuweisung fehlschlagen und die Schleife brechen würde, aber mein Computer blieb hängen, da es sich um eine Endlosschleife handelte.

Ich habe ungefähr eine Stunde gewartet und musste schließlich meinen Computer zwangsweise herunterfahren.

Einige Fragen:

• Weist malloc auch Speicher von HD zu?
• Was war der Grund für das obige Verhalten?
• Warum ist die Schleife zu keinem Zeitpunkt unterbrochen?
• Warum gab es keinen Zuordnungsfehler?

Ich habe gelesen, dass der maximale Speicher malloc zuweisen kann, ist auf physischen Speicher (auf dem Heap) beschränkt.

Falsch: Die meisten Computer/Betriebssysteme werden unterstützt virtuell Arbeitsspeicher, gesichert durch Festplattenspeicher.

Einige Fragen: tut malloc Speicher auch von HDD zuweisen?

malloc fragt das Betriebssystem, das wiederum möglicherweise etwas Speicherplatz benötigt.

Was war der Grund für das obige Verhalten? Warum brach die Schleife zu keinem Zeitpunkt?

Warum gab es keinen Zuordnungsfehler?

Sie haben einfach zu wenig auf einmal verlangt: Die Schleife wäre schließlich unterbrochen worden (lange nachdem Ihr Computer aufgrund des großen Überschusses an virtuellem gegenüber physischem Speicher und dem daraus resultierenden superhäufigen Festplattenzugriff, einem Problem, das als “Thrashing “), aber es hat Ihre Geduld schon vorher erschöpft. Versuchen Sie stattdessen, z. B. ein Megabyte auf einmal zu erhalten.

Wenn ein Programm den Speicherverbrauch auf ein bestimmtes Niveau überschreitet, funktioniert der Computer nicht mehr, da andere Anwendungen nicht genügend Speicher erhalten, den sie benötigen.

Ein vollständiger Stopp ist unwahrscheinlich, aber wenn eine Operation, die normalerweise einige Mikrosekunden dauern würde, am Ende (z. B.) zehn Millisekunden dauert, können diese vier Größenordnungen es sicherlich schaffen Gefühl als ob der Computer im Grunde stehen geblieben wäre, und was normalerweise eine Minute dauern würde, könnte eine Woche dauern.

Ich weiß, dass dieser Thread alt ist, aber für alle, die bereit sind, es selbst zu versuchen, verwenden Sie diesen Codeausschnitt

#include <stdlib.h>

int main() {
int *p;
while(1) {
    int inc=1024*1024*sizeof(char);
    p=(int*) calloc(1,inc);
    if(!p) break;
    }
}

Lauf

$ gcc memtest.c
$ ./a.out

Beim Ausführen füllt dieser Code den Arbeitsspeicher auf, bis er vom Kernel getötet wird. Verwenden von calloc anstelle von malloc, um “faule Auswertung” zu verhindern. Ideen aus diesem Thread: Malloc Memory Questions

Dieser Code füllte schnell meinen Arbeitsspeicher (4 GB) und dann in etwa 2 Minuten meine 20-GB-Swap-Partition, bevor sie starb. 64bit Linux natürlich.

/proc/sys/vm/overcommit_memory steuert das Maximum unter Linux

Unter Ubuntu 19.04 zum Beispiel das können wir leicht erkennen malloc wird mit umgesetzt mmap(MAP_ANONYMOUS durch die Nutzung strace.

Dann man proc dann beschreibt wie /proc/sys/vm/overcommit_memory steuert die maximale Belegung:

Diese Datei enthält den Abrechnungsmodus für den virtuellen Speicher des Kernels. Werte sind:

• 0: heuristisches Overcommit (dies ist die Voreinstellung)
• 1: Immer überschreiben, nie prüfen
• 2: Immer prüfen, niemals überschreiben

Im Modus 0 werden Aufrufe von mmap(2) mit MAP_NORESERVE nicht geprüft, und die Standardprüfung ist sehr schwach, was zu dem Risiko führt, dass ein Prozess „OOM-killed“ wird.

Im Modus 1 gibt der Kernel vor, immer genug Speicher zu haben, bis der Speicher tatsächlich erschöpft ist. Ein Anwendungsfall für diesen Modus sind wissenschaftliche Computeranwendungen, die große Sparse-Arrays verwenden. In Linux-Kernelversionen vor 2.6.0 impliziert jeder Wert ungleich Null Modus 1.

Im Modus 2 (verfügbar seit Linux 2.6) wird der gesamte zuweisbare virtuelle Adressraum (CommitLimit in /proc/meminfo) berechnet als

CommitLimit = (total_RAM - total_huge_TLB) * overcommit_ratio / 100 + total_swap

wo:

• total_RAM ist die Gesamtmenge an RAM auf dem System;
• total_huge_TLB ist die Speichermenge, die für riesige Seiten vorgesehen ist;
• overcommit_ratio ist der Wert in /proc/sys/vm/overcommit_ratio; und
• total_swap ist die Menge an Auslagerungsspeicher.

Beispielsweise ergibt diese Formel auf einem System mit 16 GB physischem RAM, 16 GB Swap, keinem Speicherplatz für große Seiten und einem overcommit_ratio von 50 ein CommitLimit von 24 GB.

Wenn der Wert in /proc/sys/vm/overcommit_kbytes seit Linux 3.14 ungleich Null ist, wird CommitLimit stattdessen wie folgt berechnet:

CommitLimit = overcommit_kbytes + total_swap

Siehe auch die Beschreibung von /proc/sys/vm/admiin_reserve_kbytes und /proc/sys/vm/user_reserve_kbytes.

Documentation/vm/overcommit-accounting.rst im 5.2.1-Kernel-Baum gibt auch einige Informationen, wenn auch lol ein bisschen weniger:

Der Linux-Kernel unterstützt die folgenden Overcommit-Behandlungsmodi

• 0 Heuristische Overcommit-Behandlung. Offensichtliche Overcommits des Adressraums werden zurückgewiesen. Wird für ein typisches System verwendet. Es stellt sicher, dass eine ernsthaft wilde Zuweisung fehlschlägt, während Overcommit ermöglicht wird, um die Swap-Nutzung zu reduzieren. root darf in diesem Modus etwas mehr Speicher zuweisen. Dies ist die Standardeinstellung.

• 1 Übertreibe es immer. Geeignet für einige wissenschaftliche Anwendungen. Ein klassisches Beispiel ist Code, der Sparse-Arrays verwendet und sich nur auf den virtuellen Speicher verlässt, der fast ausschließlich aus Nullseiten besteht.

• 2 Übertreiben Sie es nicht. Die gesamte Adressraumfestschreibung für das System darf Swap + eine konfigurierbare Menge (Standard ist 50 %) des physischen RAM nicht überschreiten. Abhängig von der Menge, die Sie verwenden, bedeutet dies in den meisten Situationen, dass ein Prozess beim Zugriff auf Seiten nicht beendet wird, sondern gegebenenfalls Fehler bei der Speicherzuweisung erhält.

  Nützlich für Anwendungen, die sicherstellen möchten, dass ihre Speicherzuweisungen in Zukunft verfügbar sind, ohne jede Seite initialisieren zu müssen.

Minimales Experiment

Wir können den maximal zulässigen Wert leicht sehen mit:

Haupt c

#define _GNU_SOURCE
#include <stdio.h>
#include <stdlib.h>
#include <sys/mman.h>
#include <string.h>
#include <unistd.h>

int main(int argc, char **argv) {
    char *chars;
    size_t nbytes;

    /* Decide how many ints to allocate. */
    if (argc < 2) {
        nbytes = 2;
    } else {
        nbytes = strtoull(argv[1], NULL, 0);
    }

    /* Allocate the bytes. */
    chars = mmap(
        NULL,
        nbytes,
        PROT_READ | PROT_WRITE,
        MAP_SHARED | MAP_ANONYMOUS,
        -1,
        0
    );

    /* This can happen for example if we ask for too much memory. */
    if (chars == MAP_FAILED) {
        perror("mmap");
        exit(EXIT_FAILURE);
    }

    /* Free the allocated memory. */
    munmap(chars, nbytes);

    return EXIT_SUCCESS;
}

GitHub-Upstream.

Kompilieren und ausführen, um 1 GiB und 1 TiB zuzuweisen:

gcc -ggdb3 -O0 -std=c99 -Wall -Wextra -pedantic -o main.out main.c
./main.out 0x40000000
./main.out 0x10000000000

Wir können dann mit dem Zuordnungswert herumspielen, um zu sehen, was das System zulässt.

Ich kann keine genaue Dokumentation für finden 0 (die Standardeinstellung), aber auf meinem 32-GiB-RAM-Computer ist die 1-TiB-Zuweisung nicht zulässig:

mmap: Cannot allocate memory

Wenn ich jedoch unbegrenztes Overcommit aktiviere:

echo 1 | sudo tee /proc/sys/vm/overcommit_memory

dann funktioniert die 1TiB-Zuweisung einwandfrei.

Modus 2 ist gut dokumentiert, aber ich bin zu faul, genaue Berechnungen durchzuführen, um es zu überprüfen. Aber ich möchte nur darauf hinweisen, dass wir in der Praxis Folgendes zuweisen dürfen:

overcommit_ratio / 100

des gesamten RAM und overcommit_ratio ist 50 standardmäßig, sodass wir etwa die Hälfte des gesamten Arbeitsspeichers zuweisen können.

VSZ vs. RSS und der Out-of-Memory-Killer

Bisher haben wir nur virtuellen Speicher zugewiesen.

Wenn Sie jedoch genügend dieser Seiten verwenden, muss Linux natürlich irgendwann damit beginnen, einige Prozesse zu beenden.

Ich habe das ausführlich dargestellt unter: Was ist RSS und VSZ in der Linux-Speicherverwaltung?

Versuche dies

#include <stdlib.h>
#include <stdio.h>

main() {
    int Mb = 0;
    while (malloc(1<<20)) ++Mb;
    printf("Allocated %d Mb total\n", Mb);
}

Fügen Sie dafür stdlib und stdio hinzu.
Dieser Auszug stammt von tiefe c Geheimnisse.

malloc führt seine eigene Speicherverwaltung durch, verwaltet kleine Speicherblöcke selbst, verwendet aber letztendlich Win32 Heap-Funktionen Speicher zuzuweisen. Sie können sich vorstellen malloc als “Memory Reseller”.

Das Speichersubsystem von Windows besteht aus physischem Speicher (RAM) und virtuellem Speicher (HD). Wenn der physische Speicher knapp wird, können einige der Seiten vom physischen Speicher in den virtuellen Speicher auf der Festplatte kopiert werden. Windows tut dies transparent.

Standardmäßig ist der virtuelle Speicher aktiviert und verbraucht den verfügbaren Speicherplatz auf der Festplatte. Ihr Test wird also weiter ausgeführt, bis er entweder die volle Menge an virtuellem Speicher für den Prozess (2 GB bei 32-Bit-Windows) zugewiesen oder die Festplatte gefüllt hat.

Gemäß dem C90-Standard wird garantiert, dass Sie mindestens ein Objekt mit einer Größe von 32 kByte erhalten können, und dies kann ein statischer, dynamischer oder automatischer Speicher sein. C99 garantiert mindestens 64 kByte. Informationen zu höheren Grenzwerten finden Sie in der Dokumentation Ihres Compilers.

Außerdem ist das Argument von malloc ein size_t und der Bereich dieses Typs ist [0,SIZE_MAX]also das Maximum, das Sie können Anfrage ist SIZE_MAX, dessen Wert je nach Implementierung variiert und in definiert ist <limits.h>.

Ich weiß nicht genau, warum das fehlgeschlagen ist, aber eine Sache ist, dass `malloc(4)” Ihnen vielleicht nicht wirklich 4 Bytes gibt, also ist diese Technik nicht wirklich ein genauer Weg, um Ihre maximale Heap-Größe zu finden.

Das habe ich durch meine Frage hier herausgefunden.

Wenn Sie beispielsweise 4 Byte Speicher deklarieren, könnte der Platz direkt vor Ihrem Speicher die Ganzzahl 4 enthalten, als Hinweis für den Kernel, wie viel Speicher Sie angefordert haben.