Salta al contenuto principale

pidstat: vedere quanto consuma ciascun processo

Inviato da tuxsa il

Con vmstat abbiamo scoperto che il sistema è saturo, con iostat quale disco soffre, con mpstat quale CPU è occupata. Resta l'ultima domanda, la più concreta: quale programma è responsabile? Per rispondere si può usare top, ma se serve una misura precisa, scriptabile e registrabile, lo strumento giusto è pidstat.

Cos'è

pidstat fa parte del pacchetto sysstat, lo stesso di iostat, mpstat e sar; si installa con sudo apt install sysstat su Debian e Ubuntu (vedi apt). Mentre gli altri strumenti guardano il sistema nel suo insieme, pidstat lavora processo per processo, e anche thread per thread, leggendo i contatori che il kernel tiene in /proc/PID/.

Cosa fa

A intervalli regolari mostra, per ogni processo, l'uso della CPU, della memoria, del disco o i cambi di contesto, a seconda dell'opzione. Di default elenca solo i processi che hanno avuto attività nell'intervallo, quindi l'output è breve e va subito al punto; con -p si può seguire un processo specifico anche se sta fermo.

Come si usa

$ pidstat [opzioni] [INTERVALLO [CONTEGGIO]]

Gli esempi vengono da una macchina virtuale con 2 CPU (sysstat 12.6.1): per ottenere carichi controllati ho lanciato io i processi (un ciclo infinito, yes, un programma Python, un dd che scrive). I numeri dei PID sono quelli del mio test e i tuoi saranno diversi. Ho tolto la riga con il kernel e il nome del computer e, dove indicato, ho tagliato le colonne a destra; i titoli sono in inglese.

Esempio 1: chi usa la CPU

$ sh -c 'while :; do :; done' &
$ yes > /dev/null &
$ pidstat 1 1
Average:      UID       PID    %usr %system  %guest   %wait    %CPU   CPU  Command
Average:        0       359  100.00    0.00    0.00    0.00  100.00     -  sh
Average:        0       360   45.00   55.00    0.00    0.00  100.00     -  yes

Dopo aver lanciato due processi che consumano CPU, pidstat 1 1 misura per un secondo e mostra solo i processi attivi: qui il ciclo della shell (sh) e yes, entrambi al 100% di una CPU. Le colonne: %usr tempo in modalità utente, %system tempo nel kernel (yes ne passa molto, perché scrive di continuo su /dev/null), %guest tempo in una macchina virtuale ospitata, %wait tempo passato in attesa di una CPU libera, %CPU il totale, CPU il processore su cui girava. Ho riportato le sole righe Average; sul terminale vedi prima la misura con l'ora. Il valore %CPU è riferito a una singola CPU: un processo con più thread può superare il 100% (non l'ho potuto verificare); con -I il valore viene diviso per il numero delle CPU (nel mio test un ciclo al 100% è passato a 50% su 2 CPU).

Esempio 2: seguire un processo, filtrare per nome

$ pidstat -p 370 1 1
Average:      UID       PID    %usr %system  %guest   %wait    %CPU   CPU  Command
Average:        0       370   98.00    0.00    0.00    0.00   98.00     -  sh
$ pidstat -C yes 1 1
$ pidstat -l -p 434 1 1 | tr -s ' ' | tail -1
Average: 0 434 99.00 0.00 0.00 0.00 99.00 - sh -c while :; do :; done

