Salta al contenuto principale

mpstat: guardare l'uso di ogni singola CPU

Inviato da tuxsa il

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.04

Ho 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.13

Qui 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 come 0,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: mpstat dice quale CPU è occupata, non da quale processo. Per il processo si guardano top o ps.
  • 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 taskset per l'esempio).
  • Macchine virtuali: la colonna %steal mostra il tempo che l'hypervisor ha tolto alla macchina; se è alta, il rallentamento non dipende dal tuo sistema.
  • Numeri di CPU sbagliati: -P con una CPU inesistente stampa il testo d'uso senza spiegare l'errore. Il numero delle CPU si trova con nproc.
  • 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: -T e -N nel mio sandbox mostrano un solo nodo e nessuna informazione di core o socket.

Riepilogo

ComandoCosa fa
mpstatMedia delle CPU dall'avvio
mpstat 1Media delle CPU ogni secondo
mpstat -P ALL 1Una riga per ogni CPU, ogni secondo
mpstat -P 0 1 5Solo la CPU 0, 5 misure
mpstat -I SUM 1Totale delle interruzioni al secondo
mpstat -I SCPU -P ALLInterruzioni software per CPU
mpstat -T -P ALLCon core, socket e nodo
mpstat -A 1 1Tutte le statistiche
mpstat -o JSON 1 1Output in JSON
taskset -c 0 COMANDOEsegue un comando solo sulla CPU 0