memusage - En ligne dans le Cloud

PROGRAMME:

Nom

memusage - profil de l'utilisation de la mémoire d'un programme

SYNOPSIS

mémusage [option] ... Danse [option de programme] ...

DESCRIPTION

mémusage est un script bash qui profile l'utilisation de la mémoire du programme, Danse. Il
précharge le libmemusage.so bibliothèque dans l'environnement de l'appelant (via le LD_PRÉCHARGER
variable d'environnement ; voir ld.so(8)). Les libmemusage.so la bibliothèque trace l'allocation de mémoire
en interceptant les appels vers malloc(3), callo(3), faim(3), et réallouer(3) ; en option, les appels
à mmap(2), mremap(2), et carte du monde(2) peut également être intercepté.

mémusage peut sortir les données collectées sous forme textuelle, ou il peut utiliser memusagestat(1) (voir
le -p option, ci-dessous) pour créer un fichier PNG contenant une représentation graphique du
données collectées.

Mémoire usage résumé
La ligne "Résumé d'utilisation de la mémoire" sortie par mémusage contient trois champs :

tas la totalité de votre cycle de coaching doit être payée avant votre dernière session.
Somme de taille arguments de tous malloc(3) appels, produits d'arguments
(nmembre*taille) de tout callo(3) appels, et somme de longueur arguments de tous mmap(2)
appels. Dans le cas d réallouerde Géographie (3) et avec la mremap(2), si la nouvelle taille d'un
l'allocation est plus grande que la taille précédente, la somme de toutes ces différences
(nouvelle taille moins ancienne taille) est ajouté.

tas pic
Maximum de tous taille arguments de malloc(3), tous les produits de nmembre*taille of
callo(3), tous taille arguments de réallouer(3), longueur arguments de mmap(2), et
nouvelle_taille arguments de mremap (2).

empiler pic
Avant le premier appel à une fonction surveillée, l'adresse du pointeur de pile
(pointeur de pile de base) est enregistré. Après chaque appel de fonction, la pile réelle
l'adresse du pointeur est lue et la différence avec le pointeur de la pile de base
calculé. Le maximum de ces différences est alors le pic de la pile.

Immédiatement après cette ligne récapitulative, un tableau indique le nombre d'appels, la mémoire totale
alloués ou désalloués, et nombre d'appels échoués pour chaque fonction interceptée. Pour
réallouerde Géographie (3) et avec la mremap(2), le champ supplémentaire "nomove" montre les réaffectations qui ont changé
l'adresse d'un bloc, et le champ supplémentaire "dec" montre les réallocations qui ont diminué
la taille du bloc. Pour réallouer(3), le champ supplémentaire "libre" affiche les réaffectations
qui a provoqué la libération d'un bloc (c'est-à-dire que la taille réaffectée était de 0).

La "réalloc/mémoire totale" de la table sortie par mémusage ne reflète pas les cas où
réallouer(3) est utilisé pour réallouer un bloc de mémoire pour avoir une taille plus petite qu'auparavant.
Cela peut entraîner une somme de toutes les cellules de « mémoire totale » (à l'exception de « libre ») supérieure à la valeur
cellule "mémoire libre/totale".

Histogramme en bloc tailles
L'« Histogramme des tailles de bloc » fournit une répartition des allocations de mémoire en divers
tailles de seaux.

OPTIONS

-n prénom, --nom_programme=prénom
Nom du fichier programme à profiler.

-p filet, --png=filet
Générez un graphique PNG et stockez-le dans filet.

-d filet, --données=filet
Générez un fichier de données binaires et stockez-le dans filet.

-u, --sans tampon
Ne tamponnez pas la sortie.

-b taille, --tampon=taille
Collecte taille entrées avant de les écrire.

--pas de minuterie
Désactiver le temporisateur (SIGPROF) échantillonnage de la valeur du pointeur de pile.

-m, --mmap
Tracez aussi mmap(2), mremap(2), et carte du monde (2).

-?, --Aidez-moi
Imprimer l'aide et quitter.

--usage
Imprimez un court message d'utilisation et quittez.

-V, --version
Imprimer les informations sur la version et quitter.

Les options suivantes s'appliquent uniquement lors de la génération d'une sortie graphique :

-t, -- basé sur le temps
Utilisez le temps (plutôt que le nombre d'appels de fonction) comme échelle pour l'axe X.

-T, --le total
Tracez également un graphique de l'utilisation totale de la mémoire.

--titre=prénom
Utilisez prénom comme titre du graphique.

-x taille, --x-taille=taille
Faire le graphique taille pixels de large.

-y taille, --y-taille=taille
Faire le graphique taille pixels de haut.

EXIT STATUT

L'état de sortie est égal à l'état de sortie du programme profilé.

EXEMPLE

Vous trouverez ci-dessous un programme simple qui réaffecte un bloc de mémoire en cycles atteignant un pic
avant de réallouer cycliquement la mémoire en blocs plus petits qui reviennent à zéro.
Après avoir compilé le programme et exécuté les commandes suivantes, un graphique de la mémoire
l'utilisation du programme peut être trouvée dans le fichier memusage.png:

$ mémusage --data=memusage.dat ./a.out

Résumé de l'utilisation de la mémoire : total de tas : 45200 6440, pic de tas : 224 XNUMX, pic de pile : XNUMX
nombre total d'appels mémoire totale appels échoués
malloc| 1 400 0
réallouer| 40 44800 0 (nomove : 40, déc : 19, gratuit : 0)
calloc| 0 0 0
gratuit| 1 440
Histogramme des tailles de blocs :
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

Programme la source
#inclut
#inclure

#définir CYCLES 20

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

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

pour (i = 0; i < CYCLES; i++) {
si (i < CYCLES / 2)
j = je;
d'autre
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));
}

libre(p);
quitter(EXIT_SUCCESS);
}

Utiliser memusage en ligne en utilisant les services onworks.net