web-dev-qa-db-fra.com

Utilisation maximale de la mémoire d'un processus linux / unix

Existe-t-il un outil permettant d'exécuter une ligne de commande et de signaler le pic d'utilisation RAM?

J'imagine quelque chose d'analogue à/usr/bin/time

linuxcommand-linememory-management
348
jes5199

Voici un one-liner qui ne nécessite aucun script ni utilitaire externe et ne vous oblige pas à démarrer le processus via un autre programme tel que Valgrind ou time. Vous pouvez donc l'utiliser pour tous les processus en cours d'exécution:

grep VmPeak /proc/$PID/status

(remplacez $PID par le PID du processus qui vous intéresse)

11
erobertc

[Edit: Fonctionne sur Ubuntu 14.04: /usr/bin/time -v command Assurez-vous d'utiliser le chemin complet.]

On dirait que /usr/bin/time vous donne cette information, si vous passez -v (c'est sur Ubuntu 8.10). Voir, par exemple, Maximum resident set size ci-dessous:

 $/usr/bin/time -v ls /
....
 Commande en cours: "ls /"
 Temps utilisateur (secondes): 0.00 
 Temps système (secondes): 0.01 
 Pourcentage de CPU de ce travail: 250% 
 Temps écoulé (horloge murale) (h: mm: ss ou m: ss): 0 : 00.00 
 Taille moyenne du texte partagé (kilo-octets): 0 
 Taille moyenne des données non partagées (kilo-octets): 0 
 Taille moyenne de la pile (kilo-octets): 0 
 Total moyen taille (kilo-octets): 0 
 taille maximale du groupe de résidents (kilo-octets): 0 
 taille moyenne du groupe de résidents (kilo-octets): 0 
 défauts de page majeurs (nécessitant des E/S): 0 
 Erreurs de page mineures (récupération d'un cadre): 315 
 Changements de contexte volontaires: 2 
 Changements de contexte involontaires: 0 
 Permutations: 0 
 Système de fichiers entrées: 0 
 sorties du système de fichiers: 0 
 Messages de socket envoyés: 0 
 Messages de socket reçus: 0 
 Signaux d livré: 0 
 Taille de la page (en octets): 4096 
 Statut de sortie: 0
365
Jacob Gabrielson

(C’est une question déjà posée, ancienne question .. mais juste pour le compte rendu :)

Le script de Yang m'a inspiré et j'ai créé ce petit outil nommé memusg . J'ai simplement augmenté le taux d'échantillonnage à 0,1 pour gérer beaucoup de processus de courte durée. Au lieu de surveiller un seul processus, je lui ai fait mesurer la somme rss du groupe de processus. (Oui, j'écris beaucoup de programmes distincts qui fonctionnent ensemble) Cela fonctionne actuellement sur Mac OS X et Linux. L’utilisation devait être similaire à celle de time:

 memusg ls -alR />/dev/null

Il ne montre que le pic pour le moment, mais je suis intéressé par de petites extensions pour enregistrer d’autres statistiques (approximatives).

C'est bien d'avoir un outil aussi simple pour jeter un coup d'œil avant de commencer tout profilage sérieux.

94
netj

Valgrind one-liner:

valgrind --tool=massif --pages-as-heap=yes --massif-out-file=massif.out ./test.sh; grep mem_heap_B massif.out | sed -e 's/mem_heap_B=\(.*\)/\1/' | sort -g | tail -n 1

Notez l'utilisation de --pages-as-heap pour mesurer toute la mémoire d'un processus. Plus d'infos ici: http://valgrind.org/docs/manual/ms-manual.html

61
jbeard4

Peut-être que (gnu) time (1) fait déjà ce que vous voulez. Par exemple:

$ /usr/bin/time -f "%P %M" command
43% 821248

Mais d'autres outils de profilage peuvent donner des résultats plus précis en fonction de ce que vous recherchez.

30
Jon Ericson

Sous Linux:

Utilisez /usr/bin/time -v <program> <args> et cherchez " Taille maximale du groupe de résidents ".

(Ne pas confondre avec la commande intégrée Bash time! Utilisez donc le chemin complet, /usr/bin/time)

Par exemple:

> /usr/bin/time -v ./myapp
        User time (seconds): 0.00
        . . .
        Maximum resident set size (kbytes): 2792
        . . .

Sur BSD, MacOS:

Utilisez /usr/bin/time -l <program> <args> en recherchant " taille maximale du groupe de résidents ":

>/usr/bin/time -l ./myapp
        0.01 real         0.00 user         0.00 sys
      1440  maximum resident set size
      . . .
18
rustyx

/ usr/bin/time fait peut-être ce que vous voulez, en fait. Quelque chose comme.

/usr/bin/time --format = '(% Xtext +% Ddata% Mmax)'

Voir le temps (1) pour plus de détails ...

18
simon

Si le processus s'exécute pendant au moins quelques secondes, vous pouvez utiliser le script bash suivant, qui exécute la ligne de commande donnée, puis affiche le flux RSS maximal (remplace le paramètre rss par tout autre attribut qui vous intéresse. ) C'est un peu léger, et cela fonctionne pour moi avec la ps incluse dans Ubuntu 9.04 (que je ne peux pas dire pour time).

#!/usr/bin/env bash
"$@" & # Run the given command line in the background.
pid=$! peak=0
while true; do
  sleep 1
  sample="$(ps -o rss= $pid 2> /dev/null)" || break
  let peak='sample > peak ? sample : peak'
done
echo "Peak: $peak" 1>&2
16
Yang

Sur MacOS Sierra, utilisez:

/usr/bin/time -l commandToMeasure

Vous pouvez utiliser grep pour prendre ce que vous voulez peut-être.

15
gsamaras

Eh bien, si vous voulez vraiment afficher le pic de mémoire et des statistiques plus détaillées, je vous recommande d’utiliser un profileur tel que valgrind . Un joli frontal valgrind est alleyoop .

8
alexn
time -f '%M' <run_program>
7
Jason

Vous pouvez utiliser un outil tel que Valgrind pour le faire.

5
Dana the Sane

Voici (basé sur les autres réponses) un script très simple qui surveille un processus déjà en cours d'exécution. Vous venez de l'exécuter avec le pid du processus que vous voulez regarder comme argument:

#!/usr/bin/env bash

pid=$1

while ps $pid >/dev/null
do
    ps -o vsz= ${pid}
    sleep 1
done | sort -n | tail -n1

Exemple d'utilisation:

max_mem_usage.sh 23423
5
static_rtti

Heaptrack est un outil KDE doté d'une interface graphique et d'une interface texte. Je trouve plus approprié que valgrind de comprendre l'utilisation de la mémoire d'un processus, car il fournit plus de détails et de graphiques de flamme. C'est aussi plus rapide parce qu'il vérifie moins que valgrind. Et cela vous donne l'utilisation maximale de la mémoire.

Quoi qu'il en soit, suivre les flux rss et vss est trompeur, car les pages pourraient être partagées, c’est pourquoi memusg. Ce que vous devriez vraiment faire est de suivre la somme de Pss dans /proc/[pid]/smaps ou d’utiliser pmap. Moniteur système GNOME le faisait auparavant, mais c'était trop cher.

1
Benoît

Réinventer la roue, avec le script bash fabriqué à la main. Rapide et propre.

Mon cas d'utilisation: Je voulais surveiller une machine Linux qui avait moins de RAM et je voulais prendre un instantané de l'utilisation de chaque conteneur lorsqu'il fonctionnait de manière intensive.

#!/usr/bin/env bash

threshold=$1

echo "$(date '+%Y-%m-%d %H:%M:%S'): Running free memory monitor with threshold $threshold%.."

while(true)
    freePercent=`free -m | grep Mem: | awk '{print ($7/$2)*100}'`    
  do

  if (( $(awk 'BEGIN {print ("'$freePercent'" < "'$threshold'")}') ))
  then
       echo "$(date '+%Y-%m-%d %H:%M:%S'): Free memory $freePercent% is less than $threshold%"
       free -m
       docker stats --no-stream
       sleep 60  
       echo ""  
  else
       echo "$(date '+%Y-%m-%d %H:%M:%S'): Sufficient free memory available: $freePercent%"
  fi
  sleep 30

done

Exemple de sortie:

2017-10-12 13:29:33: Exécution d'un moniteur de mémoire libre avec un seuil de 30% ..

2017-10-12 13:29:33: Mémoire libre suffisante en quantité suffisante: 69.4567%

2017-10-12 13:30:03: Mémoire libre suffisante en quantité disponible: 69.4567%

2017-10-12 16:47:02: Mémoire libre 18,9387%, moins de 30%

votre sortie de commande personnalisée

1
147.3k

Utilisez Massif: http://valgrind.org/docs/manual/ms-manual.html

1
Hans W

Sur macOS, vous pouvez plutôt utiliser DTrace. L'application "Instruments" est une interface graphique de Nice pour cela, elle est livrée avec XCode.

1
Michael Böckling

'htop' est la meilleure commande pour voir quel processus utilise combien de RAM .....

pour plus de détails http://manpages.ubuntu.com/manpages/precise/man1/htop.1.html

0
Sanket