Pobrać użycie procesora i pamięci przez pojedynczy proces w systemie Linux?

Chcę uzyskać wykorzystanie procesora i pamięci przez pojedynczy proces w systemie Linux - znam PID. Mam nadzieję, że uda mi się go pobrać co sekundę i zapisać w pliku CSV za pomocą polecenia „obserwuj”. Jakiego polecenia mogę użyć, aby uzyskać te informacje z wiersza poleceń systemu Linux?

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

(Możesz pominąć "cmd", ale może to być pomocne przy debugowaniu).

Zauważ, że daje to średnie użycie procesora przez proces w czasie, gdy był on uruchomiony.

Wariant odpowiedzi kawiarni : top -p <pid>

To automatycznie odświeża użycie procesora, więc jest dobre do monitorowania.

Możesz uzyskać wyniki według nazwy procesu za pomocą

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

-Copcja pozwala na użycie nazwy procesu, nie wiedząc, że to PID.

Użyj pidstat (z sysstat - refer Link ).

np. do monitorowania tych dwóch identyfikatorów procesów (12345 i 11223) co 5 sekund użyj

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

ps polecenie (nie należy używać):

• Użycie procesora jest obecnie wyrażane jako procent czasu spędzonego na działaniu w całym okresie istnienia procesu.

top polecenie (należy użyć):

• Udział zadania w czasie procesora, który upłynął od ostatniej aktualizacji ekranu, wyrażony jako procent całkowitego czasu procesora.

Służy topdo sprawdzania użycia procesora w czasie rzeczywistym (bieżący krótki interwał):

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

będzie wyglądać jak: 78.6

• -b: Tryb wsadowy
• -n 2: Liczba iteracji, użyj, 2ponieważ: Przy pierwszym uruchomieniu nie ma poprzedniej próbki do porównania, więc te początkowe wartości są procentami od rozruchu.
• -d 0.2: Czas opóźnienia (w sekundach, tutaj jest 200 ms)
• -p 6962: Monitor-PIDs
• tail -1: ostatni rząd
• awk '{print $9}': kolumna 9 (numer użycia procesora)

Uruchom program i monitoruj go

Ten formularz jest przydatny, jeśli chcesz łatwo przetestować plik wykonywalny:

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

Teraz po naciśnięciu Ctrl + C zamyka program i zatrzymuje monitorowanie. Przykładowe dane wyjściowe:

CPU  MEM
20.0  1.3
35.0  1.3
40.0  1.3

Powiązane: /unix/554/how-to-monitor-cpu-memory-usage-of-a-single-process

Testowane na Ubuntu 16.04.

Możesz użyć top -bi grepować pid, który chcesz (z -bflagą top działa w trybie wsadowym) lub też użyć -pflagi i określić pid bez używania grep.

Jak skomentowano w powyższej odpowiedzi caf , ps, aw niektórych przypadkach pidstat poda średnią długość procesora pCPU przez cały okres użytkowania. Aby uzyskać dokładniejsze wyniki, użyj top. Jeśli chcesz biec na górze, gdy już możesz biegać:

top -b -n 1 -p <PID>

lub tylko do przetwarzania danych i nagłówka:

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

bez nagłówków:

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

lub na proces

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

Aby uzyskać wykorzystanie pamięci tylko przez twoją aplikację (w przeciwieństwie do współdzielonych bibliotek, których używa, musisz użyć interfejsu smaps Linuksa). Ta odpowiedź dobrze to wyjaśnia .

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

gdzie pierwsza kolumna to PID, druga kolumna użycie procesora, trzecia kolumna użycie pamięci.

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

PID - identyfikator procesu

etime - Trwanie procesu / Czas trwania

% cpu - użycie procesora

% mem - użycie pamięci

cmd - Command

Zastąp nazwę procesu dowolnym procesem, który chcesz śledzić, mysql nginx php-fpm itp ...

Wszystkie odpowiedzi tutaj pokazują tylko procent pamięci dla PID.

Oto przykład, jak uzyskać użycie pamięci rss w KB dla wszystkich procesów Apache, zamień „grep apache” na „grep PID”, jeśli chcesz tylko oglądać określony PID:

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

To drukuje:

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

Z procesorem%:

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

Wynik:

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

Dla tych, którzy przez chwilę walczyli i zastanawiali się, dlaczego wybrana odpowiedź nie działa:

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

Brak PRZESTRZENI między %cpu,a %mem.

To fajna sztuczka do śledzenia jednego lub więcej programów w czasie rzeczywistym, jednocześnie obserwując wyjście innego narzędzia: watch "top -bn1 -p$(pidof foo),$(pidof bar); tool"

Następujące polecenie pobiera średnie użycie procesora i pamięci co 40 sekund dla określonego procesu (pid)

pidstat 40 -ru -p <pid>

Dane wyjściowe dla mojego przypadku (pierwsze dwa wiersze dotyczące wykorzystania procesora, drugie dwa wiersze pamięci):

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

(Jeśli używasz systemu MacOS 10.10, wypróbuj opcję kumulatywną -c top:

top -c a -pid PID

(Ta opcja nie jest dostępna w innych systemach Linux, wypróbowana z Scientific Linux el6 i RHEL6)

Powyższa lista zawiera najważniejsze procesy pochłaniające procesor i pamięć

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

Opierając się na odpowiedzi @ caf, to działa dobrze dla mnie.

Oblicz średnią dla danego PID:

Measure.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"

Stosowanie:

# send PID as argument
sh measure.sh 3282

Wykorzystanie procesora i pamięci przez pojedynczy proces w systemie Linux lub możesz uzyskać 10 najczęściej wykorzystywanych procesów przez procesor, używając poniższego polecenia

ps -aux --sort -pcpu | głowa -n 11