Come funziona davvero un computer, dalla ALU alla NPU

Sulla scatola di un computer nuovo ci sono quattro o cinque sigle: CPU, core, GPU, NPU, TOPS. Sembrano nomi di parti diverse messe lì a caso, e invece raccontano una storia sola.

La storia è questa. Ogni volta che un tipo di calcolo è diventato abbastanza importante, qualcuno ha costruito un pezzo di silicio che fa soprattutto quello, e lo fa consumando molto meno. Dalla FPU degli anni Ottanta alla NPU di oggi è sempre lo stesso mestiere. Vediamola dall’inizio, cercando di non dire niente che faccia storcere il naso a chi il mestiere lo fa.

1945: il modello che usiamo ancora

Nel giugno del 1945 circola un documento intitolato First Draft of a Report on the EDVAC, firmato da John von Neumann. Da lì viene il nome “architettura di von Neumann”, anche se è una ingiustizia storica piuttosto nota. Il lavoro era del gruppo della Moore School, e J. Presper Eckert e John Mauchly avevano titoli almeno altrettanto buoni per firmarlo. Von Neumann scriveva bene e il suo nome era sulla copertina.

L’idea, quella sì, è decisiva: una memoria sola, che contiene sia i dati sia le istruzioni, nello stesso formato e indirizzata allo stesso modo. Prima di allora il programma era una configurazione di cavi e interruttori. Da quel momento il programma è un numero come gli altri, e una macchina può caricarne uno diverso senza essere ricostruita.

Il resto del modello sono poche parti, cioè la memoria, l’unità di controllo, l’unità aritmetica, l’ingresso e l’uscita. Il funzionamento, nella descrizione da manuale, è un ciclo che si ripete.

1. Prendi dalla memoria la prossima istruzione (in inglese fetch).
2. Interpreta che cosa chiede di fare (decode).
3. Esegui: fai il conto, oppure sposta un numero, oppure salta a un'altra istruzione (execute).
4. Ricomincia.

Il clock è il battito che tiene d’accordo le varie parti del chip su quando un risultato è stabile e può essere registrato. Tre gigahertz vuol dire tre miliardi di battiti al secondo.

Attenzione però a cosa descrive quel ciclo. Descrive il comportamento che il programma vede, non quello che succede dentro il chip. Un processore moderno di fascia alta non prende un’istruzione, la finisce e passa alla seguente: ne tiene in lavorazione molte insieme, le esegue anche in un ordine diverso da quello scritto, tira a indovinare l’esito dei salti per non restare fermo, e se indovina male butta via il lavoro fatto e ricomincia. Il risultato finale deve essere identico a quello dell’esecuzione ordinata, e questo è il patto. Il percorso per arrivarci, no.

La stessa distinzione serve per un altro luogo comune, quello secondo cui i processori di oggi restano macchine di von Neumann. Cache, esecuzione fuori ordine e percorsi separati per istruzioni e dati dentro il chip riguardano come è costruita la macchina; il contratto con chi programma resta quello del 1945, una memoria sola con dentro dati e istruzioni. Architettura di von Neumann, implementazione che prende in prestito parecchio dal modello concorrente, quello di Harvard. Due piani diversi del discorso.

La ALU, e perché i megahertz non bastano più

La ALU è il banco di lavoro. Somma, sottrae, confronta, fa AND e OR su numeri interi. Prende gli operandi dai registri e ci rimette dentro il risultato. In un core moderno non ce n’è una sola, e accanto a lei vivono altre unità specializzate: moltiplicazione, divisione, virgola mobile, operazioni su gruppi di numeri.

Per vent’anni il modo normale di confrontare due computer è stato guardare il clock. Si diceva “un 486 a 66 megahertz”, poi “un Pentium a 200”, poi si è passati ai gigahertz, e per tutta la fine degli anni Novanta la pubblicità è stata una gara a chi aveva il numero più alto. Per un po’ quel numero funzionava, perché i processori che si confrontavano erano abbastanza simili tra loro: a parità di progetto, più battiti al secondo vuol dire più lavoro fatto.

Poi il criterio si è rotto. E conviene capire perché, perché è lo stesso motivo per cui oggi non bisogna fidarsi dei TOPS.

Il tempo che un programma impiega dipende da tre cose moltiplicate tra loro: quanti battiti al secondo, quanto lavoro passa in media a ogni battito, quante istruzioni servono per fare quel lavoro. Il clock è solo il primo dei tre fattori. Un processore può averne di più e restare più lento, se gli altri due sono peggiori. Successe proprio questo al Pentium 4, che arrivò a 3,8 GHz ed era più lento, su molti programmi, di processori concorrenti che di gigahertz ne facevano due. La catena di montaggio interna era stata allungata proprio per permettere frequenze alte, e ogni volta che una previsione di salto sbagliava si pagava quel tratto in più.

