Comment mesurer l'utilisation séparée du cœur du processeur pour un processus?

Existe-t-il un moyen de mesurer l'utilisation du processeur d'un processus spécifique par les cœurs?

Je sais que top est bon pour mesurer l'utilisation du processeur de l'ensemble du système par les cœurs et l'ensemble de tâches peut fournir des informations sur le cœur de processeur autorisé pour le processus.

Mais comment mesurer l'utilisation du processeur d'un processus spécifique par les cœurs de processeur?

Vous pouvez toujours le faire en haut . Tout en haut est en cours d'exécution, appuyez sur «1» sur votre clavier, il affichera alors l'utilisation du processeur par cœur.

Limitez les processus affichés en exécutant ce processus spécifique sous un compte d'utilisateur spécifique et utilisez le type 'u' pour limiter à cet utilisateur

Vous pouvez utiliser:

 mpstat -P ALL 1

Il montre combien chaque noyau est occupé et il se met à jour automatiquement chaque seconde. La sortie serait quelque chose comme ceci (sur un processeur quad-core):

10:54:41 PM  CPU    %usr   %nice    %sys %iowait    %irq   %soft  %steal  %guest   %idle
10:54:42 PM  all    8.20    0.12    0.75    0.00    0.00    0.00    0.00    0.00   90.93
10:54:42 PM    0   24.00    0.00    2.00    0.00    0.00    0.00    0.00    0.00   74.00
10:54:42 PM    1   22.00    0.00    2.00    0.00    0.00    0.00    0.00    0.00   76.00
10:54:42 PM    2    2.02    1.01    0.00    0.00    0.00    0.00    0.00    0.00   96.97
10:54:42 PM    3    2.00    0.00    0.00    0.00    0.00    0.00    0.00    0.00   98.00
10:54:42 PM    4   14.15    0.00    1.89    0.00    0.00    0.00    0.00    0.00   83.96
10:54:42 PM    5    1.00    0.00    0.00    0.00    0.00    0.00    0.00    0.00   99.00
10:54:42 PM    6    0.00    0.00    0.00    0.00    0.00    0.00    0.00    0.00  100.00
10:54:42 PM    7    0.00    0.00    0.00    0.00    0.00    0.00    0.00    0.00  100.00

Cette commande ne répond pas à la question d'origine, c'est-à-dire qu'elle n'affiche pas l'utilisation du cœur du processeur pour un processus spécifique.

vous pouvez utiliser ps.
par exemple, avoir un processus python avec deux threads occupés sur un processeur double cœur:

$ ps -p 29492 -L -o pid,tid,psr,pcpu
  PID   TID PSR %CPU
29492 29492   1  0.0
29492 29493   1 48.7
29492 29494   1 51.9

(PSR est l'identifiant du processeur auquel le thread est actuellement affecté)

vous voyez que les threads fonctionnent sur le même cœur de processeur (à cause de GIL)

exécutant le même script python en jython, nous voyons que le script utilise les deux cœurs (et il existe de nombreux autres services ou autres threads, qui sont presque inactifs):

$ ps -p 28671 -L -o pid,tid,psr,pcpu
  PID   TID PSR %CPU
28671 28671   1  0.0
28671 28672   0  4.4
28671 28673   0  0.6
28671 28674   0  0.5
28671 28675   0  2.3
28671 28676   0  0.0
28671 28677   1  0.0
28671 28678   1  0.0
28671 28679   0  4.6
28671 28680   0  4.4
28671 28681   1  0.0
28671 28682   1  0.0
28671 28721   1  0.0
28671 28729   0 88.6
28671 28730   1 88.5

vous pouvez traiter la sortie et calculer le CPU total pour chaque cœur de CPU.

Malheureusement, cette approche ne semble pas être fiable à 100%, parfois je vois que dans le premier cas, les deux threads de travail sont signalés comme étant séparés de chaque cœur de processeur, ou dans ce dernier cas, les deux threads sont signalés comme étant sur le même noyau ..

htop donne un bon aperçu de l'utilisation individuelle du cœur

La pssolution était presque ce dont j'avais besoin et avec un peu de bash ajouté, fait exactement ce que la question initiale demandait: voir l'utilisation par cœur de processus spécifiques

Cela montre également l'utilisation par cœur des processus multi-threads .

Utilisez comme: cpustat `pgrep processname`` pgrep otherprocessname` ...

#!/bin/bash

pids=()
while [ $# != 0 ]; do
        pids=("${pids[@]}" "$1")
        shift
done

if [ -z "${pids[0]}" ]; then
        echo "Usage: $0 <pid1> [pid2] ..."
        exit 1
fi

for pid in "${pids[@]}"; do
        if [ ! -e /proc/$pid ]; then
                echo "Error: pid $pid doesn't exist"
                exit 1
        fi
done

while [ true ]; do
        echo -e "\033[H\033[J"
        for pid in "${pids[@]}"; do
                ps -p $pid -L -o pid,tid,psr,pcpu,comm=
        done
        sleep 1
done

Remarque: ces statistiques sont basées sur la durée de vie du processus , et non sur les X dernières secondes, vous devrez donc redémarrer votre processus pour réinitialiser le compteur.

dstat -C 0,1,2,3 

Vous donnera également l'utilisation du processeur des 4 premiers cœurs. Bien sûr, si vous avez 32 cœurs, cette commande devient un peu plus longue mais utile si vous ne vous intéressez qu'à quelques cœurs.

Par exemple, si vous n'êtes intéressé que par les core 3 et 7, vous pouvez

dstat -C 3,7

J'avais juste ce problème et j'ai trouvé une réponse similaire ici .

La méthode consiste à définir topcomme vous le souhaitez, puis à appuyer sur W(W majuscule). Cela enregistre topla mise en page actuelle dans un fichier de configuration dans $ HOME / .toprc

Bien que cela puisse ne pas fonctionner si vous souhaitez en exécuter plusieurs topavec des configurations différentes.

Donc, via ce que je considère comme un travail, vous pouvez écrire dans différents fichiers de configuration / utiliser différents fichiers de configuration en effectuant l'une des opérations suivantes ...

1) Renommez le binaire

  ln -s /usr/bin/top top2
  ./top2

Va maintenant .top2rcêtre écrit dans votre $ HOME

2) Définissez $ HOME sur un chemin alternatif, car il écrira son fichier de configuration dans le fichier $ HOME / .binary-name.rc

