Comment surveiller l'utilisation CPU / mémoire d'un seul processus?
Je voudrais surveiller l'utilisation de la mémoire/du processeur d'un processus en temps réel. Similaire à top mais ciblé sur un seul processus, de préférence avec un graphique d'historique quelconque.
Sous Linux, top prend en charge la focalisation sur un seul processus, bien qu'il n'ait naturellement pas de graphique d'historique:
top -p PID
Ceci est également disponible sur Mac OS X avec une syntaxe différente:
top -pid PID
psrecord
Les adresses suivantes graphique historique d'une certaine sorte . Python psrecord package fait exactement cela.
pip install psrecord # local user install
Sudo apt-get install python-matplotlib python-tk # for plotting; or via pip
Pour un processus unique, c'est le suivant (arrêté par Ctrl+C):
psrecord $(pgrep proc-name1) --interval 1 --plot plot1.png
Pour plusieurs processus, le script suivant est utile pour synchroniser les graphiques:
#!/bin/bash
psrecord $(pgrep proc-name1) --interval 1 --duration 60 --plot plot1.png &
P1=$!
psrecord $(pgrep proc-name2) --interval 1 --duration 60 --plot plot2.png &
P2=$!
wait $P1 $P2
echo 'Done'
Les graphiques ressemblent à: 
memory_profiler
Le package fournit un échantillonnage RSS uniquement (plus quelques options spécifiques à Python). Il peut également enregistrer un processus avec ses processus enfants (voir mprof --help).
pip install memory_profiler
mprof run /path/to/executable
mprof plot
Par défaut, une fenêtre basée sur Tkinter (python-tk peut être nécessaire) Explorateur de graphiques qui peut être exporté:
graphite-stack & statsd
Cela peut sembler exagéré pour un simple test unique, mais pour quelque chose comme un débogage de plusieurs jours, c'est certainement raisonnable. Un tout-en-un pratique raintank/graphite-stack (des auteurs de Grafana) image et psutil et statsd client. procmon.py fournit une implémentation.
$ docker run --rm -p 8080:3000 -p 8125:8125/udp raintank/graphite-stack
Puis dans un autre terminal, après avoir démarré le processus cible:
$ Sudo apt-get install python-statsd python-psutil # or via pip
$ python procmon.py -s localhost -f chromium -r 'chromium.*'
Ensuite, ouvrez Grafana à http: // localhost: 808 , authentification comme admin:admin, configuration de la source de données https: // localhost , vous pouvez tracer un graphique comme:
graphite-stack & telegraf
Au lieu de Python envoie les métriques à Statsd, telegraf (et procstat plugin d'entrée) peut être utilisé pour envoyer les métriques directement au graphite.
La configuration minimale de telegraf ressemble à:
[agent]
interval = "1s"
[[outputs.graphite]]
servers = ["localhost:2003"]
prefix = "testprfx"
[[inputs.procstat]]
pid_file = "/path/to/file/with.pid"
Exécutez ensuite la ligne telegraf --config minconf.conf. La partie Grafana est la même, à l'exception des noms de métriques.
pidstat
pidstat (partie du package sysstat) peut produire une sortie qui peut être facilement analysée. C'est utile dans le cas où vous avez besoin de mesures supplémentaires du (des) processus, par exemple les 3 groupes les plus utiles (CPU, mémoire et disque) contiennent: %usr, %system, %guest, %CPU, minflt/s, majflt/s, VSZ, RSS, %MEM, kB_rd/s, kB_wr/s, kB_ccwr/s. Je l'ai décrit dans ne réponse connexe .
htop est un excellent remplacement de top. Il a ... des couleurs! Raccourcis clavier simples! Faites défiler la liste à l'aide des touches fléchées! Tuez un processus sans quitter et sans prendre note du PID! Marquez plusieurs processus et tuez-les tous!
Parmi toutes les fonctionnalités, la page de manuel indique que vous pouvez appuyer sur F pour suivre un processus.
Vraiment, vous devriez essayer htop. Je n'ai jamais recommencé top, après la première fois que j'ai utilisé htop.
Afficher un seul processus:
htop -p PID
Pour utiliser ces informations sur un script, vous pouvez procéder comme suit:
calcPercCpu.sh
#!/bin/bash
nPid=$1;
nTimes=10; # customize it
delay=0.1; # customize it
strCalc=`top -d $delay -b -n $nTimes -p $nPid \
|grep $nPid \
|sed -r -e "s;\s\s*; ;g" -e "s;^ *;;" \
|cut -d' ' -f9 \
|tr '\n' '+' \
|sed -r -e "s;(.*)[+]$;\1;" -e "s/.*/scale=2;(&)\/$nTimes/"`;
nPercCpu=`echo "$strCalc" |bc -l`
echo $nPercCpu
utiliser comme: calcPercCpu.sh 1234 où 1234 est le pid
Pour le $ nPid spécifié, il mesurera la moyenne de 10 instantanés de l'utilisation du processeur en 1 seconde (retard de 0,1 s chacun * nTimes = 10); qui fournit un bon résultat précis et rapide de ce qui se passe en ce moment même.
Ajustez les variables à vos besoins.
J'utilise normalement les deux suivants:
HP caliper : son très bon outil pour surveiller les processus, vous pouvez également consulter le graphique des appels et d'autres informations de bas niveau. Mais veuillez noter que c'est gratuit uniquement pour un usage personnel.
daemontools : une collection d'outils pour gérer les services UNIX
En utilisant top et awk on pourrait facilement créer par exemple un journal séparé par des virgules de% CPU ($9) +% MEM ($10) utilisation qui pourra ensuite être introduite dans n'importe quel outil de statistiques et de graphiques.
top -b -d $delay -p $pid | awk -v OFS="," '$1+0>0 {
print strftime("%Y-%m-%d %H:%M:%S"),$1,$NF,$9,$10; fflush() }'
La sortie sera comme
2019-03-26 17:43:47,2991,firefox,13.0,5.2
2019-03-26 17:43:48,2991,firefox,4.0,5.2
2019-03-26 17:43:49,2991,firefox,64.0,5.3
2019-03-26 17:43:50,2991,firefox,71.3,5.4
2019-03-26 17:43:51,2991,firefox,67.0,5.4
Cela ne donnera pas de bons résultats pour les grands $delay, cependant, car l'horodatage imprimé est en fait $delay derrière en raison du fonctionnement de la sortie de top. Sans entrer dans trop de détails, une façon simple de contourner cela est de consigner le temps fourni par top:
top -b -d $delay -p $pid | awk -v OFS="," '$1=="top"{ time=$3 }
$1+0>0 { print time,$1,$NF,$9,$10; fflush() }'
L'horodatage est alors précis, mais la sortie sera toujours retardée de $delay.
Si vous connaissez le nom du processus que vous pouvez utiliser
top -p $(pidof <process_name>)
Je suis un peu en retard ici, mais je vais partager mon astuce en ligne de commande en utilisant uniquement la valeur par défaut ps
WATCHED_PID=$({ command_to_profile >log.stdout 2>log.stderr & } && echo $!);
while ps -p $WATCHED_PID --no-headers --format "etime pid %cpu %mem rss"; do
sleep 1
done
Je l'utilise comme une doublure. Ici, la première ligne déclenche la commande et stocke le PID dans la variable. Ensuite, ps affichera le temps écoulé, le PID, le pourcentage de CPU utilisé, le pourcentage de mémoire et la mémoire RSS. Vous pouvez également ajouter d'autres champs.
Dès que le processus se termine, la commande ps ne retourne pas "succès" et la boucle while se termine.
Vous pouvez ignorer la première ligne si le PID que vous souhaitez profiler est déjà en cours d'exécution. Placez simplement l'id souhaité dans la variable.
Vous obtiendrez une sortie comme celle-ci:
00:00 7805 0.0 0.0 2784
00:01 7805 99.0 0.8 63876
00:02 7805 99.5 1.3 104532
00:03 7805 100 1.6 129876
00:04 7805 100 2.1 170796
00:05 7805 100 2.9 234984
00:06 7805 100 3.7 297552
00:07 7805 100 4.0 319464
00:08 7805 100 4.2 337680
00:09 7805 100 4.5 358800
00:10 7805 100 4.7 371736
....
Pas assez de réputation pour commenter, mais pour psrecord vous pouvez aussi l'appeler directement, de manière programmatique, directement en Python:
from psrecord.main import monitor
monitor(<pid number>, logfile = "./test.log", plot="./fig.png", include_children=True)
Si vous avez une distribution Linux réduite où top n'a pas d'option par processus (-p) ou d'options connexes, vous pouvez analyser la sortie de la commande top pour le nom de votre processus pour obtenir les informations d'utilisation du processeur par processus.
while true; do top -bn1 | awk '/your_process_name/ {print $8}' ; sleep 1; done
8 représente l'utilisation du processeur par processus dans la sortie de la commande supérieure dans ma distribution Linux intégrée
pidstat -p 7994 2
03:54:43 PM UID PID %usr %system %guest %CPU CPU Command
03:54:45 PM 0 7994 1.50 1.50 0.00 3.00 1 AliYunDun
03:54:47 PM 0 7994 1.00 1.00 0.00 2.00 0 AliYunDun
toutes les 2 secondes processus d'impression Utilisation de 7994 cpu
Si vous avez besoin des moyennes pour une période de temps d'un processus spécifique, essayez l'option cumulative -c en haut:
top -c a -pid PID
"-c a" trouvé en haut pour Mac 10.8.5.
Pour Scientific Linux, l'option est -S, qui peut être définie de manière interactive.