Qui va tolta di mezzo anche l’altra semplificazione classica, “il processore esegue un’istruzione per ogni colpo di clock”, che è imprecisa in due modi opposti.

Primo, una singola istruzione occupa molti battiti. Il lavoro è organizzato come una catena di montaggio divisa in stadi, parecchi nei progetti ad alte prestazioni: mentre una istruzione è in esecuzione, la successiva è già in decodifica e quella dopo ancora è in prelievo. Quindi non è la singola istruzione a durare un battito, è la catena nel suo insieme che a regime riesce a consegnarne una per battito.

Secondo, le catene non sono una sola. I processori ad alte prestazioni sono superscalari, cioè hanno più unità di esecuzione in parallelo e possono avviare più lavoro nello stesso battito. In molte architetture, x86 in testa, l’istruzione scritta nel programma viene prima tradotta in una o più micro-operazioni più semplici, ed è su quelle che la macchina lavora davvero. Quante se ne possano avviare per ciclo dipende dal progetto specifico: è un numero che cambia da architettura ad architettura e da generazione a generazione, ed è uno di quei dati che ha senso solo se citi il chip preciso.

La cosa curiosa è che quella capacità resta quasi sempre inutilizzata. Le misure su codice di uso comune danno medie basse, nell’ordine di una o due istruzioni completate per ciclo, con grandi differenze da programma a programma: un ciclo stretto e ben prevedibile va forte, un programma che salta da una struttura all’altra della memoria va molto peggio. Il motivo principale è uno solo, e tornerà alla fine di questo articolo. Spesso il processore sta fermo ad aspettare che arrivino i dati.

Morale pratica. I gigahertz continuano a contare, ma servono a confrontare due modelli della stessa famiglia, non due chip qualsiasi. Tra un processore recente a 3 GHz e uno di sei anni fa a 3,5 GHz, il recente vince quasi sempre.

La FPU: perché la virgola ha avuto bisogno di un pezzo tutto suo

Sommare due numeri interi è facile. Sommare 1,5 × 10³ e 2,7 × 10⁻² è un’altra storia, perché bisogna confrontare gli esponenti, allineare le cifre, sommare, rinormalizzare il risultato e arrotondarlo. È un percorso più lungo e più costoso dentro il silicio, e per questo i numeri in virgola mobile hanno avuto un reparto dedicato, la FPU.

Per anni fu un chip a parte, da comprare separatamente. L’Intel 8087, uscito nel 1980, si infilava in uno zoccolo vuoto accanto al processore, e nella maggior parte dei computer quello zoccolo restava vuoto. Con il 486DX del 1989 la FPU finì sullo stesso pezzo di silicio del processore, almeno nel mondo dei PC. Il calcolo in virgola mobile in hardware, va detto, esisteva da molto prima: quello che cambia in quegli anni è che arriva sul computer di casa.

Nel frattempo era successa la cosa più importante, cioè lo standard IEEE 754, approvato nel 1985 e oggi alla revisione del 2019. Conviene dire con precisione cosa standardizza, perché viene spesso riassunto male. Definisce i formati con cui i numeri vengono rappresentati, le operazioni e il loro comportamento, le modalità di arrotondamento, i valori speciali (lo zero con segno, gli infiniti, il risultato non numerico chiamato NaN) e la gestione delle eccezioni, per esempio cosa deve succedere in caso di divisione per zero o di overflow. La conseguenza che interessa a chi usa il computer è che operazioni eseguite secondo lo standard danno gli stessi risultati su macchine diverse. Prima del 1985 ogni costruttore faceva di testa sua e lo stesso programma poteva rispondere in modo diverso a seconda di dove girava.

Resta un dettaglio che prima o poi incontri in un foglio di calcolo. I numeri in virgola mobile binaria non possono rappresentare esattamente tutti i decimali. 0,1 in binario non ha una scrittura finita, come 1/3 non ce l’ha in decimale. Per questo in molti linguaggi 0,1 + 0,2 non dà 0,3 ma qualcosa come 0,30000000000000004. Il computer non sta sbagliando: sta pagando il prezzo di rappresentare con un numero finito di bit qualcosa che finito non è. Per la stessa ragione, sommare gli stessi numeri in ordine diverso può dare risultati leggermente diversi, il che ha conseguenze concrete quando il lavoro viene diviso tra molte unità di calcolo.

