Il carico medio dice che il server è occupato, vmstat dice che la CPU è piena, ma c'è un'informazione che entrambi nascondono: com'è distribuito il lavoro tra i processori? Un programma che usa un solo thread può saturare una CPU lasciando le altre quasi ferme, e la media complessiva sembra tranquilla. Per vedere questa differenza si usa mpstat.
Cos'è
mpstat (multiprocessor statistics) fa parte del pacchetto sysstat, lo stesso di iostat e sar. Come loro, su Debian e Ubuntu si installa con sudo apt install sysstat (vedi apt). Rispetto al blocco della CPU di iostat e vmstat offre più dettaglio: il tempo di ogni processore e le interruzioni gestite da ciascuno.
Cosa fa
Legge i contatori del kernel in /proc/stat e, a intervalli regolari, riporta come ogni CPU ha ripartito il proprio tempo tra programmi utente, kernel, attesa del disco, interruzioni, e inattività. Può mostrare la media di tutte le CPU, una CPU specifica o tutte insieme, riga per riga; con -I mostra anche quante interruzioni ha gestito ciascuna.
Come si usa
$ mpstat [opzioni] [INTERVALLO [CONTEGGIO]]Gli esempi vengono da una macchina virtuale con 2 CPU (sysstat 12.6.1). L'output predefinito è largo 110 caratteri: per non rompere il layout del sito, negli esempi che seguono lo filtro con awk e tengo solo le colonne più utili, dove le dico esplicitamente. Ho tolto la riga d'intestazione con il kernel e il nome del computer; i titoli sono in inglese. Per creare carico su una CPU precisa ho usato taskset (vedi sotto).
Esempio 1: la media di tutte le CPU
$ mpstat 1 2
09:38:04 CPU %usr %nice %sys %iowait %irq %soft %steal ...
09:38:05 all 0.00 0.00 0.00 0.00 0.00 0.00 0.00 ...
09:38:06 all 0.00 0.00 0.00 0.00 0.00 0.00 0.00 ...
Average: all 0.00 0.00 0.00 0.00 0.00 0.00 0.00 ...Con 1 2 mpstat misura ogni secondo per due volte e poi stampa la media. Le colonne in più, tagliate a destra, sono %guest, %gnice e %idle (ho scritto i puntini al loro posto). Senza intervallo (mpstat da solo) stampa invece una sola riga con la media dall'avvio, come vmstat. Le colonne sono le stesse di sar -u ALL: %usr programmi utente, %sys kernel, %iowait attesa del disco, %irq e %soft interruzioni hardware e software, %steal tempo rubato dall'hypervisor, %idle inattività.
Esempio 2: una riga per ogni CPU
$ NARROW='/^Average/ {printf "%-9s %-4s %6s %6s %7s %7s\n",
> $1, $2, $3, $5, $6, $NF}'
$ mpstat -P ALL 1 1 | awk "$NARROW"
Average: CPU %usr %sys %iowait %idle
Average: all 0.00 0.00 0.00 100.00
Average: 0 0.00 0.00 0.00 100.00
Average: 1 0.00 0.00 0.00 100.00-P ALL aggiunge una riga per ogni processore, oltre alla media complessiva (all). Il filtro (nella variabile NARROW) tiene soltanto le colonne %usr, %sys, %iowait e %idle e solo la riga Average: sul terminale vedrai l'output intero, largo 110 caratteri. Con -P 0 si guarda una sola CPU, con -P 0,1 un elenco; un numero inesistente (-P 5 su una macchina con 2 CPU) fa stampare il testo d'uso del comando, senza un messaggio d'errore chiaro.
Esempio 3: un programma che satura una sola CPU
$ taskset -c 0 sh -c 'while :; do :; done' &
$ mpstat -P ALL 1 1 | awk "$NARROW"
Average: CPU %usr %sys %iowait %idle
Average: all 49.01 0.50 0.00 49.50
Average: 0 99.00 0.00 0.00 0.00
Average: 1 0.00 0.98 0.00 98.04Ho lanciato un ciclo infinito della shell, vincolato con taskset -c 0 alla CPU 0. La riga all dice che l'uso medio è circa il 50%, e un occhio distratto penserebbe a un sistema a metà carico; le righe per CPU mostrano la verità: la CPU 0 è al 99%, la 1 è ferma. È proprio il caso in cui mpstat -P ALL serve: un programma "single thread" che ha raggiunto il suo limite non è risolvibile aggiungendo CPU. Nel comando, $NARROW è il filtro awk definito nell'esempio 2 (taskset fa parte di util-linux).
Esempio 4: attesa del disco su una sola CPU
$ taskset -c 1 dd if=/dev/zero of=big.bin bs=1M count=800 conv=fsync &
$ mpstat -P ALL 1 1 | awk "$NARROW"
Average: CPU %usr %sys %iowait %idle
Average: all 0.00 11.00 33.00 55.50
Average: 0 0.00 1.98 0.00 97.03
Average: 1 0.00 20.20 66.67 13.13Qui ho vincolato alla CPU 1 una scrittura di 800 MiB con dd e conv=fsync. La media (all) mostra un %iowait del 33%, mentre la CPU 1 passa il 67% del tempo ad aspettare il disco. Sulle macchine reali un processo di solito non resta fissato a una CPU, ma questa vista aiuta a capire se l'attesa è concentrata su una o su tutte. %iowait è un valore "per CPU": indica il tempo in cui quella CPU era inattiva perché aveva richieste di I/O in sospeso. Per sapere quale disco, passa a iostat.
Esempio 5: le interruzioni
$ mpstat -I SUM 1 1
09:38:44 CPU intr/s
09:38:45 all 61.00
$ mpstat -I CPU 1 1
09:39:12 CPU 24/s 25/s 26/s 28/s 29/s ...
$ mpstat -I SCPU 1 1
09:39:13 CPU HI/s TIMER/s NET_TX/s NET_RX/s BLOCK/s ...Con -I SUM si ottiene il totale di interruzioni al secondo (qui 61 su tutto il sistema); -I CPU le divide per sorgente hardware (le colonne sono i numeri delle linee di interruzione, gli stessi di /proc/interrupts) e per CPU; -I SCPU mostra le interruzioni software (TIMER, NET_RX, BLOCK...). -I ALL le stampa tutte insieme in un output molto lungo (17 righe nel mio test di una sola misura). Un valore anomalo, per esempio tutte le interruzioni di rete (NET_RX/s) su una sola CPU, è il segnale di una scheda di rete che andrebbe distribuita meglio. Nelle righe qui sopra ho tagliato a destra le colonne meno interessanti.
Esempio 6: altre viste (-T, -N, JSON, decimali)
$ mpstat -T -P ALL 1 1 | sed -n 3,4p | cut -c1-48
09:40:12 CPU CORE SOCK NODE %usr %nice
09:40:13 all 0.00 0.00
$ mpstat -N ALL 1 1 | sed -n 3,4p | cut -c1-48
09:40:13 NODE %usr %nice %sys %iowait
09:40:14 all 0.50 0.00 0.00 0.00
$ mpstat --dec=0 1 1 | tail -1 | cut -c1-48
Average: all 0 0 0 0
$ mpstat -o JSON -P 0 1 1 | grep '"cpu"' | cut -c7-60
{"cpu": "0", "usr": 0.00, "nice": 0.00, "sys": 0.00, "-T aggiunge, per ogni CPU, a quale core, socket e nodo NUMA appartiene (nel mio sandbox, senza topologia, quelle colonne restano vuote); -N raggruppa i valori per nodo NUMA; --dec=N sceglie quanti decimali mostrare (da 0 a 2); -o JSON produce l'output in formato JSON, che ho accorciato qui sopra a una sola voce. -A equivale a -I ALL -u -P ALL e stampa tutto: nel mio test 35 righe per una sola misura su 2 CPU.
Esempio 7: uso negli script
#!/bin/bash
SOGLIA="${1:-90}"
LC_ALL=C mpstat -P ALL 1 3 | awk -v s="$SOGLIA" '
/%idle/ { for (i = 1; i <= NF; i++) if ($i == "%idle") c = i }
/^Average:/ && $2 ~ /^[0-9]+$/ {
occ = 100 - $c
n++
printf "CPU %s: %.1f%% occupata\n", $2, occ
if (occ >= s) alta = 1
}
END { if (n == 0) exit 2; exit alta }'Lo script misura per tre secondi e, per ogni CPU, calcola l'occupazione come 100 meno %idle (la colonna è trovata per nome, non per posizione). Se almeno una CPU raggiunge la soglia (90 per default) termina con codice 1. Il filtro $2 ~ /^[0-9]+$/ scarta la riga all e tiene solo le CPU numerate; se mpstat non produce nulla, il codice è 2. A riposo ha stampato CPU 0: 0.0% occupata e CPU 1: 0.3% occupata (codice 0); con un ciclo infinito su una sola CPU, CPU 0: 100.0% occupata e CPU 1: 1.0% occupata (codice 1), mentre la media complessiva sarebbe stata circa 50% e non avrebbe fatto scattare un controllo normale. Con un finto mpstat che non stampa nulla ha risposto con codice 2. LC_ALL=C forza il formato standard: in alcune lingue l'ora è in formato 12 ore e le colonne si spostano.
Opzioni utili
INTERVALLO [CONTEGGIO]: secondi tra le misure e numero di misure (senza intervallo: media dall'avvio).-P CPU|LISTA|ALL|ON: sceglie le CPU (una, un elenco come0,1, tutte, o solo quelle attive).-u: utilizzo della CPU (predefinito).-I SUM|CPU|SCPU|ALL: interruzioni.-T: aggiunge core, socket e nodo.-N NODO|ALL: statistiche per nodo NUMA.-n: riepilogo per nodo NUMA.-A: tutto.--dec=0|1|2: numero di decimali.-o JSON: output in JSON.-V: versione.
Attenzione a
- La media inganna: su una macchina con molte CPU un processo che ne satura una sola pesa pochissimo sulla riga
all(1/16 su 16 CPU, il 6%). Controlla sempre le righe per CPU. - Il primo valore senza intervallo è la media dall'avvio: per l'attività di adesso serve un intervallo (
mpstat 1). - Un singolo processo non va confuso con la macchina:
mpstatdice quale CPU è occupata, non da quale processo. Per il processo si guardanotopops. - Il valore cambia in fretta: lo scheduler sposta i processi tra le CPU. Sulle macchine reali un processo non resta fermo sulla stessa CPU, a meno che non sia vincolato (come ho fatto io con
tasksetper l'esempio). - Macchine virtuali: la colonna
%stealmostra il tempo che l'hypervisor ha tolto alla macchina; se è alta, il rallentamento non dipende dal tuo sistema. - Numeri di CPU sbagliati:
-Pcon una CPU inesistente stampa il testo d'uso senza spiegare l'errore. Il numero delle CPU si trova connproc. - Lingua e formato dell'ora: in alcune lingue l'orario ha AM/PM e le colonne si spostano; negli script usa
LC_ALL=C. - Non l'ho provato su più socket o sistemi NUMA reali:
-Te-Nnel mio sandbox mostrano un solo nodo e nessuna informazione di core o socket.
Riepilogo
| Comando | Cosa fa |
|---|---|
mpstat | Media delle CPU dall'avvio |
mpstat 1 | Media delle CPU ogni secondo |
mpstat -P ALL 1 | Una riga per ogni CPU, ogni secondo |
mpstat -P 0 1 5 | Solo la CPU 0, 5 misure |
mpstat -I SUM 1 | Totale delle interruzioni al secondo |
mpstat -I SCPU -P ALL | Interruzioni software per CPU |
mpstat -T -P ALL | Con core, socket e nodo |
mpstat -A 1 1 | Tutte le statistiche |
mpstat -o JSON 1 1 | Output in JSON |
taskset -c 0 COMANDO | Esegue un comando solo sulla CPU 0 |