Man page - memusage(1)

Packages contains this manual

Available languages:

en fr da ja ru ro de

Manual

memusage

NUME
SINOPSIS
DESCRIERE
Rezumatul utilizării memoriei
Histograma pentru dimensiunile blocurilor
OPȚIUNI
STARE DE IEȘIRE
ERORI
EXEMPLE
Sursa programului
CONSULTAȚI ȘI
TRADUCERE

NUME

memusage - profilul utilizării memoriei de către un program

SINOPSIS

memusage [ opțiune ]... program [ opțiune-program ]...

DESCRIERE

memusage este un script bash care face profilul utilizării memoriei programului program . Acesta preîncarcă biblioteca libmemusage.so în mediul apelantului (prin intermediul variabilei de mediu LD_PRELOAD ; a se vedea ld.so (8)). Biblioteca libmemusage.so urmărește alocarea memoriei prin interceptarea apelurilor la malloc (3), calloc (3), free (3) și realloc (3); opțional, pot fi interceptate și apelurile la mmap (2), mremap (2) și munmap (2).

memusage poate afișa datele colectate sub formă de text sau poate utiliza memusagestat (1) (a se vedea opțiunea -p , mai jos) pentru a crea un fișier PNG care conține o reprezentare grafică a datelor colectate.

Rezumatul utilizării memoriei

Linia „Memory usage summary” produsă de memusage conține trei câmpuri:

heap total

Suma argumentelor dimensiune din toate apelurile malloc (3), produsul argumentelor ( nmemb * dimensiune ) din toate apelurile calloc (3) și suma argumentelor lungime din toate apelurile mmap (2). În cazul apelurilor realloc (3) și mremap (2), în cazul în care noua dimensiune a unei alocări este mai mare decât dimensiunea anterioară, se adaugă suma tuturor acestor diferențe (noua dimensiune minus vechea dimensiune).

heap peak

Maximul tuturor argumentelor dimensiune din malloc (3), al tuturor produselor nmemb * dimensiune din calloc (3), al tuturor argumentelor dimensiune din realloc (3), al argumentelor lungime din mmap (2) și al argumentelor dimensiunea_nouă din mremap (2).

stack peak

Înainte de primul apel la orice funcție monitorizată, se salvează adresa indicatorului de stivă (indicatorul stivei de bază). După fiecare apel de funcție, se citește adresa reală a indicatorului de stivă și se calculează diferența față de indicatorul de bază al stivei. Valoarea maximă a acestor diferențe reprezintă apoi vârful stivei.

Imediat după această linie de rezumat, un tabel prezintă numărul de apeluri, memoria totală alocată sau eliberată și numărul de apeluri eșuate pentru fiecare funcție interceptată. Pentru realloc (3) și mremap (2), câmpul suplimentar „nomove” arată realocările care au schimbat adresa unui bloc, iar câmpul suplimentar „dec” arată realocările care au scăzut dimensiunea blocului. Pentru realloc (3), câmpul suplimentar „free” indică realocările care au dus la eliberarea unui bloc (adică dimensiunea realocată a fost 0).

Coloana „realloc/total memory” din tabelul generat de memusage nu reflectă cazurile în care realloc (3) este utilizat pentru a realoca un bloc de memorie pentru a avea o dimensiune mai mică decât cea anterioară. Acest lucru poate face ca suma tuturor celulelor „total memory” (cu excepția celulei „free”) să fie mai mare decât cea a celulei „free/total memory”.

Histograma pentru dimensiunile blocurilor

„Histogram for block sizes” oferă o defalcare a alocărilor de memorie în pachete de diferite dimensiuni.

OPȚIUNI

-n nume , --progname= nume

Numele fișierului de program de profilat.

-p fișier , --png= fișier

Generează un grafic PNG și îl stochează în fișier .

-d fișier , --data= fișier

Generează un fișier de date binare și îl stochează în fișier .

-u , --unbuffered

Fără memorie tampon la ieșire.

-b dimensiune , --buffer= dimensiune

Colectează intrările dimensiune înainte de a le scrie.

--no-timer

Dezactivează eșantionarea pe bază de temporizator ( SIGPROF ) a valorii indicatorului de stivă.

-m , --mmap

De asemenea, urmărește mmap (2), mremap (2) și munmap (2).

-? , --help

Afișează mesajul de ajutor și iese.

--usage

Imprimă un mesaj scurt de utilizare și iese.

-V , --version

Imprimă informațiile de versiune și iese

Următoarele opțiuni se aplică numai atunci când se generează o ieșire
grafică:
-t , --time-based

Utilizează timpul (mai degrabă decât numărul de apeluri de funcții) ca scală pentru axa X.

-T , --total

Desenează, de asemenea, un grafic al utilizării totale a memoriei.

--title= nume

Utilizează nume ca titlu în interiorul graficului.

-x dimensiunea , --x-size= dimensiunea

Face ca graficul să aibă o lățime de dimensiunea pixeli.

-y dimensiunea , --y-size= dimensiunea

Face ca graficul să aibă o înălțime de dimensiunea pixeli.

STARE DE IEȘIRE

Starea de ieșire a memusage este egală cu starea de ieșire a programului profilat.

ERORI

Pentru a raporta erori, consultați http://www.gnu.org/software/libc/bugs.html

EXEMPLE

Mai jos este prezentat un program simplu care realocă un bloc de memorie în cicluri care cresc până la un vârf înainte de a realoca ciclic memoria în blocuri mai mici care revin la zero. După compilarea programului și rularea următoarelor comenzi, în fișierul memusage.png se poate găsi un grafic al utilizării memoriei programului:

$ 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

Sursa programului

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

CONSULTAȚI ȘI

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

TRADUCERE

Traducerea în limba română a acestui manual a fost făcută de Remus-Gabriel Chelu <remusgabriel.chelu@disroot.org>

Această traducere este documentație gratuită; citiți Licența publică generală GNU Versiunea 3 sau o versiune ulterioară cu privire la condiții privind drepturile de autor. NU se asumă NICIO RESPONSABILITATE.

Dacă găsiți erori în traducerea acestui manual, vă rugăm să trimiteți un e-mail la translation-team-ro@lists.sourceforge.net .