Una curiosità che merita la digressione. Nel 1994 un matematico scoprì che certe divisioni sui primi Pentium davano un risultato sbagliato a partire dalla quarta cifra decimale, per via di alcune voci mancanti in una tabella interna. Intel finì per sostituire i processori a chiunque li chiedesse e mise a bilancio una svalutazione di circa 475 milioni di dollari. È uno dei motivi per cui oggi le unità aritmetiche vengono verificate con metodi formali, cioè dimostrando matematicamente che si comportano come devono.

SIMD: una istruzione, tanti risultati

Verso la fine degli anni Novanta arriva un problema nuovo: video, audio, immagini. Lavori in cui si deve fare la stessa operazione su moltissimi numeri. Alza la luminosità di ogni pixel, somma un valore a ogni campione sonoro.

Farlo con una istruzione per numero è uno spreco, e il motivo è più profondo di quanto sembri. Una presentazione molto citata di Mark Horowitz dà l’ordine di grandezza, riferito a una tecnologia di quegli anni: su un processore generico l’energia spesa per gestire l’istruzione, cioè prelevarla, decodificarla e far funzionare il contorno, è molto maggiore di quella spesa per fare il conto in sé. Il conto è la parte economica. A costare è l’organizzazione intorno.

La risposta si chiama SIMD, in inglese Single Instruction, Multiple Data: una sola istruzione che opera contemporaneamente su un gruppo di numeri affiancati. Un solo prelievo, una sola decodifica, molti risultati. Sui processori Intel e AMD è la famiglia che va da MMX (1997) a SSE (1999) fino ad AVX (dal 2011) e seguito; sui processori Arm, quelli dei telefoni e dei Mac, la corrispondente si chiama NEON.

Non è gratis, perché funziona se i dati sono tanti, indipendenti e disposti in modo regolare, e rende poco quando ogni elemento richiede una decisione diversa. Ma tienilo a mente, perché questo schema ritorna in tutto il resto dell’articolo: restringi il tipo di lavoro, riduci il contorno, guadagni molto in efficienza.

I core: quando la frequenza ha smesso di salire

Fino ai primi anni Duemila ogni generazione di processori andava più veloce della precedente in frequenza, e bastava aspettare. Poi, intorno al 2004-2006, la salita si è fermata contro un limite fisico, perché più si sale più aumentano consumo e calore da smaltire in pochi millimetri quadrati. Intel abbandonò i progetti che puntavano ai 4 GHz e cambiò strada: invece di un processore più veloce, più processori nello stesso chip. Sui computer di casa i primi doppi core arrivano nel 2005; nei server esistevano già da qualche anno, e macchine con più processori separati da decenni.

Qui ci sono due cose che vengono quasi sempre confuse.

La legge di Moore riguarda il numero di transistor che si riescono a mettere su un chip, e ha continuato, rallentando e diventando molto più costosa. Lo scaling di Dennard è un’altra cosa, e diceva che rimpicciolendo i transistor si poteva abbassare anche la tensione, così il consumo per unità di superficie restava costante e la frequenza saliva quasi gratis. È questa seconda legge che si è rotta, e secondo la ricostruzione di Hennessy e Patterson lo ha fatto gradualmente, soprattutto tra il 2007 e il 2012. Il muro della frequenza è arrivato prima, la fine della legge che lo rendeva gratuito dopo.

E i core servono? Sì, ma non come si crede, perché otto core non fanno un programma otto volte più veloce. Un lavoro accelera nella misura in cui si lascia dividere in parti indipendenti, e quasi ogni programma ha una parte che resta in fila per forza. È per questo che la velocità di un singolo core conta ancora molto.

Oggi un portatile ha in genere fra i sei e i sedici core, e spesso sono di due tipi, alcuni grandi e veloci, altri più piccoli e più efficienti. I piccoli non sono “core lenti per quando il computer non fa niente”: occupano molto meno spazio, quindi a parità di silicio se ne mettono di più, e quando c’è molto lavoro parallelo da macinare contribuiscono in modo serio. Lo svantaggio è che adesso il sistema operativo deve decidere dove mandare ogni programma, e sbagliare quella scelta si sente.

La GPU: migliaia di corsie, nessun solista

La grafica 3D ha una proprietà comoda. Il colore di un pixel si può calcolare in larga parte indipendentemente dagli altri. Sono moltissimi conti simili tra loro, che si possono fare insieme.

