it-swarm.it

Come monitorare l'utilizzo della CPU / memoria di un singolo processo?

Vorrei monitorare l'utilizzo della memoria/CPU di un processo in tempo reale. Simile a top ma mirato a un solo processo, preferibilmente con un grafico cronologico di qualche tipo.

194
Josh K

Su Linux, top in realtà supporta la concentrazione su un singolo processo, anche se naturalmente non ha un grafico cronologico:

top -p PID

Questo è disponibile anche su Mac OS X con una sintassi diversa:

top -pid PID
157
Michael Mrozek

psrecord

I seguenti indirizzi grafico cronologico di qualche tipo . Python psrecord il pacchetto fa esattamente questo.

pip install psrecord                             # local user install
Sudo apt-get install python-matplotlib python-tk # for plotting; or via pip

Per singolo processo è il seguente (interrotto da Ctrl+C):

psrecord $(pgrep proc-name1) --interval 1 --plot plot1.png

Per diversi processi il seguente script è utile per sincronizzare i grafici:

#!/bin/bash    
psrecord $(pgrep proc-name1) --interval 1 --duration 60 --plot plot1.png &
P1=$!
psrecord $(pgrep proc-name2) --interval 1 --duration 60 --plot plot2.png &
P2=$!
wait $P1 $P2
echo 'Done'

I grafici sembrano: psrecord example

memory_profiler

pacchetto fornisce il campionamento solo RSS (oltre ad alcune opzioni specifiche di Python). Può anche registrare il processo con i suoi processi figlio (vedi mprof --help).

pip install memory_profiler
mprof run /path/to/executable
mprof plot

Per impostazione predefinita, viene visualizzata una finestra basata su Tkinter (python-tk potrebbe essere necessario) Chart Explorer che può essere esportato:

mprof

stack di grafite e statsd

Può sembrare eccessivo per un semplice test una tantum, ma per qualcosa come un debug di diversi giorni è, sicuramente, ragionevole. Un pratico all-in-one raintank/graphite-stack (dagli autori di Grafana) immagine e psutil e statsd client. procmon.py fornisce un'implementazione.

$ docker run --rm -p 8080:3000 -p 8125:8125/udp raintank/graphite-stack

Quindi in un altro terminale, dopo aver avviato il processo di destinazione:

$ Sudo apt-get install python-statsd python-psutil # or via pip
$ python procmon.py -s localhost -f chromium -r 'chromium.*'

Quindi aprendo Grafana su http: // localhost: 808 , autenticazione come admin:admin, impostazione dell'origine dati https: // localhost , puoi tracciare un grafico come:

grafana chart

stack di grafite e telegraf

Invece di Python che invia le metriche a Statsd, telegraf (e procstat plug-in di input) può essere usato per inviare le metriche alla grafite direttamente.

La configurazione minima di telegraf è simile a:

[agent]
  interval = "1s"

[[outputs.graphite]]
  servers = ["localhost:2003"]
  prefix = "testprfx"

[[inputs.procstat]]
  pid_file = "/path/to/file/with.pid"

Quindi eseguire la riga telegraf --config minconf.conf. La parte di Grafana è la stessa, tranne i nomi delle metriche.

pidstat

pidstat (parte del pacchetto sysstat) può produrre output che possono essere facilmente analizzati. È utile nel caso in cui siano necessarie metriche aggiuntive dal processo o dai processi, ad es. i 3 gruppi più utili (CPU, memoria e disco) contengono: %usr, %system, %guest, %CPU, minflt/s, majflt/s, VSZ, RSS, %MEM, kB_rd/s, kB_wr/s, kB_ccwr/s. L'ho descritto in na risposta correlata .

87
saaj

htop è un ottimo sostituto di top. Ha ... Colori! Scorciatoie da tastiera semplici! Scorri l'elenco usando i tasti freccia! Uccidi un processo senza uscire e senza prendere nota del PID! Segna più processi e uccidili tutti!

Tra tutte le funzionalità, la manpage dice che puoi premere F per seguire un processo.

Davvero, dovresti provare htop. Non ho mai più avviato top, dopo la prima volta che ho usato htop.

Visualizza un singolo processo:

htop -p PID

67

Per usare queste informazioni su uno script puoi fare questo:

calcPercCpu.sh

#!/bin/bash
nPid=$1;
nTimes=10; # customize it
delay=0.1; # customize it
strCalc=`top -d $delay -b -n $nTimes -p $nPid \
  |grep $nPid \
  |sed -r -e "s;\s\s*; ;g" -e "s;^ *;;" \
  |cut -d' ' -f9 \
  |tr '\n' '+' \
  |sed -r -e "s;(.*)[+]$;\1;" -e "s/.*/scale=2;(&)\/$nTimes/"`;
nPercCpu=`echo "$strCalc" |bc -l`
echo $nPercCpu

usa come: calcPercCpu.sh 1234 dove 1234 è il pid

