memusage - Online nel cloud

PROGRAMMA:

NOME

memusage - utilizzo della memoria del profilo di un programma

SINOSSI

messaggio [opzione] ... Programma [opzione di programmazione] ...

DESCRIZIONE

messaggio è uno script bash che profila l'utilizzo della memoria del programma, Programma. Questo
precarica il libmemusage.so libreria nell'ambiente del chiamante (tramite il LD_PRELOAD
variabile d'ambiente; vedere ld.so(8)). Il libmemusage.so la libreria traccia l'allocazione della memoria
intercettando le chiamate a malloc(3) calloc(3) "gratis"(3), e rialloc(3); facoltativamente, chiama
a mmap(2) mremap(2), e munmap(2) può anche essere intercettato.

messaggio può emettere i dati raccolti in forma testuale, oppure può usare memusagestat(1) (vedi
, il -p opzione, sotto) per creare un file PNG contenente la rappresentazione grafica del
dati raccolti.

Memorie uso sommario
L'output della riga "Riepilogo utilizzo memoria" di messaggio contiene tre campi:

heap totale
Somma di Taglia argomenti di tutti malloc(3) chiamate, prodotti di argomenti
(nmemb*Taglia) di tutti calloc(3) chiamate e somma di lunghezza argomenti di tutti mmap(2)
chiamate. In caso di rialloc(3) e mremap(2), se la nuova dimensione di an
l'allocazione è maggiore della dimensione precedente, la somma di tutte queste differenze
(nuova dimensione meno vecchia dimensione).

heap picco
Massimo di tutti Taglia argomenti di malloc(3), tutti i prodotti di nmemb*Taglia of
calloc(3), tutto Taglia argomenti di rialloc(3) lunghezza argomenti di mmap(2), e
nuova_dimensione argomenti di mremap(2).

pila picco
Prima della prima chiamata a qualsiasi funzione monitorata, l'indirizzo del puntatore dello stack
(puntatore dello stack di base) viene salvato. Dopo ogni chiamata di funzione, lo stack effettivo
l'indirizzo del puntatore viene letto e la differenza dal puntatore dello stack di base
calcolato. Il massimo di queste differenze è quindi il picco dello stack.

Subito dopo questa riga riepilogativa, una tabella riporta il numero di chiamate, la memoria totale
allocate o deallocate e numero di chiamate fallite per ciascuna funzione intercettata. Per
rialloc(3) e mremap(2), il campo aggiuntivo "nomove" mostra le riallocazioni che sono cambiate
l'indirizzo di un blocco e il campo aggiuntivo "dec" mostra le riallocazioni che sono diminuite
la dimensione del blocco. Per rialloc(3), il campo aggiuntivo "libero" mostra le riassegnazioni
che ha causato la liberazione di un blocco (ovvero, la dimensione riallocata era 0).

La "realloc/memoria totale" dell'output della tabella di messaggio non riflette i casi in cui
rialloc(3) viene utilizzato per riallocare un blocco di memoria per avere una dimensione inferiore rispetto a prima.
Ciò può far sì che la somma di tutte le celle della "memoria totale" (esclusa quella "libera") sia maggiore del
cella "memoria libera/totale".

Istogramma per bloccare Dimensioni
L'"Istogramma per le dimensioni dei blocchi" fornisce una suddivisione delle allocazioni di memoria in varie
dimensioni del secchio.

VERSIONI

-n Nome, --nomeprogramma=Nome
Nome del file di programma da profilare.

-p filetto, --png=filetto
Genera grafica PNG e salvala in filetto.

-d filetto, --dati=filetto
Genera file di dati binari e salvalo in filetto.

-u, --senza buffer
Non bufferizzare l'output.

-b Taglia, --buffer=Taglia
Collezionare Taglia voci prima di scriverle.

--senza timer
Disabilita basato su timer (SIGPROF) campionamento del valore del puntatore dello stack.

-m, --mappa
anche traccia mmap(2) mremap(2), e munmap(2).

-?, --Aiuto
Stampa la guida ed esci.

--uso
Stampa un breve messaggio di utilizzo ed esci.

-V, --versione
Stampa le informazioni sulla versione ed esci.

Le seguenti opzioni si applicano solo quando si genera un output grafico:

-t, --basato sul tempo
Usa il tempo (piuttosto che il numero di chiamate di funzione) come scala per l'asse X.

-T, --totale
Disegna anche un grafico dell'utilizzo totale della memoria.

--titolo=Nome
Usa il Nome come titolo del grafico.

-x Taglia, --x-dimensione=Taglia
Fai il grafico Taglia pixel di larghezza.

-y Taglia, --y-dimensione=Taglia
Fai il grafico Taglia pixel di altezza.

EXIT STATUS

Lo stato di uscita è uguale allo stato di uscita del programma profilato.

ESEMPIO

Di seguito è riportato un semplice programma che rialloca un blocco di memoria in cicli che raggiungono un picco
prima di riallocare poi ciclicamente la memoria in blocchi più piccoli che tornano a zero.
Dopo aver compilato il programma ed eseguito i seguenti comandi, un grafico della memoria
l'utilizzo del programma può essere trovato nel file memusage.png:

$ messaggio --data=memusage.dat ./a.fuori
...
Riepilogo utilizzo memoria: totale heap: 45200, picco heap: 6440, picco stack: 224
chiamate totali memoria totale chiamate non riuscite
malloc| 1 400 0
realloc| 40 44800 0 (nomove:40, dic:19, libero:0)
calloc| 0 0 0
gratis| 1 440
Istogramma per le dimensioni dei blocchi:
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

Programma source
#includere
#includere

#define CICLI 20

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

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

for (i = 0; i < CICLI; i++) {
se (i < CICLI / 2)
j = io;
altro
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));
}

libero (p);
uscita(EXIT_SUCCESS);
}

Usa memusage online utilizzando i servizi onworks.net