Misura delle prestazioni - tempo di calcolo e indici MIPS

In questa pagina 6

Un processore è veloce se esegue in poco tempo un dato programma. In un µC o in un DSP, dove di solito non c'è un sistema operativo che divide il tempo tra più processi, il tempo che il processore dedica al programma coincide con il suo tempo di calcolo. È il parametro decisivo nelle applicazioni di signal processing e di controllo real time (Microcontrollori e DSP - definizioni e scelta del dispositivo).

Stima del tempo di calcolo

Servono tre dati:

il periodo di clock $T_{clk}$ (letto nel datasheet);
il numero medio di cicli $NC_i$ richiesto dalle istruzioni di ciascuna classe $i$ (anche questo nel datasheet o nel manuale);
il numero di istruzioni $N_i$ di ciascuna classe che il programma contiene.

Allora $T_{cal}=T_{clk}\sum_{i=1}^{N_{cl}}N_i\cdot NC_i .$ La formula trascura le interruzioni del programma e i ritardi di accesso alla memoria. Il numero di istruzioni dipende dall'architettura; il periodo di clock e i cicli per istruzione dipendono dall'organizzazione. Una stessa architettura può avere organizzazioni molto diverse.

Tre modi di andare più veloci, con i rispettivi limiti:

ridurre $T_{clk}$ : aumenta la potenza dissipata, che si limita abbassando la tensione di alimentazione (per questo si va verso processori sotto 1 V); il limite è tecnologico;
ridurre $NC_i$ : serve un'organizzazione più complessa (controllo cablato anziché microprogrammato, parallelismo, pipeline), quindi un chip più costoso; il limite è economico;
ridurre $N_i$ : si usano architetture con istruzioni più potenti (CISC invece di RISC), che complicano di nuovo l'organizzazione.

Le prestazioni dipendono quindi da architettura e organizzazione insieme, sotto i vincoli di costo e di consumo (Architettura del repertorio di istruzioni - RISC, CISC, VLIW e indirizzamento).

Indici di prestazione e perché ingannano

MIPS (Million Instructions Per Second): è il valore di picco di istruzioni eseguibili nell'unità di tempo. Ma il lavoro svolto da una istruzione cambia da CPU a CPU e dipende dal compilatore, quindi l'indice confronta al più dispositivi con la stessa architettura.
DMIPS: MIPS misurati su un programma di prova specifico, il benchmark Dhrystone (del 1984), talvolta normalizzati alla frequenza di clock (DMIPS/MHz). Significatività bassa.
FLOPS: operazioni a virgola mobile al secondo (valore di picco); ha senso solo per processori con aritmetica a virgola mobile.

Nessuno considera aspetti essenziali come la velocità degli accessi in memoria. Si usa allora il benchmarking: si misura il tempo su programmi campione. Per i processori generici si usano applicazioni complete (metodo SPEC), ma per i DSP questo valuterebbe l'insieme compilatore-processore: si fa kernel benchmarking, cioè si misurano algoritmi tipici del signal processing (FFT, filtri FIR e IIR). Un buon benchmark per DSP deve essere rilevante per le applicazioni, definibile in modo univoco, semplice e rapidamente ottimizzabile. Per i processori ARM il benchmark CoreMark (ricerca e ordinamento, matrici, stringhe, CRC) sta sostituendo Dhrystone.

Esempio 1: MIPS contro tempo di calcolo

Un processore ha tre classi di istruzioni con $NC=1,2,3$ cicli. Due compilatori producono due codici con (in centinaia) $N=(5,1,1)$ e $N=(10,1,1)$ istruzioni per classe.

$T_{cal,1}=T_{clk}\cdot100\cdot(5\cdot1+1\cdot2+1\cdot3)=1000\,T_{clk}$ .
$T_{cal,2}=T_{clk}\cdot100\cdot(10\cdot1+1\cdot2+1\cdot3)=1500\,T_{clk}$ .

Il secondo codice è il 50% più lento. Ma i MIPS sono $\frac{700}{1000\,T_{clk}}=0{,}7\,F_{clk}$ per il primo e $\frac{1200}{1500\,T_{clk}}=0{,}8\,F_{clk}$ per il secondo: l'indice dice che il secondo è "più veloce". Conclusione: a parità di processore l'indice MIPS può premiare il codice peggiore.

Esempio 2: due datasheet

Un costruttore dichiara 30 MIPS con $F_{clk}=40$ MHz (circa 0,75 istruzioni per periodo, quindi un'istruzione per ciclo con qualche perdita). Un altro dichiara 8000 MIPS ma con $F_{clk}=1000$ MHz: sono "MIPS di picco" ottenuti con più unità in parallelo. Un terzo usa i DMIPS/MHz. I tre numeri non si possono mettere in fila.

Esempio 3: numeri

Con $F_{clk}=25$ MHz ( $T_{clk}=40$ ns) e un mix 60% istruzioni da 1 ciclo, 30% da 2 cicli, 10% da 3 cicli, i cicli medi sono $0{,}6+0{,}6+0{,}3=1{,}5$ . Un programma di $10^6$ istruzioni dura $10^6\cdot1{,}5\cdot40$ ns $=60$ ms.

Errori comuni

Confrontare due processori di famiglie diverse dai MIPS del datasheet.
Dimenticare che $T_{cal}$ vale solo se il programma non viene interrotto e se la memoria è abbastanza veloce.
Ridurre il numero di istruzioni senza considerare che le istruzioni "più potenti" richiedono più cicli.

Versione ripasso

Tempo di calcolo: $T_{cal}=T_{clk}\sum N_i\,NC_i$ (classi di istruzioni, cicli medi per classe).
Tre leve: $T_{clk}$ (potenza dissipata, tecnologia), $NC$ (organizzazione, costo), $N$ (architettura RISC/CISC).
MIPS, DMIPS, FLOPS: valori di picco, non confrontabili tra famiglie; un codice più lento può avere MIPS maggiori (esempio 1000 contro 1500 $T_{clk}$ , MIPS $0{,}7F_{clk}$ contro $0{,}8F_{clk}$ ).
Benchmarking: SPEC per i processori generici; kernel benchmarking (FFT, FIR, IIR) per i DSP; CoreMark sostituisce Dhrystone.
Errori: confrontare famiglie diverse, ignorare memoria e interruzioni, confondere architettura e organizzazione (Microcontrollori e DSP - definizioni e scelta del dispositivo).