Su questa proprietà è nata una macchina fatta apposta. NVIDIA chiamò “GPU” la GeForce 256 nel 1999, ed è il momento in cui il nome entra nel linguaggio comune; la rivendicazione di essere “la prima GPU della storia” è però generosa, perché schede con elaborazione geometrica in hardware esistevano prima, nelle workstation e altrove. Quello che cambia davvero arriva dopo, in due passi. Prima i pezzi fissi del chip diventano programmabili (gli shader, dai primi anni Duemila), poi, a metà del decennio, smettono di essere divisi per compito e diventano un insieme unico di unità generiche assegnabili all’uno o all’altro lavoro. A quel punto, in buona parte per effetto collaterale, la scheda video diventa anche un calcolatore parallelo per scopi generali. Nel 2007 NVIDIA pubblica CUDA e programmarla smette di essere un gioco di prestigio.

Come funziona, in due punti che contano più di qualsiasi conteggio di “cuda core”.

Il primo è che le unità lavorano in gruppi affiatati. I thread sono organizzati in gruppi (32 nelle architetture NVIDIA) che condividono la stessa istruzione nello stesso momento. Se dentro un gruppo metà prende un ramo di un “se” e metà l’altro, la macchina tende a eseguire prima un ramo e poi l’altro, tenendo inattive le corsie che non c’entrano. Ecco perché le GPU rendono meno sul codice pieno di decisioni diverse da elemento a elemento. Non c’entra l’intelligenza della macchina, c’entra che è costruita perché molte corsie facciano la stessa cosa nello stesso momento.

Il secondo riguarda la memoria. Una GPU non prova a ridurre l’attesa, la copre con altro lavoro. Un processore combatte l’attesa con cache grandi e con l’esecuzione fuori ordine. Una GPU invece ne tiene pronte moltissime di squadre di lavoro e, quando una si blocca in attesa di un dato, ne manda avanti un’altra. È una macchina pensata per il flusso complessivo, più che per finire in fretta una singola cosa.

Due conseguenze pratiche. La prima: quando leggi “16.000 core” su una scheda video e “16 core” su un processore, i due numeri non sono paragonabili, perché quello che NVIDIA chiama core è una corsia di calcolo, non un processore completo. La seconda, su un lavoro sequenziale, fatto di passi che dipendono l’uno dall’altro, la GPU parte in forte svantaggio, perché le sue corsie lavorano a frequenze più basse, hanno meno meccanismi per tirare avanti da sole, e in più c’è il costo di avviare il lavoro e di spostare i dati. Non è una legge di natura, è una questione di quale lavoro gli stai dando: cambia il lavoro e cambia il vincitore.

Nel 2012 una rete neurale chiamata AlexNet vince la gara di riconoscimento di immagini più seguita del mondo addestrandosi su due schede video da gioco. Non fu la prima a usare una GPU, ma fu quella che convinse il settore. Nel 2017 NVIDIA aggiunge dentro al chip le unità tensoriali, circuiti che eseguono in un colpo solo una moltiplicazione tra piccole matrici, con ingressi a precisione ridotta e accumulo a precisione piena: sullo stesso chip, sulle operazioni per cui sono fatte, rendono molto di più delle unità generiche. Ancora una volta, restringere il tipo di lavoro e togliere il superfluo paga.

La NPU: non la più veloce, la più parsimoniosa

Semplificando parecchio, e dichiarandolo, il grosso del lavoro di una rete neurale sta in moltiplicazioni di matrici, cioè enormi quantità di “moltiplica e somma”, spesso con numeri a precisione ridotta. Non è tutto quello che fa una rete, ma è la parte che domina il tempo di calcolo, e basta a spiegare l’hardware.

Una NPU è un acceleratore progettato per eseguire in modo molto efficiente proprio quel tipo di calcoli. Non è un processore generico e non deve esserlo, perché rinuncia a parte della flessibilità di una CPU in cambio di un consumo molto più basso quando il lavoro è quello per cui è stata fatta.

Come ci riesca varia da progetto a progetto, e qui le generalizzazioni sono pericolose. Alcuni acceleratori organizzano le unità di moltiplica-e-accumula in una griglia attraversata ritmicamente dai dati, lo schema chiamato systolic array, che ha il pregio di far entrare un numero dalla memoria una volta sola e poi riusarlo lungo tutta la griglia; l’idea è del 1978, molto più vecchia della moda attuale. Altri progetti usano organizzazioni diverse. Quasi tutti però condividono tre scelte: precisione ridotta (tipicamente interi a 8 bit, a volte meno, o formati compatti in virgola mobile), molta attenzione a quanti dati si spostano, e memorie locali vicine alle unità di calcolo, spesso gestite dal compilatore anziché lasciate a una gerarchia di cache automatica. Dire che “una NPU non ha cache” sarebbe però troppo netto: dipende dal chip.

