memusage(1)

BEZEICHNUNG
memusage - Speicherverwendung eines Programms profilieren

ÜBERSICHT
memusage [Option …] Programm [Programmoption …]

BESCHREIBUNG
memusage ist ein bash(1)-Skript, das die Speicherverwendung des Programms Programm profiliert. Es lädt die Bibliothek libmemusage.so vorab in die Umgebung des Aufrufenden (mittels der Umgebungsvariablen LD_PRELOAD, siehe ld.so(8)). Die Bibliothek libmemusage.so verfolgt die Speicherbelegungen mittels Abfangens der Aufrufe von malloc(3), calloc(3), free(3) und realloc(3) nach; optional können auch die Aufrufe von mmap(2), mremap(2) und munmap(2) abgefangen werden.

memusage kann die gesammelten Daten in textueller Form ausgeben oder es kann (mittels der nachfolgend beschriebenen Option -p) memusagestat(1) verwenden, um eine PNG-Datei zu erstellen, die die graphische Darstellung der gesammelten Daten enthält.

  Speicherverwendungszusammenfassung
Die von memusage ausgegebene Zeile »Memory usage summary« enthält drei Felder:

    heap total
        Summe der Argumente Größe für alle malloc(3)-Aufrufe; Produkte der Argumente (n*Größe) aller calloc(3)-Aufrufe und die Summe aller Argumente Länge aller mmap(2)-Aufrufe. Im Falle von realloc(3) und mremap(2) wird die Summe aller Differenzen (neue Größe minus alter Größe) hinzugefügt, falls die neue Größenreservierung die vorherige Größe überschreitet.

    heap peak
        Maximum aller Argumente Größe aller malloc(3), alle Produkte von n*Größe von calloc(3), aller Argumente Größe von realloc(3), Argumente Länge von mmap(2) und Argumente neue_Größe von mremap(2).

    stack peak
        Vor dem erstmaligen Aufruf jeder überwachten Funktion wird die Adresse des Stapel-Zeigers (Basis-Stapelzeiger) gesichert. Nach jedem Funktionsaufruf wird die tatsächliche Adresse gelesen und die Differenz zum Basis-Stapelzeiger berechnet. Das Maximum dieser Differenzen ist der »stack peak«.

Direkt nach dieser Zusammenfassungszeile zeigt eine Tabelle die Anzahl der Aufrufe, den insgesamt reservierten oder freigegebenen Speicher und die Anzahl der fehlgeschlagenen Aufrufe für jede abgefangene Funktion. Für realloc(3) und mremap(2) zeigt das zusätzliche Feld »nomove« die Umreservierungen, die die Adresse eines Blocks änderten und das zusätzliche Feld »dec« zeigt die Umreservierungen, die die Größe eines Blocks verkleinerten. Für realloc(3) zeigt das zusätzliche Feld »free« die Umreservierungen, die zur Freigabe eines Blocks führten (d.h. die umreservierte Größe war 0).

Das »realloc/total memory« der Tabellenausgabe von memusage berücksichtigt Fälle nicht, bei denen realloc(3) zur Umreservierung eines Speicherblocks zur Verkleinerung der vorherigen Größe verwandt wird. Dies kann zu einer Summe von allen »total memory«-Zellen führen (ausschließlich »free«), die größer als die Zelle »free/total memory« ist.

  Histogramm für Blockgrößen
Das »Histogram for block sizes« stellt eine Aufteilung der Speicherreservierungen in verschiedene Topfgrößen dar.

OPTIONEN

-n Name
--progname=Name
    Name des zu profilierenden Programms.

-p Datei
--png=Datei
    Erstellt eine PNG-Graphik und speichert sie in Datei.

-d Datei
--data=Datei
    Erstellt eine binäre Datendatei und speichert sie in Datei.

-u
--unbuffered
    Puffert die Ausgabe nicht.

-b Größe
--buffer=Größe
    Sammelt Größe Einträge, bevor sie herausgeschrieben werden.