-p PID segue un processo preciso (anche più d'uno, separati da virgole; -p SELF è pidstat stesso, -p ALL tutti, compresi quelli inattivi). -C TESTO sceglie i processi il cui nome contiene il testo; -l mostra la riga di comando completa al posto del solo nome (sh -c while :; do :; done invece di sh), utile per distinguere due interpreti Python o due java; anche qui ho compresso gli spazi con tr -s ' '. L'output del secondo comando (-C yes) non lo riporto per intero: ha la stessa forma del primo. Se il PID non esiste, pidstat -p 999999 stampa solo l'intestazione e termina con codice 0, senza errore.

Esempio 3: i thread di un processo

$ pidstat -t -p 423 1 1 | tr -s ' '
05:58:00 UID TGID TID %usr %system %guest %wait %CPU CPU Command
Average: 0 423 - 98.00 0.00 0.00 0.00 98.00 - python3
Average: 0 - 423 0.00 0.00 0.00 0.00 0.00 - |__python3
Average: 0 - 425 48.00 0.00 0.00 0.00 48.00 - |__python3
Average: 0 - 426 50.00 0.00 0.00 0.00 50.00 - |__python3

Con -t ogni processo (identificato da TGID) è seguito dai suoi thread (TID, con il segno |__ davanti al nome). Il programma di prova, in Python, avvia due thread che girano di continuo: insieme fanno il 98%, circa il 49% a testa (nella riga del processo e nei thread; ho compresso gli spazi con tr -s ' ' per accorciare le righe). Il motivo è il blocco globale dell'interprete Python (il GIL): due thread Python non girano mai davvero in parallelo. È un esempio di cosa -t fa scoprire: si vede quale thread consuma, non solo il processo.

Esempio 4: la memoria

$ pidstat -r -p 172 1 1
05:55:07      UID       PID  minflt/s  majflt/s     VSZ     RSS   %MEM  Command
Average:        0       172      0.00      0.00  547540  522636   6.36  python3
$ pidstat --human -r -p 266 1 1 | tail -1
Average:        0       266      0.00      0.00   34.7M   10.3M   0.1%  python3

-r mostra l'uso della memoria: minflt/s e majflt/s sono i "page fault" minori e maggiori al secondo (i maggiori obbligano a leggere dal disco), VSZ la memoria virtuale riservata, RSS quella realmente occupata in RAM (entrambe in KiB), %MEM la percentuale sulla RAM totale. Il primo processo è un programma Python che ha riempito 500 MiB: l'RSS è circa 510 MiB (il 6,36% degli 8 GB della macchina). Il secondo è un altro programma Python a riposo; con --human i valori compaiono in forma leggibile (34.7M, 10.3M). Come per tutti gli esempi di questo articolo, PID e valori vengono da esecuzioni distinte.

Esempio 5: il disco

$ pidstat -d -p 235 1 1
05:55:36      UID       PID   kB_rd/s   kB_wr/s kB_ccwr/s iodelay  Command
Average:        0       235      0.00 964640.00      0.00       0  dd

-d mostra quanto ogni processo legge (kB_rd/s) e scrive (kB_wr/s) sul disco, più i kilobyte di scritture "annullate" (kB_ccwr/s, per esempio se un file viene cancellato prima di essere scritto) e il ritardo di I/O (iodelay, in tick). Il dd di prova scriveva a circa 940 MiB/s con oflag=direct. Senza -p, pidstat -d elenca tutti i processi che hanno fatto I/O: è il passo successivo a iostat, che aveva indicato il disco sotto stress. Se la riga non compare, il processo ha finito prima dell'intervallo: nel mio sandbox un dd da 800 MB terminava in meno di un secondo. Non l'ho verificato su disco fisico.

Esempio 6: cambi di contesto

$ pidstat -w -p 193 1 1
05:55:11      UID       PID   cswch/s nvcswch/s  Command
Average:        0       193    901.00      0.00  python3

-w conta i cambi di contesto al secondo: cswch/s sono quelli volontari (il processo cede la CPU perché aspetta qualcosa), nvcswch/s quelli involontari (il kernel gliela toglie perché c'è altro da eseguire). Il programma di prova faceva mille piccole pause al secondo: circa 900 cambi volontari e nessuno involontario. Tanti cambi involontari indicano invece processi che si contendono la CPU (insieme a un valore %wait alto nell'esempio 1).

Esempio 7: altre viste

$ pidstat -h -p 265 1 1
# Time        UID       PID    %usr %system  %guest   %wait    %CPU   CPU  Command
05:55:59        0       265   99.00    0.00    0.00    0.00   99.00     0  sh
$ pidstat -s -p 266 1 1 | sed -n 3p
05:56:00      UID       PID StkSize  StkRef  Command
$ pidstat -R -p 266 1 1 | sed -n 3p
05:56:01      UID       PID prio policy  Command
$ pidstat -v -p 266 1 1 | sed -n 3p
05:56:02      UID       PID threads   fd-nr  Command
$ pidstat -T CHILD -p 265 1 1 | sed -n 3p
05:56:07      UID       PID    usr-ms system-ms  guest-ms  Command

-h stampa tutto su una riga per processo, con un'unica intestazione che inizia con #: è il formato più comodo per awk e per i log. -s mostra le dimensioni dello stack (StkSize e StkRef, nel mio test 152 e 72 KiB per un processo Python), -R la priorità e il criterio di scheduling (0 NORMAL per un processo comune), -v il numero di thread e di file aperti (threads 1 e fd-nr 3). -T CHILD riporta il tempo di CPU consumato dai processi figli già terminati, in millisecondi. Per ognuna delle ultime quattro opzioni ho riportato solo l'intestazione, e i valori citati nel testo vengono dallo stesso test.

Esempio 8: uso negli script

#!/bin/bash
N="${1:-3}"
out=$(LC_ALL=C pidstat -u 1 3 | awk '
    /^Average:/ && $3 ~ /^[0-9]+$/ { printf "%s %s %s\n", $(NF-2), $3, $NF }' |
    sort -rn | head -n "$N")
[ -n "$out" ] || { echo "nessun processo attivo" >&2; exit 1; }
echo "$out" | awk '{ printf "%6.1f%%  pid %-6s %s\n", $1, $2, $3 }'

Lo script misura per tre secondi e stampa i primi N processi per uso di CPU (3 per default): estrae dalle righe Average la colonna %CPU (la terzultima), il PID e il nome, ordina in senso decrescente con sort -rn e riformatta. Con un ciclo della shell e yes in esecuzione ha stampato 98.7% pid 317 yes e 97.7% pid 316 sh; con N uguale a 1, solo sh (99,0%). Se pidstat non produce righe (l'ho simulato con un finto pidstat vuoto) stampa "nessun processo attivo" ed esce con codice 1. LC_ALL=C serve a evitare l'orario con AM/PM in alcune lingue, che sposta le colonne. Il nome dei processi senza -l è il nome breve: un nome con spazi può spezzarsi.

Opzioni utili

  • INTERVALLO [CONTEGGIO]: secondi tra le misure e numero di misure. Senza intervallo, pidstat mostra le medie dall'avvio.
  • -u: CPU (predefinito). -r: memoria. -d: disco. -w: cambi di contesto. -s: stack. -v: thread e file aperti. -R: priorità.
  • -p PID|SELF|ALL: sceglie i processi. -C TESTO: per nome. -U UTENTE: per utente. -G TESTO: per nome, con espressione regolare.
  • -t: mostra anche i thread. -l: riga di comando completa. -I: %CPU diviso per il numero di CPU.
  • -h: una riga per processo, adatta agli script. --human: valori leggibili (K, M, G).
  • -T CHILD: tempo dei processi figli terminati. -V: versione.

Attenzione a

  • Mostra solo i processi attivi: se lanci pidstat e non vedi un processo, può essere semplicemente fermo in quell'intervallo. Usa -p PID o -p ALL.
  • Un processo molto breve sfugge: se nasce e muore tra due misure, pidstat non lo vede. Nel mio test un dd troppo veloce non è comparso; per i processi effimeri servono altri strumenti.
  • %CPU e numero di CPU: il 100% significa "una CPU intera". Per confrontare più macchine usa -I.
  • Il primo risultato senza intervallo è la media dall'avvio: per l'attività attuale serve un intervallo (pidstat 1).
  • Permessi: per vedere il disco e i dettagli di processi di altri utenti possono servire privilegi di root; il mio sandbox è root, quindi non l'ho verificato.
  • Container e macchine virtuali: nei container si vedono i processi del proprio spazio dei nomi, i PID possono differire da quelli dell'host. Nelle macchine virtuali i dati di disco e rete riflettono ciò che vede il sistema ospite.
  • Lingua e formato dell'ora: in alcune lingue l'orario ha AM/PM e le colonne si spostano; negli script usa LC_ALL=C.
  • Il processo giusto, non la causa: pidstat dice chi consuma, non perché. Per capire cosa sta facendo il programma servono strumenti come strace o lsof.

Riepilogo

ComandoCosa fa
pidstat 1CPU dei processi attivi, ogni secondo
pidstat -p PID 1Segue un processo preciso
pidstat -C nginx -l 1Processi per nome, con riga di comando
pidstat -t -p PID 1Anche i thread del processo
pidstat -r 1Memoria dei processi
pidstat -d 1I/O su disco dei processi
pidstat -w 1Cambi di contesto
pidstat -I 1%CPU diviso per il numero di CPU
pidstat -h 1Una riga per processo (script)
pidstat --human -r 1Valori in forma leggibile