Il percorso storico è noto. Google usa i suoi TPU nei propri centri dati dal 2015 e ne pubblica l’architettura nel 2017; Apple mette un motore neurale dentro l’iPhone nel 2017, inizialmente riservato alle proprie funzioni e aperto agli sviluppatori l’anno dopo; Qualcomm ci arriva da un’altra strada, facendo evolvere il processore di segnale dei suoi modem. Nel 2024 Microsoft fissa la soglia dei 40 TOPS per chiamare un portatile Copilot+ PC, requisito tuttora indicato per diverse funzioni di quella categoria.

E allora perché mettercela, se in molti casi la scheda grafica dello stesso computer macina più lavoro al secondo? Per l’energia. Qui torna il numero di prima, nella sua forma robusta: spostare un dato dalla memoria esterna costa molto più che farci sopra un’operazione aritmetica, nelle misure classiche due o tre ordini di grandezza. Un acceleratore progettato per spostare poco e per non pagare il contorno delle istruzioni generiche fa lo stesso lavoro con una frazione dei watt.

Ecco perché le funzioni che girano sulla NPU sono quelle che devono stare accese a lungo, a batteria, senza far partire le ventole: sottotitoli dal vivo, sfocatura dello sfondo in videochiamata, riconoscimento vocale. Sul tipo di lavoro per cui è stata disegnata, la NPU è il pezzo che spende meno energia, e questo, più della velocità, è il motivo per cui ce la mettono.

Dove siamo adesso: quando il collo di bottiglia è la memoria

Ed eccoci al punto che chiude il cerchio, quello annunciato parlando del processore che sta fermo ad aspettare.

Negli ultimi vent’anni la potenza di calcolo dei chip di punta è cresciuta molto più in fretta della velocità con cui si leggono i dati dalla memoria. Quanto, esattamente, dipende da quali prodotti si prendono come riferimento: l’analisi di Gholami e colleghi, confrontando le generazioni successive di acceleratori, stima una crescita del calcolo di diversi ordini di grandezza a fronte di una crescita della banda di memoria molto più lenta, dell’ordine di un centinaio di volte nello stesso periodo. I numeri precisi vanno presi come ordini di grandezza, non come misure; la direzione, quella, è fuori discussione, ed è che per anni si è ottimizzato soprattutto ciò che costava meno.

Lo si vede bene nel caso che oggi interessa a molti, cioè far girare un modello linguistico sul proprio computer. Quando il modello scrive, produce un token alla volta (un token è un pezzetto di parola, l’unità con cui questi modelli lavorano), e per produrne uno deve far passare i parametri del modello dalla memoria alle unità di calcolo, facendoci sopra relativamente pochi conti. In questa modalità la velocità dipende soprattutto dalla banda di memoria, e in prima approssimazione vale che token al secondo ≈ banda di memoria ÷ byte del modello. Un modello da 4,5 gigabyte su un portatile che legge intorno ai 100 gigabyte al secondo sta nell’ordine della ventina di token al secondo, e il numero di TOPS sulla scocca non cambia granché il risultato.

È anche il motivo per cui la quantizzazione, cioè riscrivere il modello con meno bit per parametro, lo rende più veloce in questa fase. Non tanto perché faccia meno conti, quanto perché ci sono meno byte da spostare.

Messa così, tornano insieme mosse dell’industria che altrimenti sembrano scollegate. La memoria unificata dei chip Apple e simili, dove processore, grafica e motore neurale leggono lo stesso banco senza copiarsi i dati. La memoria HBM, impilata in verticale accanto al processore, che nei centri dati è diventata una delle risorse più contese. E i chiplet, cioè costruire un processore con più pezzi di silicio separati invece che con un unico blocco grande, che avrebbe troppi scarti di produzione.

Attenzione però a non trasformarlo in uno slogan. “Il collo di bottiglia è la memoria” vale per molti carichi di lavoro, non per tutti. Vale per il caso descritto sopra, un modello che genera testo per una persona sola. L’elaborazione iniziale della domanda, l’addestramento e i server che servono molti utenti insieme sono in genere limitati dal calcolo, perché lì ogni parametro letto viene riusato per molte richieste. E fuori dall’intelligenza artificiale ci sono programmi limitati dal disco, dalla rete, o semplicemente da come sono scritti.

Se vuoi continuare

Il seguito pratico di questo articolo è Ma a cosa serve un computer “con l’intelligenza artificiale”?, dove si guarda cosa cambia davvero nei negozi. Se invece vuoi provare a far girare un modello sul tuo computer e toccare con mano il discorso sulla memoria, c’è Ma a cosa serve un’intelligenza artificiale che gira sul tuo computer?.