--no-timer
    Deaktiviert Timer-basierte (SIGPROF) Probennahme des Stapelzeigerwertes.

-m
--mmap
    Verfolgt mmap(2), mremap(2) und munmap(2) auch nach.

-?
--help
    Hilfe ausgeben und beenden.

--usage
    Gibt eine kurze Gebrauchsinformation aus und beendet sich.

-V
--version
    Gibt Versionsinformationen aus und beendet sich.

Die folgenden Optionen sind nur bei der Erstellung graphischer Ausgaben relevant:

-t
--time-based
    Verwendet die Zeit (anstelle der Anzahl der Funktionsaufrufe) als Skala für die X-Achse.

-T
--total
    Zeichnet auch eine Graphik der gesamten Speicherverwendung.

--title=Name
    Verwendet Name als Titel für die Graphik.

-x Größe
--x-size=Größe
    Setzt die Breite der Graphik auf Größe Pixel.

-y Größe
--y-size=Größe
    Setzt die Höhe der Graphik auf Größe Pixel.

EXIT-STATUS
Der Exit-Status von memusage ist identisch zu dem Exit-Status des profilierten Programms.

FEHLER
Um Fehler (auf Englisch) zu melden, siehe http://www.gnu.org/software/libc/bugs.html

BEISPIELE
Es folgt ein einfaches Programm, das zyklisch Speicherblöcke neu reserviert, die zu einer Spitzenbelastung ansteigen und dann zyklisch kleinere Speicherblöcke neu reserviert, die auf Null zurückkehren. Nach der Kompilierung und Ausführung der folgenden Befehle, ist eine Graphik der Speicherverwendung des Programms in der Datei memusage.png verfügbar:

    $ memusage --data=memusage.dat ./a.out;
    …
    Memory usage summary: heap total: 45200, heap peak: 6440, stack peak: 224
            total calls  total memory  failed calls
     malloc|         1           400             0
    realloc|        40         44800             0  (nomove:40, dec:19, free:0)
     calloc|         0             0             0
       free|         1           440
    Histogram for block sizes:
      192-207             1   2% ================
    …
     2192-2207            1   2% ================
     2240-2255            2   4% =================================
     2832-2847            2   4% =================================
     3440-3455            2   4% =================================
     4032-4047            2   4% =================================
     4640-4655            2   4% =================================
     5232-5247            2   4% =================================
     5840-5855            2   4% =================================
     6432-6447            1   2% ================
    $ memusagestat memusage.dat memusage.png;

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

    #define CYCLES 20

    int
    main(int argc, char *argv[])
    {
        int i, j;
        size_t size;
        int *p;

        size = sizeof(*p) * 100;
        printf("malloc: %zu\n", size);
        p = malloc(size);

        for (i = 0; i < CYCLES; i++) {
            if (i < CYCLES / 2)
                j = i;
            else
                j--;

            size = sizeof(*p) * (j * 50 + 110);
            printf("realloc: %zu\n", size);
            p = realloc(p, size);

            size = sizeof(*p) * ((j + 1) * 150 + 110);
            printf("realloc: %zu\n", size);
            p = realloc(p, size);
        }

        free(p);
        exit(EXIT_SUCCESS);
    }

SIEHE AUCH
memusagestat(1), mtrace(1), ld.so(8)

ÜBERSETZUNG
Die deutsche Übersetzung dieser Handbuchseite wurde von Helge Kreutzmann <debian@helgefjell.de> erstellt.

Diese Übersetzung ist Freie Dokumentation; lesen Sie die GNU General Public License Version 3 (https://www.gnu.org/licenses/gpl-3.0.html) oder neuer bezüglich der Copyright-Bedingungen. Es wird KEINE HAFTUNG übernommen.

Wenn Sie Fehler in der Übersetzung dieser Handbuchseite finden, schicken Sie bitte eine E-Mail an die Mailingliste der Übersetzer (debian-l10n-german@lists.debian.org).