Jak zmierzyć użycie oddzielnego rdzenia procesora w procesie?

Czy istnieje sposób na zmierzenie użycia procesora przez rdzenie w określonym procesie?

Wiem, że top jest dobry do pomiaru zużycia procesora przez cały system przez rdzenie, a zestaw zadań może dostarczyć informacji o tym, na którym rdzeniu procesora może działać proces.

Ale jak zmierzyć zużycie procesora przez poszczególne rdzenie procesora?

Nadal możesz to zrobić na górze . Gdy top jest uruchomiony, naciśnij „1” na klawiaturze, a następnie pokaże użycie procesora na rdzeń.

Ogranicz pokazywane procesy, uruchamiając ten konkretny proces na określonym koncie użytkownika i użyj typu „u”, aby ograniczyć się do tego użytkownika

Możesz użyć:

 mpstat -P ALL 1

Pokazuje, jak bardzo każdy rdzeń jest zajęty i aktualizuje się automatycznie co sekundę. Wynik wyglądałby mniej więcej tak (na czterordzeniowym procesorze):

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

To polecenie nie odpowiada jednak na pierwotne pytanie, tj. Nie pokazuje użycia rdzenia procesora dla określonego procesu.

możesz użyć ps.
np. posiadanie procesu Pythona z dwoma zajętymi wątkami na dwurdzeniowym procesorze:

$ 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 to identyfikator procesora, do którego wątek jest obecnie przypisany)

widzisz, że wątki działają na tym samym rdzeniu procesora (z powodu GIL)

uruchamiając ten sam skrypt Pythona w jythonie, widzimy, że skrypt wykorzystuje oba rdzenie (i istnieje wiele innych usług lub innych wątków, które są prawie bezczynne):

$ 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

możesz przetworzyć dane wyjściowe i obliczyć całkowity procesor dla każdego rdzenia procesora.

Niestety to podejście nie wydaje się być w 100% niezawodne, czasami widzę, że w pierwszym przypadku dwa wątki robocze są zgłaszane jako oddzielne dla każdego rdzenia procesora lub w drugim przypadku są zgłaszane, że dwa wątki są włączone ten sam rdzeń ..

htop daje ładny przegląd wykorzystania poszczególnych rdzeni

psRoztwór prawie co potrzebne iz jakiegoś bash wrzucony jest dokładnie to, co oryginalne pytanie zadawane przez: aby zobaczyć per-rdzeniową wykorzystaniem procesów specyficznych

Pokazuje również użycie na rdzeń procesów wielowątkowych .

Użyj na przykład: 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

Uwaga: te statystyki są oparte na czasie trwania procesu , a nie na ostatnich X sekundach, więc musisz ponownie uruchomić proces, aby zresetować licznik.

dstat -C 0,1,2,3 

Zapewnia również wykorzystanie procesora przez pierwsze 4 rdzenie. Oczywiście, jeśli masz 32 rdzenie, to polecenie będzie trochę dłuższe, ale przydatne, jeśli interesuje Cię tylko kilka rdzeni.

Na przykład, jeśli interesujesz się tylko rdzeniami 3 i 7, możesz to zrobić

dstat -C 3,7

I właśnie ten problem i znalazłem podobną odpowiedź tutaj .

Metoda polega na tym, aby ustawić toptak, jak chcesz, a następnie nacisnąć W(duże W). Zapisuje topto aktualny układ do pliku konfiguracyjnego w $ HOME / .toprc

Chociaż może to nie działać, jeśli chcesz uruchomić wiele topprogramów z różnymi konfiguracjami.

Dzięki temu, co uważam za obejście, możesz pisać do różnych plików konfiguracyjnych / używać różnych plików konfiguracyjnych, wykonując jedną z następujących czynności ...

1) Zmień nazwę pliku binarnego

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

Teraz .top2rczostanie zapisany w Twoim $ HOME

2) Ustaw $ HOME na jakąś alternatywną ścieżkę, ponieważ zapisze swój plik konfiguracyjny do pliku $ HOME / .binary-name.rc

HOME=./
top

Teraz .toprczostanie zapisany w bieżącym folderze.

Korzystając z komentarzy innych osób, aby dodać różne rozliczenia wykorzystania, można utworzyć zbiorcze dane wyjściowe dla tych informacji, a następnie połączyć informacje za pomocą skryptu. Może nie tak proste, jak skrypt, ale znalazłem górę, aby zapewnić mi WSZYSTKIE procesy, aby później móc podsumować i uchwycić stan w dłuższej perspektywie, który mógłbym przegapić w inny sposób (niewyjaśnione nagłe użycie procesora z powodu zbłąkanych procesów)

Pomyślałem, że perf stattego potrzebujesz.

Po określeniu --cpu=listopcji pokazuje określone użycie procesu . Oto przykład monitorowania wykorzystania procesora podczas budowania projektu za pomocą perf stat --cpu=0-7 --no-aggr -- make all -jpolecenia. Wynik to:

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

Lewa kolumna to określony indeks procesora, a skrajna prawa kolumna to użycie procesora. Jeśli nie określisz --no-aggropcji, wynik zostanie zagregowany. Ta --pid=pidopcja pomoże, jeśli chcesz monitorować działający proces.

Spróbuj -a --per-corelub -a perf-socketteż, co przedstawi bardziej tajne informacje.

Więcej o używaniu perf statmożna zobaczyć w tym samouczku: statystyka perf cpu , również perf help statpomoże zrozumieć znaczenie opcji.