memusage - Online in der Cloud

PROGRAMM:

NAME/FUNKTION

memusage - Profilspeichernutzung eines Programms

ZUSAMMENFASSUNG

Erinnerung [zu erhalten] ... Programm [Programmoption] ...

BESCHREIBUNG

Erinnerung ist ein Bash-Skript, das die Speichernutzung des Programms profiliert, Programm. Es
lädt die libmemusage.so Bibliothek in die Umgebung des Anrufers (über die LD_PRELOAD
Umgebungsvariable; sehen ld.so(8)). Die libmemusage.so Bibliothek verfolgt die Speicherzuordnung
durch Abfangen von Anrufen an malloc(3) calloc(3) kostenlos(3) und Realloc(3); optional, Anrufe
zu mmap(2) mremap(2) und Munmap(2) kann auch abgefangen werden.

Erinnerung kann die gesammelten Daten in Textform ausgeben oder verwenden memusagestat(1) (siehe
-p Option, unten), um eine PNG-Datei zu erstellen, die eine grafische Darstellung der
Gesammelte Daten.

Memory Verwendung Zusammenfassung
Die Zeilenausgabe "Zusammenfassung der Speichernutzung" von Erinnerung enthält drei Felder:

Haufen gesamt
Die Summe von Größe Argumente von allen malloc(3) Aufrufe, Produkte von Argumenten
(nmemb*Größe) von allen calloc(3) Anrufe und Summe von Länge Argumente von allen mmap(2)
Anrufe. Im Falle des Realloc(3) und mremap(2), wenn die neue Größe von an
Zuteilung größer ist als die vorherige Größe, die Summe all dieser Unterschiede
(neue Größe minus alte Größe) wird hinzugefügt.

Haufen Haupt
Maximal von allen Größe Argumente von malloc(3), alle Produkte von nmemb*Größe of
calloc(3), alle Größe Argumente von Realloc(3) Länge Argumente von mmap(2) und
neue_größe Argumente von mremap(2).

Stapel Haupt
Vor dem ersten Aufruf einer überwachten Funktion wird die Stack-Pointer-Adresse
(Basisstapelzeiger) wird gespeichert. Nach jedem Funktionsaufruf wird der aktuelle Stack
Zeigeradresse wird gelesen und die Differenz zum Basisstackzeiger
berechnet. Das Maximum dieser Differenzen ist dann der Stapelpeak.

Unmittelbar nach dieser Zusammenfassungszeile zeigt eine Tabelle die Anzahl der Anrufe, den Gesamtspeicher
zugewiesen oder aufgehoben, und Anzahl fehlgeschlagener Anrufe für jede abgehörte Funktion. Zum
Realloc(3) und mremap(2), das Zusatzfeld "nomove" zeigt geänderte Umverteilungen an
die Adresse eines Blocks, und das zusätzliche Feld "dec" zeigt Neuzuweisungen, die abgenommen haben
die Größe des Blocks. Zum Realloc(3), das Zusatzfeld "frei" zeigt Umverteilungen
die dazu führte, dass ein Block freigegeben wurde (dh die neu zugewiesene Größe war 0).

Der "realloc/total memory" der Tabellenausgabe von Erinnerung spiegelt nicht Fälle wider, in denen
Realloc(3) wird verwendet, um einen Speicherblock neu zuzuweisen, um eine kleinere Größe als zuvor zu haben.
Dies kann dazu führen, dass die Summe aller "Gesamtspeicher"-Zellen (außer "frei") größer als die
Zelle "freier/gesamter Speicher".

Histogramm für Schutzmassnahmen bei Größen
Das "Histogramm für Blockgrößen" bietet eine Aufschlüsselung der Speicherzuweisungen in verschiedene
Eimergrößen.

OPTIONAL

-n Name, --Programmname=Name
Name der zu profilierenden Programmdatei.

-p Datei, --png=Datei
PNG-Grafik generieren und speichern in Datei.

-d Datei, --data=Datei
Generieren Sie eine Binärdatendatei und speichern Sie sie in Datei.

-u, --ungepuffert
Ausgabe nicht puffern.

-b Größe, --puffer=Größe
Sammeln Größe Einträge, bevor Sie sie ausschreiben.

--kein Timer
Timer-basiert deaktivieren (SIGPROF) Abtastung des Stapelzeigerwerts.

-m, --mmap
Auch verfolgen mmap(2) mremap(2) und Munmap(2).

-?, --help
Hilfe ausdrucken und beenden.

--Verwendungszweck
Drucken Sie eine kurze Nutzungsnachricht und beenden Sie den Vorgang.

-V, --Version
Versionsinformationen drucken und beenden.

Die folgenden Optionen gelten nur beim Generieren einer grafischen Ausgabe:

-t, --zeitbasiert
Verwenden Sie die Zeit (statt der Anzahl der Funktionsaufrufe) als Maßstab für die X-Achse.

-T, --gesamt
Zeichnen Sie auch ein Diagramm der gesamten Speichernutzung.

--title=Name
Verwenden Sie die Name als Titel der Grafik.

-x Größe, --x-Größe=Größe
Machen Sie die Grafik Größe Pixel breit.

-y Größe, --y-Größe=Größe
Machen Sie die Grafik Größe Pixel hoch.

EXIT STATUS

Der Exit-Status entspricht dem Exit-Status des profilierten Programms.

BEISPIEL

Unten ist ein einfaches Programm, das einen Speicherblock in Zyklen neu zuweist, die zu einem Spitzenwert ansteigen
bevor dann zyklisch der Speicher in kleineren Blöcken neu zugewiesen wird, die auf Null zurückkehren.
Nach dem Kompilieren des Programms und Ausführen der folgenden Befehle wird eine Grafik des Speichers
Verwendung des Programms finden Sie in der Datei memusage.png:

$ Erinnerung --data=memusage.dat ./August
...
Zusammenfassung der Speichernutzung: Heap gesamt: 45200, Heap-Peak: 6440, Stack-Peak: 224
Gesamtzahl der Anrufe Gesamtspeicher fehlgeschlagener Anrufe
malloc| 1 400 0
realloc| 40 44800 0 (nomov:40, dez:19, frei:0)
calloc| 0 0 0
kostenlos| 1 440
Histogramm für Blockgrößen:
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

Programm Quelle
#einschließen
#einschließen

#define ZYKLEN 20

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

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

für (i = 0; i < ZYKLEN; i ++) {
wenn (i < ZYKLEN / 2)
j = ich;
sonst
J--;

printf("realloc: %zd\n", sizeof(int) * (j * 50 + 110));
p = realloc(p, sizeof(int) * (j * 50 + 100));

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

kostenlos (p);
Beenden (EXIT_SUCCESS);
}

Verwenden Sie memusage online mit den onworks.net-Diensten