it-swarm-eu.dev

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.

194
Josh K

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
157
Michael Mrozek

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 à: psrecord example

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é:

mprof

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:

grafana chart

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 .

87
saaj

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

67
Denilson Sá Maia

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.

8
Aquarius Power

J'utilise normalement les deux suivants:

  1. 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.

  2. daemontools : une collection d'outils pour gérer les services UNIX

5
Hemant

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.

5
xebeche

Si vous connaissez le nom du processus que vous pouvez utiliser

top -p $(pidof <process_name>)
2
user4757345

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
  ....
2
theist

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)
2
ZettaCircl

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

1
Razan Paul
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

0
赵宝磊

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.

0
Kieleth