Как измерить отдельное использование центрального процессора для процесса?

Есть ли способ измерить конкретное использование ЦП процессора по ядрам?

Я знаю top хорош для измерения всего использования ЦП процессора по ядрам и taskset может предоставить информацию о том, какой процессорный ядро ​​разрешен для запуска процесса.

Но как я могу измерить конкретный процесс "Использование ЦП ядрами процессора?"

Ответ 1

Вы все еще можете сделать это сверху

Тип 1 - показывает каждый cpu

Ограничьте процессы, показанные тем, что этот конкретный процесс выполняется под определенной учетной записью пользователя и используйте "u" для ограничения этого пользователя

Ответ 2

Вы можете использовать:

 mpstat -P ALL 1

Показывает, сколько ячеек занято и оно обновляется автоматически каждую секунду. Результат будет примерно таким (на четырехъядерном процессоре):

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

Эта команда не отвечает на исходный вопрос, хотя он не показывает использование ядра ЦП для определенного процесса.

Ответ 3

вы можете использовать ps.
например с процессом python с двумя занятыми потоками на двухъядерном процессоре:

$ 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 - это идентификатор CPU, которому в данный момент назначен поток)

вы видите, что потоки работают на одном ядре процессора (из-за GIL)

работает с тем же самым python script в jython, мы видим, что script использует оба ядра (и есть много других сервисов или любых потоков, которые почти простаивают):

$ 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

вы можете обрабатывать выходные данные и вычислять общий процессор для каждого ядра ЦП.

К сожалению, этот подход, похоже, не на 100% надежный, иногда я вижу, что в первом случае два рабочих потока, как сообщается, разделяются на каждое ядро ​​ЦП или в последнем случае сообщаются два потока быть на одном ядре.

Ответ 4

Решение ps было почти тем, что мне было нужно, и с некоторым количеством bash, которое было сделано, делает именно то, что задал первоначальный вопрос: видеть использование ядра в конкретных ядрах

Это показывает использование ядра для многопоточных процессов.

Используйте как: 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

Примечание. Эти статистические данные основаны на времени жизни процесса, а не на последних X секундах, поэтому вам нужно перезапустить процесс до reset счетчика.

Ответ 5

dstat -C 0,1,2,3 

Также даст вам использование ЦП первых 4 ядер. Конечно, если у вас есть 32 ядра, эта команда становится немного длиннее, но полезна, если вы интересуетесь только несколькими ядрами.

Например, если вы интересуетесь только ядром 3 и 7, вы можете сделать

dstat -C 3,7

Ответ 6

htop дает хороший обзор использования отдельного ядра

Ответ 7

У меня была именно эта проблема, и я нашел аналогичный ответ здесь.

Метод состоит в том, чтобы установить top так, как вы хотите, а затем нажмите W (капитал W). Это сохраняет текущий макет top в файле конфигурации в $HOME/.toprc

Хотя это может не сработать, если вы хотите запустить несколько top с различными конфигурациями.

Итак, благодаря тому, что я считаю своей работой, вы можете писать в разные конфигурационные файлы/использовать разные файлы конфигурации, выполняя одно из следующих действий:

1) Переименуйте двоичный файл

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

Теперь .top2rc будет записано в ваш $HOME

2) Установите $HOME на какой-то альтернативный путь, так как он напишет свой файл конфигурации в файл $HOME/.binary-name.rc

HOME=./
top

Теперь .toprc будет записана в текущую папку.

С помощью комментариев других людей, чтобы добавить различные учетные записи использования в верхней части, вы можете создать пакетный вывод для этой информации, а последний объединяет информацию через script. Возможно, это не так просто, как вы script, но я нашел вершину, чтобы предоставить мне ВСЕ процессы, чтобы позже я мог повторять и фиксировать состояние в течение длительного времени, которое я мог бы пропустить иначе (необъяснимое внезапное использование ЦП из-за блуждающих процессов)

Ответ 8

Я думал, что perf stat - это то, что вам нужно.

Показывает конкретное использование процесса, когда вы указываете опцию --cpu=list. Ниже приведен пример мониторинга использования процессора для создания проекта с помощью команды perf stat --cpu=0-7 --no-aggr -- make all -j. Выход:

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%)

Левый столбец - это конкретный индекс ЦП, а самый правый столбец - использование ЦП. Если вы не укажете опцию --no-aggr, результат будет объединен вместе. Опция --pid=pid поможет, если вы хотите контролировать выполняемый процесс.

Попробуйте -a --per-core или -a perf-socket тоже, чтобы представить более секретную информацию.

Подробнее об использовании perf stat можно узнать в этом уроке: статистика персидского процессора, также perf help stat поможет по смыслу варианты.