Récupérer l'utilisation du processeur et l'utilisation de la mémoire d'un seul processus sous Linux?

Je veux obtenir l'utilisation du processeur et de la mémoire d'un seul processus sous Linux - je connais le PID. J'espère que je peux l'obtenir toutes les secondes et l'écrire dans un CSV en utilisant la commande «watch». Quelle commande puis-je utiliser pour obtenir ces informations à partir de la ligne de commande Linux?

ps -p <pid> -o %cpu,%mem,cmd

(Vous pouvez laisser «cmd» désactivé mais cela peut être utile pour le débogage).

Notez que cela donne l'utilisation moyenne du processeur du processus pendant la durée de son exécution.

Une variante de la réponse de caf : top -p <pid>

Cela actualise automatiquement l'utilisation du processeur, c'est donc bon pour la surveillance.

Vous pouvez obtenir les résultats par le nom du processus en utilisant

ps -C chrome -o %cpu,%mem,cmd

l' -Coption vous permet d'utiliser le nom du processus sans connaître son pid.

Utilisez pidstat (depuis sysstat - Refer Link ).

Par exemple, pour surveiller ces deux ID de processus (12345 et 11223) toutes les 5 secondes, utilisez

$ pidstat -h -r -u -v -p 12345,11223 5

ps commande (ne doit pas utiliser):

• L'utilisation du processeur est actuellement exprimée en pourcentage du temps passé à s'exécuter pendant toute la durée de vie d'un processus.

top commande (devrait utiliser):

• Part de la tâche du temps processeur écoulé depuis la dernière mise à jour de l'écran, exprimée en pourcentage du temps processeur total.

Utilisez toppour obtenir l'utilisation du processeur en temps réel (intervalle court actuel):

top -b -n 2 -d 0.2 -p 6962 | tail -1 | awk '{print $9}'

fera écho comme: 78.6

