¿Cómo mido el uso del núcleo de la CPU por separado para un proceso?

¿Hay alguna forma de medir el uso de CPU de un proceso específico por núcleos?

Sé que top es bueno para medir el uso de CPU de todo el sistema por núcleos y el conjunto de tareas puede proporcionar información sobre qué núcleo de CPU está permitido para que se ejecute el proceso.

Pero, ¿cómo mido el uso de CPU de un proceso específico por núcleos de CPU?

Todavía puedes hacer esto en la parte superior . Mientras se ejecuta top , presione '1' en su teclado, luego mostrará el uso de CPU por núcleo.

Limite los procesos que se muestran haciendo que ese proceso específico se ejecute bajo una cuenta de usuario específica y use el tipo 'u' para limitar a ese usuario

Puedes usar:

 mpstat -P ALL 1

Muestra cuánto está ocupado cada núcleo y se actualiza automáticamente cada segundo. La salida sería algo como esto (en un procesador de cuatro núcleos):

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

Este comando no responde a la pregunta original, es decir, no muestra el uso del núcleo de la CPU para un proceso específico.

puede utilizar ps.
por ejemplo, tener un proceso de Python con dos subprocesos ocupados en la CPU de doble núcleo:

$ 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 es el ID de CPU al que está asignado el hilo)

ve que los subprocesos se ejecutan en el mismo núcleo de la CPU (debido a GIL)

ejecutando el mismo script de Python en jython, vemos que el script está utilizando ambos núcleos (y hay muchos otros servicios o cualquier subproceso, que están casi inactivos):

$ 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

puede procesar la salida y calcular la CPU total para cada núcleo de CPU.

Desafortunadamente, este enfoque no parece ser 100% confiable, a veces veo que en el primer caso, se informa que los dos subprocesos de trabajo están separados para cada núcleo de la CPU, o en el último caso, se informa que los dos subprocesos están en el mismo núcleo ..

htop ofrece una buena descripción general del uso del núcleo individual

La pssolución fue casi lo que necesitaba y, con algo de bash, hace exactamente lo que pedía la pregunta original: ver el uso por núcleo de procesos específicos

Esto también muestra el uso por núcleo de procesos multiproceso .

Utilice como: cpustat `pgrep nombre de proceso`` pgrep otro nombre de proceso` ...

#!/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

Nota: Estas estadísticas se basan en la vida útil del proceso , no en los últimos X segundos, por lo que deberá reiniciar el proceso para restablecer el contador.

dstat -C 0,1,2,3 

También le dará el uso de CPU de los primeros 4 núcleos. Por supuesto, si tiene 32 núcleos, este comando se alarga un poco, pero es útil si solo le interesan unos pocos núcleos.

Por ejemplo, si solo te interesan los núcleos 3 y 7, puedes hacer

dstat -C 3,7

Solo tuve este problema y encontré una respuesta similar aquí .

El método es configurarlo de topla manera que desee y luego presionar W(W mayúscula). Esto guarda topel diseño actual en un archivo de configuración en $ HOME / .toprc

Aunque esto podría no funcionar si desea ejecutar varios topcon diferentes configuraciones.

Entonces, a través de lo que considero una solución alternativa, puede escribir en diferentes archivos de configuración / usar diferentes archivos de configuración haciendo uno de los siguientes ...

1) Cambiar el nombre del binario

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

Ahora .top2rcse escribirá en su $ HOME

2) Establezca $ HOME en una ruta alternativa, ya que escribirá su archivo de configuración en el archivo $ HOME / .binary-name.rc

HOME=./
top

Ahora .toprcse escribirá en la carpeta actual.

Mediante el uso de los comentarios de otras personas para agregar las diversas cuentas de uso en la parte superior, puede crear una salida por lotes para esa información y luego fusiona la información a través de un script. Tal vez no sea tan simple como su script, pero encontré que top me proporciona TODOS los procesos para que luego pueda recapitular y capturar un estado durante una ejecución larga que podría haber perdido de otra manera (uso repentino inexplicable de la CPU debido a procesos perdidos)

Pensé que perf states lo que necesitas.

Muestra un uso específico de un proceso cuando especifica una --cpu=listopción. A continuación, se muestra un ejemplo de cómo monitorear el uso de la CPU al construir un proyecto usando perf stat --cpu=0-7 --no-aggr -- make all -jcommand. La salida es:

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 columna de la izquierda es el índice de CPU específico y la columna más a la derecha es el uso de la CPU. Si no especifica la --no-aggropción, el resultado se agregará. La --pid=pidopción le ayudará si desea monitorear un proceso en ejecución.

Prueba -a --per-coreo -a perf-sockettambién, que presentará información más clasificada.

Se perf statpuede ver más sobre el uso de en este tutorial: perf cpu statistic , también perf help statayudará en el significado de las opciones.