HOME=./
top

Maintenant .toprc être écrit dans le dossier actuel.

En utilisant les commentaires d'autres personnes pour ajouter les divers comptes d'utilisation en haut, vous pouvez créer une sortie par lots pour ces informations et ces dernières fusionnent les informations via un script. Peut-être pas aussi simple que votre script, mais j'ai trouvé top pour me fournir TOUS les processus afin que plus tard, je puisse récapituler et capturer un état pendant une longue période que j'aurais peut-être manqué autrement (utilisation soudaine du processeur inexpliquée en raison de processus errants)

J'ai pensé que c'était perf statce dont tu avais besoin.

Il montre une utilisation spécifique d'un processus lorsque vous spécifiez une --cpu=listoption. Voici un exemple de surveillance de l'utilisation du processeur lors de la construction d'un projet à l'aide de la perf stat --cpu=0-7 --no-aggr -- make all -jcommande. La sortie est:

CPU0         119254.719293 task-clock (msec)         #    1.000 CPUs utilized            (100.00%)
CPU1         119254.724776 task-clock (msec)         #    1.000 CPUs utilized            (100.00%)
CPU2         119254.724179 task-clock (msec)         #    1.000 CPUs utilized            (100.00%)
CPU3         119254.720833 task-clock (msec)         #    1.000 CPUs utilized            (100.00%)
CPU4         119254.714109 task-clock (msec)         #    1.000 CPUs utilized            (100.00%)
CPU5         119254.727721 task-clock (msec)         #    1.000 CPUs utilized            (100.00%)
CPU6         119254.723447 task-clock (msec)         #    1.000 CPUs utilized            (100.00%)
CPU7         119254.722418 task-clock (msec)         #    1.000 CPUs utilized            (100.00%)
CPU0                 8,108 context-switches          #    0.068 K/sec                    (100.00%)
CPU1                26,494 context-switches                                              (100.00%)
CPU2                10,193 context-switches                                              (100.00%)
CPU3                12,298 context-switches                                              (100.00%)
CPU4                16,179 context-switches                                              (100.00%)
CPU5                57,389 context-switches                                              (100.00%)
CPU6                 8,485 context-switches                                              (100.00%)
CPU7                10,845 context-switches                                              (100.00%)
CPU0                   167 cpu-migrations            #    0.001 K/sec                    (100.00%)
CPU1                    80 cpu-migrations                                                (100.00%)
CPU2                   165 cpu-migrations                                                (100.00%)
CPU3                   139 cpu-migrations                                                (100.00%)
CPU4                   136 cpu-migrations                                                (100.00%)
CPU5                   175 cpu-migrations                                                (100.00%)
CPU6                   256 cpu-migrations                                                (100.00%)
CPU7                   195 cpu-migrations                                                (100.00%)

La colonne de gauche est l'index CPU spécifique et la colonne la plus à droite est l'utilisation du CPU. Si vous ne spécifiez pas l' --no-aggroption, le résultat sera agrégé. L' --pid=pidoption vous aidera si vous souhaitez surveiller un processus en cours d'exécution.

Essayez -a --per-coreou -a perf-socketaussi, qui présentera des informations plus classifiées.

Plus d'informations sur l'utilisation de perf statpeuvent être vues dans ce tutoriel: perf cpu statistic , perf help stataidera également sur la signification des options.