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 - yesDopo 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 - |__python3Con -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,pidstatmostra 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
pidstate non vedi un processo, può essere semplicemente fermo in quell'intervallo. Usa-p PIDo-p ALL. - Un processo molto breve sfugge: se nasce e muore tra due misure,
pidstatnon lo vede. Nel mio test unddtroppo 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:
pidstatdice chi consuma, non perché. Per capire cosa sta facendo il programma servono strumenti comestraceolsof.
Riepilogo
| Comando | Cosa fa |
|---|---|
pidstat 1 | CPU dei processi attivi, ogni secondo |
pidstat -p PID 1 | Segue un processo preciso |
pidstat -C nginx -l 1 | Processi per nome, con riga di comando |
pidstat -t -p PID 1 | Anche i thread del processo |
pidstat -r 1 | Memoria dei processi |
pidstat -d 1 | I/O su disco dei processi |
pidstat -w 1 | Cambi di contesto |
pidstat -I 1 | %CPU diviso per il numero di CPU |
pidstat -h 1 | Una riga per processo (script) |
pidstat --human -r 1 | Valori in forma leggibile |