Per $ nPid specificato, misurerà media di 10 istantanee dell'uso della cpu in un intero 1 secondo (ritardo di 0,1 secondi ciascuno * nTime = 10); che fornisce un risultato accurato e rapido di ciò che sta accadendo nel momento stesso.

Modifica le variabili in base alle tue esigenze.

8
Aquarius Power

Normalmente ne uso due seguenti:

  1. HP caliper : il suo ottimo strumento per il monitoraggio dei processi è possibile controllare anche il grafico delle chiamate e altre informazioni di basso livello. Si prega di notare che è gratuito solo per uso personale.

  2. daemontools : una raccolta di strumenti per la gestione dei servizi UNIX

5
Hemant

Utilizzando top e awk si potrebbe facilmente creare ad es. un registro separato da virgola di% CPU ($9) +% MEM ($10) utilizzo che può essere successivamente inserito in qualsiasi strumento di statistica e rappresentazione grafica.

top -b -d $delay -p $pid | awk -v OFS="," '$1+0>0 {
print strftime("%Y-%m-%d %H:%M:%S"),$1,$NF,$9,$10; fflush() }'

L'output sarà simile

2019-03-26 17:43:47,2991,firefox,13.0,5.2
2019-03-26 17:43:48,2991,firefox,4.0,5.2
2019-03-26 17:43:49,2991,firefox,64.0,5.3
2019-03-26 17:43:50,2991,firefox,71.3,5.4
2019-03-26 17:43:51,2991,firefox,67.0,5.4

Questo non darà buoni risultati per grandi $delay, tuttavia, poiché il timestamp stampato è in realtà $delay dietro a causa del funzionamento dell'output di top. Senza entrare troppo nei dettagli, 1 semplice modo per aggirare questo è registrare il tempo fornito da top:

top -b -d $delay -p $pid | awk -v OFS="," '$1=="top"{ time=$3 }
$1+0>0 { print time,$1,$NF,$9,$10; fflush() }'

Quindi il timestamp è preciso, ma l'output sarà comunque ritardato di $delay.

5
xebeche

Se conosci il nome del processo che puoi utilizzare

top -p $(pidof <process_name>)
2
user4757345

Sono un po 'in ritardo qui ma condividerò il mio trucco da riga di comando usando solo il valore predefinito ps

WATCHED_PID=$({ command_to_profile >log.stdout 2>log.stderr & } && echo $!);
while ps -p $WATCHED_PID --no-headers --format "etime pid %cpu %mem rss"; do 
   sleep 1 
done

Lo uso come una linea. Qui la prima riga attiva il comando e memorizza il PID nella variabile. Quindi ps stamperà il tempo trascorso, il PID la percentuale di CPU utilizzata, la percentuale di memoria e la memoria RSS. Puoi aggiungere anche altri campi.

Non appena il processo termina, il comando ps non restituirà "successo" e il ciclo while terminerà.

È possibile ignorare la prima riga se il PID che si desidera profilare è già in esecuzione. Posiziona semplicemente l'id desiderato nella variabile.

Otterrai un output come questo:

  00:00  7805  0.0  0.0  2784
  00:01  7805 99.0  0.8 63876
  00:02  7805 99.5  1.3 104532
  00:03  7805  100  1.6 129876
  00:04  7805  100  2.1 170796
  00:05  7805  100  2.9 234984
  00:06  7805  100  3.7 297552
  00:07  7805  100  4.0 319464
  00:08  7805  100  4.2 337680
  00:09  7805  100  4.5 358800
  00:10  7805  100  4.7 371736
  ....
2
theist

Non abbastanza reputazione per commentare, ma per psrecord puoi anche chiamarlo direttamente, in modo programmatico, direttamente in Python:

from psrecord.main import monitor
monitor(<pid number>, logfile = "./test.log", plot="./fig.png", include_children=True)
2
ZettaCircl

Se si dispone di una distribuzione Linux ridotta in cui top non ha un'opzione per processo (-p) o opzioni correlate, è possibile analizzare l'output del comando top per il nome del processo per ottenere le informazioni sull'utilizzo della CPU per processo.

while true;  do top -bn1 | awk '/your_process_name/ {print  $8}' ; sleep 1; done

8 rappresenta l'utilizzo della CPU per processo nell'output del comando principale nella mia distribuzione Linux incorporata

1
Razan Paul
pidstat -p 7994 2 

03:54:43 PM   UID       PID    %usr %system  %guest    %CPU   CPU  Command
03:54:45 PM     0      7994    1.50    1.50    0.00    3.00     1  AliYunDun
03:54:47 PM     0      7994    1.00    1.00    0.00    2.00     0  AliYunDun

processo di stampa ogni 2 secondi utilizzo di 7994 cpu

0
赵宝磊

Se hai bisogno delle medie per un periodo di tempo di un processo specifico, prova l'opzione cumulativa -c di top:

top -c a -pid PID

"-c a" trovato in cima per Mac 10.8.5.

Per Scientific Linux, l'opzione è -S, che può essere impostata in modo interattivo.

0
Kieleth