• -b: Temps différé
• -n 2: Nombre d'itérations, utilisez 2parce que: Lorsque vous l'exécutez pour la première fois, il n'a pas d'exemple précédent à comparer, donc ces valeurs initiales sont les pourcentages depuis le démarrage.
• -d 0.2: Temps de retard (en seconde, ici 200ms)
• -p 6962: Moniteur-PID
• tail -1: la dernière ligne
• awk '{print $9}': la 9ème colonne (le numéro d'utilisation du processeur)

Lancer un programme et le surveiller

Ce formulaire est utile si vous souhaitez comparer facilement un exécutable:

topp() (
  $* &>/dev/null &
  pid="$!"
  trap ':' INT
  echo 'CPU  MEM'
  while sleep 1; do ps --no-headers -o '%cpu,%mem' -p "$pid"; done
  kill "$pid"
)
topp ./myprog arg1 arg2

Maintenant, lorsque vous appuyez sur Ctrl + C, il quitte le programme et arrête la surveillance. Exemple de sortie:

CPU  MEM
20.0  1.3
35.0  1.3
40.0  1.3

En relation: /unix/554/how-to-monitor-cpu-memory-usage-of-a-single-process

Testé sur Ubuntu 16.04.

Vous pouvez utiliser top -bet extraire le pid de votre choix (avec l' -bindicateur top s'exécute en mode batch), ou également utiliser l' -pindicateur et spécifier le pid sans utiliser grep.

Comme indiqué dans la réponse de caf ci-dessus, ps et dans certains cas pidstat vous donneront la moyenne de la durée de vie du pCPU. Pour obtenir des résultats plus précis, utilisez top. Si vous devez exécuter top une fois que vous pouvez exécuter:

top -b -n 1 -p <PID>

ou pour traiter uniquement les données et l'en-tête:

top -b -n 1 -p <PID> | tail -3 | head -2

sans en-têtes:

top -b -n 1 -p <PID> | tail -2 | head -1

ps aux | awk '{print $4"\t"$11}' | sort | uniq -c | awk '{print $2" "$1" "$3}' | sort -nr

ou par processus

ps aux | awk '{print $4"\t"$11}' | sort | uniq -c | awk '{print $2" "$1" "$3}' | sort -nr |grep mysql

Pour ceux qui ont lutté pendant un certain temps se demandant pourquoi la réponse choisie ne fonctionne pas:

ps -p <pid> -o %cpu,%mem

Pas d'espace entre %cpu,et %mem.

La commande suivante obtient la moyenne de l'utilisation du processeur et de la mémoire toutes les 40 secondes pour un processus spécifique (pid)

pidstat 40 -ru -p <pid>

Sortie pour mon cas (deux premières lignes pour l'utilisation du processeur, deux secondes pour la mémoire):

02:15:07 PM       PID    %usr %system  %guest    %CPU   CPU  Command
02:15:47 PM     24563    0.65    0.07    0.00    0.73     3  java

02:15:07 PM       PID  minflt/s  majflt/s     VSZ    RSS   %MEM  Command
02:15:47 PM     24563      6.95      0.00 13047972 2123268   6.52  java

Pour obtenir l'utilisation de la mémoire de votre application uniquement (par opposition aux bibliothèques partagées qu'elle utilise, vous devez utiliser l'interface smaps Linux). Cette réponse l'explique bien .

ps aux|awk  '{print $2,$3,$4}'|grep PID

où la première colonne est le PID, l'utilisation du processeur de la deuxième colonne, l'utilisation de la mémoire de la troisième colonne.

ps axo pid,etime,%cpu,%mem,cmd | grep 'processname' | grep -v grep

PID - ID de processus

etime - Exécution du processus / Durée en direct

% cpu - utilisation du processeur

% mem - Utilisation de la mémoire

cmd - Commande

Remplacez processname par le processus que vous souhaitez suivre, mysql nginx php-fpm etc ...

Toutes les réponses ici ne montrent que le pourcentage de mémoire pour le PID.

Voici un exemple de la façon d'obtenir l'utilisation de la mémoire rss en Ko pour tous les processus apache, remplacez "grep apache" par "grep PID" si vous voulez juste regarder un PID spécifique:

watch -n5 "ps aux -y | grep apache | awk '{print \$2,\$6}'"

Cela imprime:

Every 5.0s: ps aux -y | grep apache | awk '{print $2,$6}'                                                                                                                                                                                                          
Thu Jan 25 15:44:13 2018

12588 9328
12589 8700
12590 9392
12591 9340
12592 8700
12811 15200
15453 9340
15693 3800
15694 2352
15695 1352
15697 948
22896 9360

Avec CPU%:

watch -n5 "ps aux -y | grep apache | awk '{print \$2,\$3,\$6}'"

Production:

Every 5.0s: ps aux -y | grep apache | awk '{print $2,$3,$6}'                                                                                                                                                                                                       
Thu Jan 25 15:46:00 2018

12588 0.0 9328
12589 0.0 8700
12590 0.0 9392
12591 0.0 9340
12592 0.0 8700
12811 0.0 15200
15453 0.0 9340
15778 0.0 3800
15779 0.0 2352
15780 0.0 1348
15782 0.0 948
22896 0.0 9360

C'est une belle astuce pour suivre un ou plusieurs programmes en temps réel tout en regardant la sortie d'un autre outil: watch "top -bn1 -p$(pidof foo),$(pidof bar); tool"

(Si vous êtes sous MacOS 10.10, essayez l'option -c cumulative de top:

top -c a -pid PID

(Cette option n'est pas disponible dans d'autres Linux, essayée avec Scientific Linux el6 et RHEL6)

Ci-dessus la liste des meilleurs processeurs et processus de consommation de mémoire

        ps axo %cpu,%mem,command | sort -nr | head

Basé sur la réponse de @ caf, cela fonctionne très bien pour moi.

Calculer la moyenne pour un PID donné:

mesure.sh

times=100
total=0
for i in $(seq 1 $times)
do
   OUTPUT=$(top -b -n 1 -d 0.1 -p $1 | tail -1 | awk '{print $9}')
   echo -n "$i time: ${OUTPUT}"\\r
   total=`echo "$total + $OUTPUT" | bc -l`
done
#echo "Average: $total / $times" | bc

average=`echo "scale=2; $total / $times" | bc`
echo "Average: $average"

Usage:

# send PID as argument
sh measure.sh 3282

Utilisation du processeur et de la mémoire d'un seul processus sous Linux ou vous pouvez obtenir les 10 meilleurs processus utilisés par le processeur en utilisant la commande ci-dessous

ps -aux --sort -pcpu | tête -n 11