Oltre la legge di Moore: evoluzioni architetturali dei processori Intel ...

Università degli Studi di Modena e Reggio Emilia
Facoltà di Ingegneria di Modena
Corso di Laurea in Ingegneria Elettronica
Vecchio Ordinamento Didattico
Oltre la legge di Moore:
evoluzioni architetturali
dei processori Intel fino a Nehalem
Relatore: Candidato:
Prof. Rita Cucchiara Marco Vezzani
Anno Accademico 2007/2008

Sommario
Sommario ............................................................................................................. 3
Indice delle figure ................................................................................................ 7
Ringraziamenti ................................................................................................... 13
Capitolo 1 - Introduzione ................................................................................... 15
Capitolo 2 - Il calcolo delle prestazioni ............................................................. 19
2.1 Prestazioni in termini di Velocità ............................................................ 19
2.1.1 Tcpu .................................................................................................. 22
2.1.2 MIPS ................................................................................................. 24
2.2 Prestazioni in termini di Consumo (potenza ed efficienza energetica) .... 26
2.3 Possibili approcci per l’aumento delle prestazioni .................................. 28
2.3.1 Uno sguardo all’evoluzione tecnologica ........................................... 29
2.3.2 Corsa al gigahertz e il limite dei 4 GHz ............................................ 33
2.4 Legge di Amdahl ..................................................................................... 35
Capitolo 3 - Modifiche architetturali per il miglioramento delle prestazioni .... 41
3.1 Introduzione ............................................................................................. 41
3.2 Parallelismo ............................................................................................. 42
3.2.1 Instruction Level Parallelism ............................................................ 45
3.2.2 Multithreading .................................................................................. 88
3.2.3 Multi core .......................................................................................... 95
3.2.4 Parallelismo dei dati e Unità Vettoriali ............................................. 98
3.2.5 Limiti sul livello di parallelismo ..................................................... 102

4 Indice delle figure
3.3 Cache ..................................................................................................... 103
3.3.1 Politiche di rimpiazzamento ........................................................... 106
3.3.2 Politiche di salvataggio ................................................................... 107
3.3.3 Protocolli di coerenza ..................................................................... 108
3.3.4 Associatività .................................................................................... 108
3.3.5 Obiettivo: Minimizzare i Cache miss ............................................. 111
3.3.6 Gerarchie delle cache ...................................................................... 115
3.4 Set di Istruzioni ...................................................................................... 122
Capitolo 4 - Il risparmio energetico ................................................................. 125
Capitolo 5 - Applicazione nei processori Intel® ............................................. 127
5.1 I processori della Intel ® Corporation ..................................................... 127
5.2 Modello Tick tock .................................................................................. 127
5.3 Nomi delle architetture e relative CPU .................................................. 130
5.4 Parallelismo “on Chip” .......................................................................... 131
5.4.1 Pipeline ........................................................................................... 131
5.4.2 Processori Superscalari ................................................................... 173
5.4.3 Predizione dei salti .......................................................................... 174
5.4.4 VLIW e Tecniche Predicative ......................................................... 180
5.4.5 Multithreading ................................................................................ 182
5.4.6 Multicore ......................................................................................... 189
5.5 Parallelismo a livello di dato ................................................................. 190
5.6 Nuove tecnologie per le cache di Intel ®
................................................. 192
5.7 Set di Istruzioni ...................................................................................... 194
5.7.1 IA-32: CISC o RISC? ..................................................................... 194

5.7.2 Tecnologia SIMD ........................................................................... 196
5.8 Il risparmio energetico ........................................................................... 204
Capitolo 6 - Il nuovo processore Core i7 ......................................................... 207
6.1 Elementi base della nuova architettura .................................................. 207
6.2 Design modulare .................................................................................... 209
6.3 Architettura dell’engine ......................................................................... 209
6.4 HyperThreading, ritorno al passato ........................................................ 212
6.5 Modelli ................................................................................................... 213
6.6 Architettura della cache ......................................................................... 215
6.7 Memory controller integrato .................................................................. 217
6.8 NUMA ................................................................................................... 217
6.9 QuickPath Interconnect .......................................................................... 218
6.10 Istruzioni SSE 4.2 ................................................................................ 219
6.11 Turbo Mode ......................................................................................... 219
6.12 Consumi ............................................................................................... 221
6.13 Considerazioni finali ............................................................................ 223
Capitolo 7 - Le architetture del futuro ............................................................. 225
7.1 La legge di Amdahl nell’era del multicore ............................................ 225
7.2 Una rivoluzione del pensiero comune .................................................... 231
7.3 “I sette nani” .......................................................................................... 236
7.4 Lo studio dell’ Intel ® : RMS ................................................................... 238
7.5 Autotuners .............................................................................................. 243
7.6 Nuove metriche di valutazione .............................................................. 246
Capitolo 8 - Le architetture del futuro ............................................................. 249
5

6 Indice delle figure
Appendice A - Storia della Intel® Corporation ............................................... 251
Appendice B - Storia dei processori Intel® ..................................................... 255
Cenni sulla evoluzione dei processori Intel ® precedenti al Pentium ............ 255
Evoluzione dei processori Intel ® a partire dal Pentium ............................... 265
Bibliografia ...................................................................................................... 279

Indice delle figure
Figura 1.1 - Incremento delle prestazioni a seguito di miglioramenti tecnologici
e architetturali. ................................................................................................... 16
Figura 2.1 - Grafico delle prestazioni in MIPS delle CPU Intel ® dall'8086 al
Pentium ®
............................................................................................................ 26
Figura 2.2 - Confronto tra la legge di Moore e l’incremento delle prestazioni . 29
Figura 2.3 – Grafico originale di Goordon Moore del 1965[6]. ........................ 30
Figura 2.4 -Aumento del numero di transistori delle CPU Intel ® .
Figura 2.5 – Aumento del numero di transistori nelle CPU Intel ® [8] ................ 33
Figura 2.6 - Densità di potenza dissipata dalle CPU .......................................... 34
Figura 2.7 - I risultati mostrano come un incremento anche minimo nelle
prestazioni di una parte utilizzata per parecchio tempo sia complessivamente
più rilevante di un miglioramento importante di parti poco utilizzate. .............. 38
Figura 3.1 - Diversi tipi di parallelismo applicabile ai sistemi di elaborazione. 42
Figura 3.2 - Tassonomia di Flynn per la classificazione dei sistemi paralleli ... 48
Figura 3.3 - Passaggi fonfdamentali di una pipeline .......................................... 50
Figura 3.4- Elaborazione di istruzioni senza pipeline. ....................................... 50
Figura 3.5- Esecuzione di istruzioni con pipeline .............................................. 51
Figura 3.6- La necessità di aspettare il dato disponibile genera una “bolla” nella
pipeline che comporta una riduzione del throughput. ........................................ 53
Figura 3.7- La pipeline del Pentium ® 4 costituita da 20 stadi ............................. 54
Figura 3.8 - Schema concettuale dell’esecuzione fuori ordine. ......................... 60
Figura 3.9 - Organizzazione di una pipeline col metodo del Reordering Buffer
........................................................................................................................... 61
Figura 3.10- Percorsi di by-pass e ROB. ........................................................... 64
32
7

8 Indice delle figure
Figura 3.11- Organizzazione della pipeline con un History Buffer (HB). ......... 65
Figura 3.12- Gli stati possibili della predizione bimodale ................................. 71
Figura 3.13 - Crescita del GAP tra la velocità delle memorie e delle CPU ....... 86
Figura 3.14 - Un processore single thread esegue un solo thread per volta ....... 89
Figura 3.15 -Un sistema multiprocessore classico esegue un thread per unità di
calcolo ................................................................................................................ 89
Figura 3.16 - Un sistema superthreading schedula più thread ma ne esegue uno
solo per ciclo di clock ........................................................................................ 90
Figura 3.17 - Un sistema Simultaneous Multi-Threading .................................. 95
Figura 3.18 – Schema a blocchi di una architettura vettoriale ......................... 101
Figura 3.19 –Modalità di riempimento della cache nel caso di memoria cache
“Mappata Direttamente” e “Associativa a 2 vie” ............................................. 109
Figura 3.20 - Frequenza di fallimento (miss rate) a confronto con la dimensione
della cache (Cache size) sulla porzione degli interi di SPEC CPU2000 ......... 113
Figura 3.21 - Un esempio di architettura con 3 livelli di cache. ...................... 120
Figura 3.22 – CISC vs RISC[15] ..................................................................... 123
Figura 5.1 – Tick-tock in azione. ..................................................................... 129
Figura 5.2-Per la sua politica di update Intel ® ha coniato il termine tick-tock
(equivalente del tic-tac italiano). ...................................................................... 130
Figura 5.3 – La integer pipeline del processore 486[17] ................................. 132
Figura 5.4 – Schema a blocchi della CPU 486. [18] ........................................ 134
Figura 5.5 – La integer pipeline del Pentium.[17] ........................................... 135
Figura 5.6 - Architettura interna del processore Pentium[17] ......................... 136
Figura 5.7- LA FPU del processore Pentium[17] ............................................ 139
Figura 5.8 – Struttura della pipeline MMX [19] .............................................. 142

Figura 5.9 - Introduzione del Buffer FIFO e dello stadio PF nella pipeline MMX
rispetto a quella del Pentium ® [20] .................................................................. 143
Figura 5.10 - Flusso di istruzioni MMX nel processore Pentium ® con tecnologia
MMX ............................................................................................................... 144
Figura 5.11 - Tipi di istruzioni MMX e relative unità funzionali [19] ............ 144
Figura 5.12 - La pipeline del processore Pentium ® Pro [19] ........................... 145
Figura 5.13 – In order FrontEnd del Pentium ® Pro [19] ................................... 147
Figura 5.14 - L'Out-of order Core del Pentium ® Pro [19] ................................ 149
Figura 5.15 - Execution units del Pentium ® Pro. [19] ..................................... 150
Figura 5.16 - Retirement unit del Pentium ® Pro ............................................... 150
Figura 5.17 - Execution units del Pentium ® II ................................................. 151
Figura 5.18 - Architettura del Pentium ® II e del Pentium ® III [21] ................... 152
Figura 5.19 - Execution unit e porte del core Out-of-order del Pentium ® III [21]
......................................................................................................................... 152
Figura 5.20 – Execution Unit del Pentium ® III.. ............................................... 153
Figura 5.21 - Microarchitettura Intel ® NetBurst [22] ...................................... 155
Figura 5.22- Execution Unit e porte della architettura NetBurst. [22] ............ 159
Figura 5.23 - Schema a blocchi dell'architettura del Pentium ® 4 [23] .............. 161
Figura 5.24 - Funzionamento della pipeline della microarchitettura Intel ®
Core[24] ........................................................................................................... 163
Figura 5.25- Elementi del Front End della microarchitettura Core [24] .......... 164
Figura 5.26 - Issue ports della Microarchitettura Intel ® Core. La tabella mostra I
dati per due modelli di processore. [24] ........................................................... 166
Figura 5.27 - Execution core della microarchitettura Intel ® Core [24] ............ 167
Figura 5.28 - Funzionamento della pipeline della microarchitettura Intel ®
Nehalem [24] ................................................................................................... 168
9

10 Indice delle figure
Figura 5.29 - Front end della pipeline della microarchitettura Nehalem [24] . 170
Figura 5.30- Bypass Delay tra µ-ops espresso in cicli [24] ............................. 172
Figura 5.31 - Issue Ports della microarchietettura Nehalem [24] .................... 173
Figura 5.32- BTB del Pentium. ........................................................................ 176
Figura 5.33 - Loghi dei processori Intel® Itanium® ed Itanium®2 ................ 181
Figura 5.34 - Due copie dell' "Architectural State" consentono ai processori con
tecnologia HyperThreading di essere visti come 2 processori logici [25]. ...... 183
Figura 5.35 – L’ Intel ® Pentium ® 4 e le risorse del processore visibili che
vengono dulicate per supportare la tecnologia HyperThreading. .................... 185
Figura 5.36 – In questa vista della execution pipeline della microarchitettura
NetBurst, le aree chiare e scure indicano l’utilizzo delle risorse di due threads
avviate sui due processori logici [25]. ............................................................. 188
Figura 5.37 – Condivisione delle risorse in alcune CPU Intel Multicore ........ 190
Figura 5.38 – Approccio Post-CISC [15] ........................................................ 196
Figura 5.39 - Estensioni dell'Instruction set nei processori Intel ® [27] ............ 197
Figura 5.40 - MMX ed SSE a confronto[29] ................................................... 199
Figura 5.41: TDP dei principali processori Intel ® per desktop dal Pentium ® II al
Pentium ® D ....................................................................................................... 205
Figura 5.42 : TDP vs Frequenza di clock ........................................................ 206
Figura 6.1 - Introduzione del "Loop Stream Detector" .................................... 211
Figura 6.2 - Schema a blocchi dei livelli di cache nei Core i7. ....................... 215
Figura 6.3 - Schema di base del funzionamento in Turbo Mode nel caso di
alcuni core disattivati. ...................................................................................... 220
Figura 6.4 - Schema di base del funzionamento in Turbo Mode nel caso di tutti
i core attivi. ...................................................................................................... 221
Figura 6.5 - Power Contro Unit della CPU Core i7.
Figura 7.1 – Fixed-Size Speedup di una architettura multicore.[37] ............... 230
221

Figura 7.2 - Fixed-Time Speedup di una architettura multicore [37] .............. 230
Figura 7.3 - Memory-Bounded Speedup di una architettura multicore [37] .... 231
Figura 7.4 - L’incremento di prestazioni RISC ............................................... 235
Figura 7.5 - “A view from Berkeley”: sette punti fondamentali per il calcolo
parallelo del 21° secolo. ................................................................................... 236
Figura 7.6 – Intel RMS. ................................................................................... 239
Figura 7.7 - Mapping of EEMBC, SPEC2006, Machine Learning,
Graphcs/Games, Data Base, and Intel ® ’s RMS to the 13 Dwarfs. ................... 243
Figura 7.8 – Prestazioni dell’Itanium 2 nella ricerca in matrici sparse
memorizzate mediante tecnica a blocchi [4] .................................................... 244
Figura 7.9 – Dimensione dei Blocchi ottimizzate per diverse CPU nella ricerca
in matrici sparse [4] ......................................................................................... 245
11

Ringraziamenti
Un bacio a mia moglie Francesca, per avermi supportato in questi anni e in
modo particolare in questi ultimi giorni.
Un grazie speciale a Robby, per i preziosi consigli dati in questi giorni.
Infine, ma non per ultimo, un sentito ringraziamento a tutti coloro che hanno
aspettato da tempo questa tesi e che si sono adoperati perché si potesse
realizzare.

Capitolo 1
Introduzione
Uno degli aspetti più sorprendenti della rivoluzione elettronica nei calcolatori è
costituito dallo straordinario progresso che ha caratterizzato i dispositivi
elettronici in termini di velocità, affidabilità, miniaturizzazione. Anche le
evoluzioni delle CPU sono sempre state guidate dalla necessità, talvolta più
commerciali che tecnologiche, di migliorare determinate prestazioni in termini
di velocità, area, consumo, numero di componenti, tolleranza ai guasti, tempi di
realizzazione, ecc...
L’obiettivo storico perseguito dai produttori di microprocessori è sicuramente
quello del miglioramento delle prestazioni sia come capacità di calcolo che
come velocità di presentazione dei risultati dell’elaborazione all’utente.
Diverse sono state le strade per poter ottenere questi risultati. In particolare ci
sembra di poter individuare due approcci: uno tecnologico ed uno architetturale.
Possiamo dire che da parecchi anni il miglioramento tecnologico segue la
famosa legge di Moore, individuando un trend di crescita continuo.
Osserviamo ora la Figura 1.1 che ci illustra i bound delle prestazioni ottenibili
nelle varie evoluzioni tecnologiche legati all’incremento della velocità di clock
ed al miglioramento delle architetture.
Dalla figura è evidente come, nella ricerca del miglioramento delle prestazioni,
risulta importante il miglioramento tecnologico (rappresentato dall’aumento

16 Capitolo 1
della frequenza di clock); allo stesso tempo rileviamo come il perfezionamento
della architettura contribuisca in maniera sempre più considerevole col passare
degli anni.
Figura 1.1 - Incremento delle prestazioni a seguito di miglioramenti tecnologici e
architetturali.
L’aspetto tecnologico è forse quello che da un punto di vista commerciale è
sempre stato maggiormente pubblicizzato e probabilmente fino ad una decina di
anni fa è stato sicuramente molto importante. Si pensi ad esempio alla “corsa al
Gigahertz” che si è avuta fino ai primi anni 2000.

Introduzione 17
Nuovi problemi sempre più stringenti come quello energetico, contribuiscono
alla necessità di progettare nuove architetture per ottenere significativi
incrementi di prestazioni
Questa tesi si propone di analizzare le linee guida che hanno accompagnato
negli ultimi 15 anni lo sviluppo delle microarchitetture delle CPU destinate al
mondo dei personal computer per cercare di capire i prossimi spazi di sviluppo.
Dopo una introduzione sulle modalità di calcolo delle prestazioni, nel Capitolo
3 vengono presentate da un punto di vista concettuale gli elementi architetturali
che sono alla base delle moderne CPU, specialmente per quanto concerne le
prestazioni con qualche accenno a quanto riguarda il risparmio energetico.
Il Capitolo 5e il Capitolo 6 presentano le reali applicazioni di tali concetti
adottati dalla Intel ® Corporation, uno dei maggiori produttori di CPU,
analizzando le modalità di applicazione nelle varie generazioni introdotte sul
mercato a partire dal Pentium ® fino ad arrivare all’ultima microarchitettura
Nehalem.
Alla luce di quanto illustrato, nel Capitolo 7sono infine proposte alcune
riflessioni che stanno guidando la ricerca scientifica nel settore e che
probabilmente troveranno spazio nelle future generazioni di processori.

Capitolo 2
Il calcolo delle prestazioni
Valutare le prestazioni di un sistema di elaborazione è un compito arduo: le
dimensioni e le complessità dei moderni sistemi software, unite all’ampia
varietà delle tecniche di ottimizzazione delle prestazioni utilizzate dai progettisti
hardware, hanno reso tale valutazione estremamente difficile. Non basta più
conoscere il set di istruzioni di una macchina, avere a disposizione un insieme
significativo di applicazioni software e misurare la velocità con cui vengono
eseguite le applicazioni su quella macchina; infatti devono essere utilizzate
metriche di misura diversa a seconda del tipo di applicazione e aspetti differenti
del sistema di calcolo possono essere di volta in volta quelli più significativi per
valutare le prestazioni globali. A tal riguardo si pensi ad esempio ai sistemi di
elaborazione portatili dove occorre valutare sia prestazioni in termini di velocità
che di risparmio energetico.
In questo lavoro ci soffermeremo in modo particolare su due metriche: le
prestazioni in termini di velocità e di consumo.
2.1 Prestazioni in termini di Velocità
La misura delle prestazioni di un calcolatore in termini di velocità è
normalmente ottenuta mediante stime di tempi di elaborazione.
Quantitativamente, possiamo definire:

20 Capitolo 2
1. Tempo di Esecuzione della CPU ( T exec ) o Tempo di CPU: tempo
realmente necessario alla CPU nella computazione di un Task specifico
(spesso misurato in cicli di clock).
2. Throughput ( T h ) o larghezza di banda: quantità di istruzioni o di
operazioni eseguite nell’unità di tempo. Quest’ultimo, essendo una
misura di frequenza, si riesce a stimare solo per sequenze di operazioni.
Per capire meglio il significato e la differenza dei due approcci facciamo
qualche considerazione.
Se tutte le operazioni eseguite da un calcolatore sono perfettamente sequenziali
allora possiamo definire il tempo di esecuzione come
T
1
=
T
exec (2.1)
h
Se il calcolatore può eseguire alcune operazioni in parallelo allora
T
exec
1
> (2.2)
T
h
Ad esempio nelle CPU attuali N operazioni non sono eseguite in un tempo pari
a N volte il tempo per l’esecuzione di una istruzione perché fasi di esecuzioni di
una istruzione sono sovrapposte nelle pipeline a fasi di esecuzione di una
istruzione successiva. Mentre una istruzione viene letta, l’altra viene
decodificata e così via. In questo modo la latenza o T exec per eseguire una
singola istruzione non cambia, ma il throughput T h aumenta.

Il calcolo delle prestazioni 21
Se tra una istruzione e la successiva esiste un ritardo non nullo allora si può
anche avere il caso di
T
exec
1
< (2.3)
T
h
Per esempio molte memorie, se devono cambiare modalità tra lettura e scrittura,
introducono un piccolo ritardo per riportare i registri interni allo stato iniziale.
In questo caso N operazioni di memoria hanno un throughput più basso se sono
di lettura e scrittura rispetto a quello che si avrebbe con operazioni dello stesso
tipo. In questo caso le memorie hanno ottimizzato l’accesso singolo e la latenza
a discapito del throughput.
Esistono alcuni modelli analitici che permettono di stimare a priori le
prestazioni delle CPU, seppure nelle ipotesi di situazioni ideali. Il modello più
semplice per le prestazioni della CPU utilizza il concetto di CPI (Clock Per
Instruction).
Chiamando
Ncc : numero di cicli di clock.
NI : numero di istruzioni in un programma in linguaggio
macchina.
Il CPI medio è definito come:
N
=
NI
CPI cc (2.4)

22 Capitolo 2
Per calcolare a priori il CPI medio bisogna conoscere il CPIi dell’istruzione i-
esima e l’occorrenza media (in percentuale) dell’istruzione i-esima in un
programma (indicata con xi). Tali quantità sono note spesso dai manuali
dell’hardware in esame. Quindi:
2.1.1 Tcpu
= ∑ ( i ∗ i)
CPI x CPI (2.5)
DEFINIZIONE E FORMULAZIONE ANALITICA
Chiamando Tck il tempo di clock, reciproco della frequenza f di lavoro,
possiamo definire il tempo di CPU con una semplice equazione:
T = N * T
(2.6)
cpu
cc
ck
Questa equazione ci da una prima indicazione di come le prestazioni dipendano
sia dalla frequenza di lavoro della cpu, che dal numero di cicli di necessari per
poter eseguire il programma.
Ma questo numero di cicli è sicuramente dipendente dal numero di istruzioni
presenti nel programma stesso. Se riprendiamo il concetto del CPI possiamo
esprimere il tempo di CPU come:
T = NI*
CPI * T
(2.7)
cpu
ck
L’equazione (2.7) è nota come legge di Iron. Da questa possiamo definire
l’unità di misura del Tcpu:
⎡ Sec ⎤ ⎛ NI ⎞ ⎛ Ciclo ⎞ ⎛ Sec ⎞
⎢ ⎥ = ⎜ ⎟*
⎜ ⎟*
⎜ ⎟
⎣Prog
⎦ ⎝ Prog ⎠ ⎝ NI ⎠ ⎝ Ciclo ⎠
T cpu (2.8)

Il calcolo delle prestazioni 23
CONSIDERAZIONI QUALITATIVE
L’espressione appena trovata ci evidenzia come Il tempo di CPU dipende da
tre elementi fondamentali:
• NI: dipende dal repertorio di istruzioni (ISA), dal grado di
ottimizzazione del compilatore nonché dal programmatore.
Siccome è il compilatore che traduce le istruzioni in un linguaggio di
alto livello in istruzioni eseguibili, esso può determinare prestazioni
diverse. Compilatori diversi possono dare luogo a NI diversi, così come
uno stesso compilatore che genera codice per due macchine diverse,
darà NI diversi. Il ruolo del compilatore è importantissimo; per progetti
complessi è necessario utilizzare compilatori ottimizzati per il
calcolatore specifico che siano in grado di sfruttare anche le scelte
microarchitetturali.
Anche il programmatore stesso ha un ruolo importante nella
determinazione di questo parametro in fase di stesura del codice.
• CPI: per ogni istruzione dipende dalla microarchitettura, dal repertorio
delle istruzioni e dalla architettura di tutto il calcolatore (si pensi ad
esempio alle operazioni di memoria).
Molto spesso il CPI per istruzione risulta molto variabile (es. istruzioni
tra registi o istruzioni con uso di memoria).
Istruzioni semplici richiedono un minor numero di cicli. Un
compilatore ottimizzato sceglie istruzioni semplici o con CPI minore;
inoltre attraverso tecniche come la pipeline è possibile portare il CPI ad

24 Capitolo 2
un valore molto vicino ad 1. L’aggiunta di più unità di esecuzione in
parallelo (macchine superscalari) permette di rendere il CPI minore di
1. Nei calcolatori attuali si parla infatti di IPC (Instruction per Clock),
reciproco del CPI. Ora il parametro IPC nei processori di recente
generazione è di 3,4.
• Tck (o il suo inverso, la frequenza): è legato alla tecnologia e
all’organizzazione architetturale della CPU.
Oggi grandezze nell’ordine dei 3 GHz sono la norma per PC; i
microcontrollori invece hanno una frequenza operativa molto più bassa.
Istruzioni complesse richiedono di norma frequenze più basse, invece i
calcolatori con un repertorio di istruzioni più semplice possono operare
a frequenze maggiori. In pc industriali, microcontrollori e DSP per
contenere i costi si usano frequenze ridotte.
Il confronto di prestazioni di CPU diverse deve perciò tenere in considerazione
entrambi questi aspetti e non uno solo di essi.
2.1.2 MIPS
DEFINIZIONE E FORMULAZIONE ANALITICA
Una grandezza utilizzata come misura delle prestazioni, in particolare in campo
commerciale, è il MIPS (Mega instruction per second).
Esso è definito come:

Il calcolo delle prestazioni 25
inoltre:
NI
* 10
MIPS =
6
Tcpu
f
=
CPI
MIPS ck
[ MHz]
medio
CONSIDERAZIONI QUALITATIVE
(2.9)
(2.10)
Siccome i MIPS sono una misura delle istruzioni eseguite, fissano le prestazioni
in modo inverso rispetto al tempo di CPU: le macchine più veloci hanno un
valore più elevato in termini di MIPS.
L’utilizzo dei MIPS per il confronto di prestazioni, presenta però tre problemi.
Per prima cosa esso specifica una misura delle istruzioni eseguite ma non tiene
conto delle caratteristiche delle istruzioni stesse: si tratta perciò di una misura
utilizzabile solo per CPU con la stessa ISA, in quanto set di istruzioni diverse
darebbero luogo a conteggi di istruzioni ovviamente differenti.
In secondo luogo, nello stesso calcolatore i MIPS variano a seconda del
programma. Una stessa macchina non ha un unico valore di MIPS per ogni
software.
Infine, il punto più importante è che MIPS possono variare in modo inverso
rispetto alle prestazioni.
A titolo di esempio, nelle figure seguenti sono riportati i valori MIPS delle CPU
Intel ® dal’8086 fino al Pentium ® .

26 Capitolo 2
Figura 2.1 - Grafico delle prestazioni in MIPS delle CPU Intel ® dall'8086 al Pentium ®
2.2 Prestazioni in termini di Consumo (potenza ed efficienza
energetica)
Il consumo di energia elettrica in un qualsiasi circuito integrato è
fondamentalmente dovuto a due processi: una parte viene dissipata nella
commutazione dei dispositivi contenuti nella CPU stessa (es. transistor), mentre
l’altra viene persa sotto forma di calore a causa della resistività dei circuiti
elettrici.
I produttori di processori utilizzano normalmente due grandezze per misurare la
potenza dissipata: la “Typical Thermal Power” (TTP) che viene misurata in
normali condizioni di carico e la “Maximum Thermal Power” (MTP) che viene
misurata facendo eseguire una serie di istruzioni complessa.
La dissipazione termica in termini da calore, impone che alle CPU vengano
applicati sistemi di raffreddamento tali da garantire temperature di esercizio
entro determinati range. La grandezza che viene utilizzata per indicare la

Il calcolo delle prestazioni 27
quantità di energia massima che deve essere in grado di dissipare il sistema di
raffreddamento è il “Thermal Design Power” (TDP), a volte chiamata
“Thermal Design Point”.
L’aumento dei costi per l’energia, la disponibilità e l’impatto ambientale della
produzione energia elettrica, ha portato a considerare l’efficienza energetica
come un parametro molto importante nella valutazione delle prestazioni dei
calcolatori. Se in un primo momento l’interesse maggiore veniva del settore
enterprise per l’ottimizzazione delle sale server, oggi anche nel settore dei
personal computer l’interesse ala efficienza energetica è diventato elevato.
Possiamo dire che i PC hanno cambiato il mondo, consentendo alle persone di
lavorare e giocare in modi che precedentemente erano inimmaginabili. Ma
l’elevato numero di PC desktop e notebook, hanno ora un effetto misurabile sul
consumo energetico mondiale .
Tutti i produttori sono sempre più attenti a questi aspetti, cercando di sviluppare
nuovi prodotti in grado di aumentare le prestazioni in termini di velocità e
migliorando allo stesso tempo l’efficienza energetica.
Ad oggi non sono ancora definiti degli standard metodologici per una
valutazione congiunta di prestazioni e costi energetici associati, anche se i vari
produttori stanno proponendo alcune possibili soluzioni. Ad esempio Intel ®
chiama il suo approccio EEP: Energy-Efficient Performance[1][2].

28 Capitolo 2
2.3 Possibili approcci per l’aumento delle prestazioni
Ogni giorno sono progettate soluzioni migliori in termini di funzionalità
eseguite e a parità di funzionalità, in termini di velocità.
Il miglioramento della tecnologia microelettronica è sicuramente una delle
cause di questi risultati come ci ricorda la famosa legge di Moore:
“Il numero di transistor raddoppia ogni 18 mesi, e quindi con esso
aumentano le risorse a disposizione”[3]
Come abbiamo potuto osservare nel capitolo precedente, le prestazioni però non
sono direttamente proporzionali né al solo numero di transistor, né alla sola
velocità del clock.
Un aspetto almeno altrettanto importante è il miglioramento dell’architettura
dei calcolatori.
“Non esiste nessuna legge esatta, ma dalla fine degli anni ‘80 con
l’avvento dell’architettura RISC si è verificato un aumento delle
prestazioni che è passato dal 35% a più del 50% ogni anno.” [4]
Nella Figura 2.2, è riportato un esempio di come addirittura il miglioramento
dell’architettura influenza più del miglioramento della frequenza di clock o del
numero di transistor;

Il calcolo delle prestazioni 29
Figura 2.2 - Confronto tra la legge di Moore e l’incremento delle prestazioni 1
Sebbene storicamente non sia sempre stato così, esistono oggi diversi limiti
fisici che fanno pensare a come l’influenza della tecnologia possa nel futuro
essere sempre meno influente nell’aumento delle prestazioni, mentre gli aspetti
architetturali siano sempre più di cruciale importanza.
2.3.1 Uno sguardo all’evoluzione tecnologica
Nell’aprile del 1965 Gordon Moore, che assieme a Robert Noyce e Andy
Groove nel 1968 fondò l’ Intel ® , in un articolo sulla rivista Electronics 2
ipotizzo
1 Nella figura viene utilizzata come unità di misura delle prestazioni la GFLOPS: si
tratta dell’acronimo di “Giga FLoating point Operation Per Second” ovvero l’analogo
dei MIPS ma riferito ad operazioni floating point.

30 Capitolo 2
che l’incremento della capacita elaborativa sarebbe continuato per tutti gli anni
Settanta al ritmo di un raddoppio ogni 12 mesi[5]. Moore aveva appena finito di
realizzare un chip contenente 60 transistori, il doppio di quello che aveva
realizzato l’anno precedente. Per “aumento della capacita elaborativa” egli, in
realtà, intendeva “aumento del numero di transistori” nel singolo chip. Vedremo
che le due cose non sono perfettamente equivalenti.
Figura 2.3 – Grafico originale di Gordon Moore del 1965[6].
Questa previsione fu poi corretta dallo stesso Moore due volte: nel 1975
portandola a un raddoppio ogni 2 anni [7] (ed estendendone la validità agli anni
Ottanta) e a fine anni Ottanta portandola a 18 mesi.
La previsione di Moore, rivelatasi corretta per un periodo molto lungo, e
diventata il metro di misura e l’obiettivo per le aziende che operano nel settore,
tanto da essere percepita come una legge, la cosiddetta legge di Moore.
2 All'epoca era una rivista di larghissima diffusione. Veniva distribuita gratis, anche in Italia, a
chiunque fosse ritenuto un soggetto capace di influenzare acquisti di componenti o apparati
elettronici.

Il calcolo delle prestazioni 31
Come e facile immaginare, più di uno scettico ha levato la sua voce contra la
sostenibilità dell’evoluzione quantitativa prevista da questa legge. Non c’e
alcuna ragione per cui essa debba continuare a valere: non e una legge di natura,
bensì una legge sull’ingegno umano. Prima o poi smetterà di valere. Ma gli
scettici avranno dovuto aspettare un bel po’ prima di vedere confermate le loro
critiche 3
.
La legge di Moore spiega in termini quantitativi, meglio di qualunque
argomentazione verbale, lo spettacolare sviluppo dell’elettronica a cui si sta
assistendo da anni. Affermare che la microelettronica raddoppia la sua capacita
ogni 18 mesi significa affermare che nei prossimi 18 mesi avremo un
incremento equivalente a quello che si e avuto fino a oggi. Un tale tasso di
evoluzione comporta delle conseguenze che verrebbe voglia di chiamare
fantascientifiche, se esse non fossero parte della vita di tutti i giorni.
Anzitutto c’e un’accentuata riduzione dei costi nel tempo, in netta
controtendenza rispetto a qualunque produzione industriale. Si capisce perché
un personal computer corrente ha una capacita elaborativa qualche centinaio di
volte superiore a quella di un mainframe di trent’anni addietro, nonostante che il
primo costi intorno al migliaio di euro, mentre per un mainframe dell’epoca un
miliardo di lire (di allora) poteva anche non bastare.
3 Per capire i limiti fisici teorici della legge di Moore, cioè quali sono la massima potenza
elaborativa e la massima densità di informazioni raggiungibili, si può leggere una serie di articoli
sul numero del 31 agosto 2000, vol. 406, della rivista Nature (rintracciabile su Internet), in
particolare l'articolo “Ultimate physical limits to computation” di Seth Lloyd (pp.1047-1054).

32 Capitolo 2
In Figura 2.4 viene riportato il numero di transistori delle principali CPU Intel ®
a partire dal 4004 fino al Core 2 Quad. La Figura 2.5 riporta gli stessi dati in
forma di diagramma.
Figura 2.4 -Aumento del numero di transistori delle CPU Intel ® . I dati riportati si
riferiscono al modello di introduzione sul mercato. Per i modelli introdotti in più
versioni, la tabella riporta i dati relativi alla versione di più bassa capacità. Per
esempio il Pentium ® Pro è stato introdotto in ben quattro versioni, di cui la meno
potente (quella riportata) era tecnologia a 0,6µm e frequenza pari a 150MHz, mentre la
più avanzata era in tecnologia a 0,35 µm e frequenza pari a 200 MHz [8].
L’evoluzione della microelettronica passa sia attraverso la progressiva riduzione
delle dimensioni dei transistori sul chip sia attraverso la riduzione delle
dimensioni delle connessioni tra di essi. La dimensione dei circuiti di
connessione e spesso utilizzata come parametro di misura. Alla data di
pubblicazione di questa tesi (aprile 2009) la produzione di avanguardia di Intel ®
è a 45 nm.

Il calcolo delle prestazioni 33
Figura 2.5 – Aumento del numero di transistori nelle CPU Intel ® [8]
2.3.2 Corsa al gigahertz e il limite dei 4 GHz
Sebbene la legge di Moore sia ancora rispettata, anche se con qualche
adattamento, possiamo osservare come la velocità di lavoro delle CPU abbia
invece subito una brusco rallentamento. Anzi, se consideriamo ad esempio i
primi modelli del successore del Pentium ® 4, sono usciti sul mercato con
frequenze di lavoro molto più basse (1,2 GHz rispetto ai 3,6 delle versioni più
performanti dello stesso P4).
I produttori di CPU, fino a questo momento, avevano abituato la maggior parte
degli utenti a pensare che il principale parametro prestazione della CPU fosse la
sua velocità di clock; chi si è trovato a dover vendere Personal Computer in
quel periodo ha sicuramente trovato qualche difficoltà a convincere i propri
clienti che, nonostante la riduzione di frequenza, le prestazioni complessive
erano migliorate.

34 Capitolo 2
Se però riprendiamo la formula del Tcpu, risulta evidente come questo sia
possibile se vengono migliorati gli altri due aspetti: il set di istruzioni e gli
aspetti architetturali.
Ma come mai si è stati costretti a ridurre le frequenze di lavoro e non si è
riusciti a mantenere il trend di crescita precedente?
Possiamo individuare tre motivi principali:
• Problemi relativi alla potenza dissipata. l’aumento della frequenza di
lavoro della CPU comporta un aumento del numero di commutazioni
dei transistor e pertanto un aumento della potenza dissipata come
anticipato nel paragrafo 2.2.
La riduzione delle dimensioni dei transistor con la conseguente
riduzione delle tensioni di lavoro, nonché l’esperienza nella
progettazione dei layout permette di ottenere da un punto di vista
tecnologico la riduzione del consumo di energia.
Figura 2.6 - Densità di potenza dissipata dalle CPU

Il calcolo delle prestazioni 35
• Problemi termici. L’aspetto più gravoso della dissipazione di potenza,
che può implicare anche il cattivo funzionamento della CPU stessa, è la
dissipazione termica. Oltre una certa temperatura infatti i dispositivi
integrati perdono le loro capacità funzionali. Si rende pertanto
necessario applicare dispositivi di dissipazione che garantiscano un
adeguato raffreddamento del chip.
• Il Limite fisico della velocità luce e i problemi di propagazione dei
segnali: senza voler effettuare una trattazione rigorosa sulla ricerca di
quale sia il limite massimo della frequenza di clock di una CPU,
osserviamo se riuscissimo a fare propagare il segnale per 1 cm alla
velocità della luce nel vuoto la massima frequenza ottenibile sarebbe di
10GHZ. In realtà le condizioni sono ben differenti dal vuoto, nonché le
distanze percorse possono essere anche maggiori. In più si presentano
problemi di distorsione del segnale a causa delle capacità intrinseche
dei circuiti.
2.4 Legge di Amdahl
Un ulteriore spunto di riflessione su come ci si debba muovere per migliorare le
prestazioni di una CPU ci viene dalla legge di Amdahl [9].
Questa regola afferma che:
“Se si migliora solo un elemento del calcolatore, il miglioramento
complessivo ottenuto dipende dalla % di tempo di uso di quel
componente”.

36 Capitolo 2
La lettura di questa regola per quanto riguarda la possibilità di incremento delle
prestazioni ci porta a due considerazioni.
In primo luogo concentrarsi a migliorare un solo aspetto di un qualsiasi
componente, può addirittura essere quasi ininfluente in termini di prestazioni
del sistema complessivo.
In secondo luogo possiamo desumere il seguente corollario:
“Per migliorare la velocità di un sistema conviene aumentare la velocità degli
elementi che vengono utilizzati più frequentemente”.
CONSIDERAZIONI ANALITICHE
Cerchiamo ora di vedere questi concetti da un punto di vista più analitico.
Per un qualsiasi sistema, si può definire una grandezza che indica quanto è
migliorata la prestazione globale del sistema in seguito ad un miglioramento
anche solo di una sua parte.
Questa grandezza prende il nome di Speedup.
Lo Speedup o accelerazione è pertanto un indice di miglioramento.
In realtà esso altro non è che il rapporto tra la prestazione ottenuta con il
miglioramento rispetto a quella ottenuta senza miglioramento.
Dato che nelle CPU il miglioramento cercato è in termini di velocità, le
prestazioni sono il reciproco del tempo di esecuzione:
SP
new →old
P
=
P
new
old
T
=
T
exec
exec
old
new
(2.11)

Il calcolo delle prestazioni 37
All’utilizzatore però poco importa lo speedup di ciascun elemento di un
calcolatore; è sicuramente molto più interessato a quello che si chiama
“speedup overall” ossia il miglioramento complessivo di tutto il calcolatore.
Per quantificare lo speedup overall ci viene proprio in aiuto la “Legge di
Amdahl” che possiamo anche riformulare nel modo seguente:
“Il miglioramento delle prestazioni dovute ad un miglioramento di esecuzione è
limitato dalla frazione di tempo in cui tale miglioramento può essere applicato”.
dove:
⎡ F ⎤ enh
exec = T * ( 1 )
new exec ⎢ − F enh + ⎥ (2.12)
⎣ Senh
⎦
T old
Fenh (fraction enhanced): è la percentuale di tempo in cui ha effetto
il miglioramento
Senh (speedup enhanced) è il valore di tale miglioramento.
Dalla equazione (2.12) si ottiene che lo speedup complessivo risulta:
SP overall
=
⎡
⎢
⎣
1
( 1−
F )
enh
F
+
S
enh
enh
⎤
⎥
⎦
(2.13)
Per capire meglio in termini quantitativi queste considerazioni facciamo due
esempi.
Supponiamo di avere due calcolatori identici che montano però due versioni
diverse di CPU. Il calcolatore B monta, per ipotesi, una CPU che è 5 volte più
veloce di quello installata sul calcolatore A. Supponiamo poi che il tempo

38 Capitolo 2
medio di utilizzo della CPU da parte degli applicativi sia del 50%. A quanto
ammonta l’incremento effettivo di prestazioni tra il calcolatore A ed il
Calcolatore B?
In questo caso avremo che
Pertanto
S = 5
(2.14)
enh
F = 0,5
(2.15)
enh
SP overall
=
⎡
⎢
⎣
( 1−
0,
5)
1
= 1,66
0,
5⎤
+
5 ⎥
⎦
(2.16)
Confrontiamo ora una scelta architetturale che prevede l’impiego di nuove
componenti con speedup elevatissimo (anche di 20) ma utilizzate in minima
parte (circa il 10%) rispetto ad una scelta di miglioramento più contenuto
(anche solo del 1,2) ad una parte usata il 90% dei casi.
In questo caso avremo:
Caso 1 Caso 2
Senh
= 20
SP overall
=
⎡
⎢
⎣
( 1−
0,
5)
Fenh
= 0,1
1
= 1,105
0,
5⎤
+
20 ⎥
⎦
Senh
= 1,2
SP overall
=
⎡
⎢
⎣
( 1−
0,
9)
Fenh
= 0,9
1
= 1,176
0,
9⎤
+
1,
2
⎥
⎦
Figura 2.7 - I risultati mostrano come un incremento anche minimo nelle prestazioni di
una parte utilizzata per parecchio tempo sia complessivamente più rilevante di un
miglioramento importante di parti poco utilizzate.

Il calcolo delle prestazioni 39
Nelle macchine RISC si era ad esempio osservato che il 90% del tempo era
utilizzato per eseguire soltanto il 10% delle istruzioni disponibili e quindi le
nuove scelte architetturali vennero studiate per migliorare solo quel 10%, anche
a discapito del resto.
L’analisi della espressione analitica della legge di Amdahl, ci porta anche ad
osservare come esista un limite allo speedup overall, dipendente dalla
percentuale di uso di una parte del sistema.
Se infatti facciamo tendere ad infinito lo speedup enhanched, lo speedup overall
resta limitato:
SP
lim overall
→∞
S enh
=
1
[ ( 1−
F ) ]
enh
(2.17)

Capitolo 3
Modifiche architetturali per il miglioramento delle
prestazioni
3.1 Introduzione
Riprendiamo la legge di Iron (2.7) del tempo di CPU:
NI
T cpu = NI * CPI * Tck
= * Tck
(3.1)
IPC
Come già precedentemente accennato, mantenendo costante il tempo di clock
Tck, il miglioramento delle prestazioni di una CPU si ottengono:
• riducendo NI
• aumentando IPC (Instruction Per Clock)
Ma quali sono gli aspetti architetturali che ci permettono di ottenere questi
risultati?
Una prima possibilità è quella di cercare di eseguire un numero maggiore di
operazioni contemporaneamente, in modo da aumentare IPC; in altri termini
significa aumentare il parallelismo.
L’aumento dell’IPC può anche essere ottenuto cercando di ridurre al minimo i
motivi di stallo della CPU legati per esempio ad elementi esterni “lenti” (es
memorie).

42 Capitolo 3
Un altro modo per aumentare le prestazioni è indubbiamente legato al numero
di istruzioni necessarie. Un modo per ridurre il tempo di CPU è perciò quello di
aggiungere nell’ISA dei set di istruzioni ottimizzati specializzati all’esecuzione
di determinate operazioni.
3.2 Parallelismo
Nella figura seguente sono riportati diversi tipi di parallelismo applicabili ai
sistemi di elaborazione:
Figura 3.1 - Diversi tipi di parallelismo applicabile ai sistemi di elaborazione.

Modifiche architetturali per il miglioramento delle prestazioni 43
I fattori che caratterizzano, dal punto di vista hardware, un sistema parallelo
sono i seguenti:
• Natura e numero degli elementi di calcolo: il parallelismo può essere
stabilito tra semplici ALU (anche 1.000.000) oppure tra potenti CPU
complete (fino a 10.000).
• Natura e numero degli elementi di memoria: normalmente la memoria è
suddivisa in moduli indipendenti al fine di permettervi l’accesso da più
CPU contemporaneamente.
• Modalità di interconnessione: rappresenta il principale elemento di
differenziazione. La connessione può essere:
o Statica: i legami tra le CPU sono determinati a priori e sono
fissi
o Dinamica: i legami tra le CPU sono definiti in base alle
necessità da opportuni dispositivi (switch) in grado di instradare
i messaggi.
Sebbene qualsiasi combinazione di queste caratteristiche sia possibile si
tendono a realizzare sistemi con un piccolo numero di CPU indipendenti, grandi
e dotate d’interconnessioni a bassa velocità (sistemi debolmente accoppiati o
loosely coupled) oppure sistemi in cui il parallelismo è realizzato a livello di
componenti più piccole e che interagiscono fortemente tra loro (sistemi
fortemente accoppiati o strongly coupled).

44 Capitolo 3
Esiste una forte correlazione tra le caratteristiche hardware di un sistema
parallelo e i problemi software che possono essere utilmente risolti su di esso. Il
fattore discriminante è il livello di granularità del parallelismo:
• Parallelismo course-grained: l’elemento software che viene
parallelizzato è grande (es. programma); i vari processi paralleli non
hanno bisogno di comunicare (es. Sistema UNIX multi-utente, web-
server).
• Parallelismo fine-grained: l’elemento software che viene parallelizzato
è piccolo (es. singola operazione); i vari processi paralleli hanno
bisogno di comunicare poiché stanno risolvendo lo stesso problema (es.
Calcolatori vettoriali).
PARALLELISMO NEL CHIP
L’interesse di questo lavoro è di valutare le possibilità di incremento delle
prestazioni delle singole CPU. Ci soffermeremo pertanto a trattare il
parallelismo sul singolo chip.
Diverse sono le possibilità di implementazione del parallelismo a livello di
singola CPU:
• Parallelismo a livello di istruzioni (ILP – Instruction Level
Parallelism): l’idea che sta alla base di questo approccio consiste nel
fare eseguire contemporaneamente più istruzioni. Esempi di queste
tecniche sono le Pipeline e le Architetture Superscalari.
• Multi-threading: in questo caso la CPU esegue contemporaneamente
due thread (parti di programma) come se esistessero due CPU virtuali.

Modifiche architetturali per il miglioramento delle prestazioni 45
Se uno dei due deve attendere, ad esempio per un cache-miss (sia di
primo che di secondo livello), l’altro può continuare l’esecuzione
evitando di lasciare la CPU in attesa. È il caso dell’HyperThreading del
Pentium ® 4. In casi limite, il multi-threading su CPU virtuali può portare
a peggioramento delle prestazioni.
• Multi-core: consente un vero multi-threading e permette in certi casi di
aumentare notevolmente le prestazioni. Es. Core 2 Duo di Intel ® .
• Più core eterogenei nel chip: ingloba nello stesso chip due o più core
ma con funzionalità specializzate. Es. Cell di IBM/Sony/Toshiba.
3.2.1 Instruction Level Parallelism
L’ “Instruction Level Parallelism” (ILP ovvero parallelismo a livello
d’istruzione) è la possibilità di eseguire delle istruzioni di un programma in
parallelo da parte un sistema di calcolo.
La ricerca di rendere il codice parallelo a livello di istruzioni è diventata una
priorità nei moderni microprocessori. Questi ultimi infatti sono dotati di molte
unità di calcolo e usualmente seguono una struttura a pipeline: l’individuazione
e lo sfruttamento delle istruzioni eseguibili in parallelo permette pertanto di
utilizzare le unità funzionali dei processori contemporaneamente innalzando le
prestazioni del microprocessore.
Consideriamo il seguente frammento di pseudocodice:
Istruzione 1:
h =
a + b

46 Capitolo 3
Istruzione 2:
Istruzione 3:
f = c + d
g = h * f
L’istruzione 1 e 2 possono essere eseguite in parallelo dato che richiedono dei
dati (a, b, c, d) che non sono utilizzate da altre istruzioni e quindi sono libere.
Invece l’istruzione 3, per venire eseguita, deve attendere il completamento delle
prime due istruzioni dato che i dati h e f dipendono dall’esecuzione delle prime
due istruzioni. Supponendo di avere delle unità di calcolo (ALU) indipendenti
quindi si possono eseguire le istruzioni 1 e 2 in parallelo mentre la 3 deve
attendere le altre due. Supponendo di avere unità che eseguono le operazioni in
un ciclo di clock eseguendo le operazioni in parallelo si può completare il
codice in due cicli di clock mentre un’esecuzione seriale del codice
richiederebbe tre cicli di clock. Con questa modifica l’IPC diventa 3/2 dato che
si eseguono tre istruzioni in due cicli di clock.
CENNI STORICI
Fin dagli albori dell’informatica i progettisti hanno cercato di eseguire alcune
operazioni in parallelo al fine di ottenere un incremento delle prestazioni dei
sistemi di elaborazione. Già lo Z3, il primo computer digitale degli anni 40, era
in grado di eseguire alcune parti delle elaborazioni in parallelo al fine di
migliorare le sue prestazioni.
Il suo successore, lo Z4 (1944-1949) provvedeva al caricamento di due
istruzioni in parallelo se non vincolate, in modo da ridurre i tempi di accesso.

Modifiche architetturali per il miglioramento delle prestazioni 47
È del 1946 nei laboratori Bell, era stato implementato un gestore di due
processori venivano gestiti che distribuiva le istruzioni base alle unità libere.
Nell’IBM SSEC (1948), due istruzioni se non dipendenti venivano unite in una
sola linea in modo da poterle far eseguire in parallelo al computer. Il
trasferimento dei dati era effettuato in modo asincrono.
Già nel 1953 un articolo di Wilkes e Stinger [10] suggerisce la possibilità di
raccogliere istruzioni indipendenti in una sola macroistruzione da far caricare al
computer.
È invece del 1969 articolo sullo sviluppo di un primitivo sistema VLIW di
Melliar-Smith.
Gene Amdahl nella sua tesi del 1951 [9], descrive una pipeline a quattro stadi
(caricamento istruzione, caricamento dati, esecuzione, salvataggio risultati). Le
pipeline cominceranno ad essere implementate nelle CPU i primi degli anni 60.
Nel 1964 esce il CDC 6600, processore scalare con esecuzione fuori ordine,
dotato di dieci unità funzionali nella CPU. La CPU decodifica un’istruzione per
ciclo di clock e la invia allo scoreboard che può avviare fino a tre istruzioni in
contemporanea (limitazione dovuta alla presenza di registri a tripla porta). In
questa CPU compare anche una rudimentale esecuzione multithreading.
Nel 1966 Michael J. Flynn presenta sulla rivista IEEE un articolo [11] sui
sistemi di calcolo ad alta velocità, mettendo le basi per una classificazione dei
sistemi di calcolo nota con il nome di Tassonomia di Flynn (vedi Figura 3.2).

48 Capitolo 3
Figura 3.2 - Tassonomia di Flynn per la classificazione dei sistemi paralleli
Negli anni settanta e ottanta sono diverse le applicazioni di architetture
superscalari e tecniche VLIW.
È dell’ottobre 1981 il brevetto di James H. Pomerene (IBM), "Machine for
multiple instruction execution"[12], sulla realizzazione di sistemi che elaborano
gruppi di istruzioni indipendenti contemporaneamente.
Nel recente 2001, Intel ® presenta i processori Itanium basati su architettura
Explicitly Parallel Instruction Computing (EPIC).
TIPOLOGIE DI ILP
Possiamo distinguere due macrocategorie di ILP: l’ILP statico e quello
dinamico.
Nel “ILP statico” il processore riceve le operazioni già suddivise in blocchi di
istruzioni indipendenti eseguibili in parallelo; il processore deve unicamente

Modifiche architetturali per il miglioramento delle prestazioni 49
eseguire le istruzioni dato che l’analisi del codice è già stata effettuata dal
compilatore, il quale ha già individuato ed evidenziato le parti eseguibili in
parallelo. Questo approccio permette di realizzare processori semplici e veloci
ma ha lo svantaggio che i programmi vengono compilati appositamente per un
singolo tipo di processore e modifiche all’architettura interna del processore
possono produrre notevoli riduzioni di prestazioni e in casi estremi anche errori
di esecuzione. I processori Very Long Instruction Word (VLIW) seguono
questa filosofia.
Invece nel “ILP dinamico” il compilatore non analizza il codice alla ricerca di
istruzioni parallelizzabili; questo compito viene infatti svolto dal processore che
durante l’esecuzione decide dinamicamente quali istruzioni sono eseguibili in
parallelo. Questo permette di non legare il codice all’architettura di un singolo
processore ma ha lo svantaggio di rendere il microprocessore molto più
complesso e potenzialmente più lento. Il processore ha pochi nanosecondi per
decidere se esistono delle istruzioni parallelizzabili e per decidere come
organizzarle mentre un compilatore può fare un’analisi approfondita del codice
avendo molto più tempo a disposizione.
I microprocessori per computer implementano ormai tutti l’ILP dinamico,
sebbene molti possano utilizzare anche alcune tecniche di ILP statico per
incrementare le prestazioni.

50 Capitolo 3
ILP DINAMICO
Durante l’esecuzione il processore per individuare le istruzioni parallelizzabili
può utilizzare molte tecniche, le principali sono:
La Pipeline
La pipeline è una tecnologia di parallelismo ILP utilizzata dai microprocessori
per incrementare il throughput. L’elaborazione di un’istruzione da parte di un
processore si compone di cinque passaggi fondamentali:
IF (Instruction fetch): Lettura dell’istruzione da memoria
ID (Instruction decode): Decodifica istruzione e lettura
operandi da registri
EX (Execution): Esecuzione dell’istruzione
MEM (Memory access): Accesso alla memoria (solo per certe
istruzioni)
WB (Write back): Scrittura del risultato nel registro
opportuno
Figura 3.3 - Passaggi fonfdamentali di una pipeline
Senza pipeline la CPU richiede quindi almeno cinque cicli di clock per eseguire
una singola istruzione e l’istruzione successiva non può iniziare fino al
completamento di quella precedente.
Figura 3.4- Elaborazione di istruzioni senza pipeline.

Modifiche architetturali per il miglioramento delle prestazioni 51
L’esecuzione delle istruzioni con pipeline prevede che la CPU sia composta da
diversi stadi specializzati, capaci di eseguire ciascuno una operazione
elementare di quelle sopra descritte. La CPU lavora come in una catena di
montaggio e quindi ogni stadio provvede a svolgere solo un compito specifico.
Quando la catena è a regime, ad ogni ciclo di clock esce dall’ultimo stadio
un’istruzione completata. Nello stesso istante ogni unità sta elaborando in
parallelo i diversi stadi delle successive istruzioni. In sostanza si guadagna una
maggior velocità di esecuzione a prezzo di una maggior complessità circuitale
del microprocessore, che non deve essere più composto da una sola unità ma da
cinque unità che devono collaborare tra loro.
Cenni storici
Figura 3.5- Esecuzione di istruzioni con pipeline
Nel 1951 Gene Amdahl nella sua tesi [9] introduce un nuovo elemento di
parallelismo: descrive infatti una pipeline a quattro stadi (caricamento
istruzione, caricamento dati, esecuzione, salvataggio risultati).
Il concetto di pipeline viene poi sviluppato dal ricercatore Robert Tomasulo
dell’IBM intorno agli anni ‘60. Il primo sistema dotato di pipeline fu infatti il
supercomputer IBM System 360/91 presentato nel 1966 che grazie alla pipeline

52 Capitolo 3
otteneva un incremento anche del 33%. La pipeline si diffuse rapidamente nei
supercomputer e nei server. Il primo microprocessore a utilizzare una pipeline
fu il MOS Technology 6502 che tramite una semplice pipeline forniva
prestazioni superiori a quelli della concorrenza a una frazione del loro costo.
Nel settore di microprocessori le pipeline divennero comuni con i processori
RISC, la cui semplicità consentì di utilizzare un’architettura a pipeline completa
fin dalle loro prime implementazioni negli anni ottanta. I progetti Berkeley
RISC e MIPS infatti, avevano già una pipeline. I processori CISC utilizzarono
un’architettura a pipeline completa solamente alla fine degli anni 80 per via
delle maggiori difficoltà di implementazione.
Punti Deboli
L’implementazione di una pipeline non sempre moltiplica il throughput.
I problemi principali di gestione della pipeline sono due: il problema legato alla
presenza di istruzioni che possono richiedere l’elaborazione di dati non ancora
disponibili e il problema legato alla presenza di salti condizionati.
Il primo problema deriva dal lavoro parallelo delle unità.
Supponiamo che la CPU con pipeline debba eseguire il seguente frammento di
codice:
Istruzione 1:
Istruzione 2:
c = a + b
d = c −1
La prima istruzione deve prelevare i numeri contenuti nelle variabili “a” e “b”,
sommarli e porli nella variabile “c”. La seconda istruzione deve prelevare il
valore contenuto nella variabile “c”, sottrarlo di uno e salvare il risultato in “d”.

Modifiche architetturali per il miglioramento delle prestazioni 53
Ma la seconda istruzione non potrà essere elaborata (EX) fino a quando il dato
della prima operazione non sarà disponibile in memoria (MEM) e quindi la
seconda operazione dovrà bloccarsi per attendere il completamento della prima
e quindi questo ridurrà il throughput complessivo.
Figura 3.6- La necessità di aspettare il dato disponibile genera una “bolla” nella
pipeline che comporta una riduzione del throughput.
Questo tipo di problematiche è noto con il nome di “Alea sui dati”
Il secondo problema consiste nei salti condizionati. Nell’esecuzione dei
programmi si possono incontrare istruzioni condizionate che impongono, a
fronte del verificarsi di una specifica condizione, l’interruzione del flusso
abituale del programma e mandare in esecuzione un altro pezzo di programma
indicato dall’istruzione di salto. Ogni volta che questo accade il
microprocessore si trova a dover eseguire un nuovo flusso di operazioni e
quindi deve svuotare la pipeline del precedente flusso e caricare il nuovo flusso.
Ovviamente queste operazioni fanno sprecare cicli di clock e quindi fanno
crollare il throughput. Per ridurre questo problema (noto come Alea di
controllo) le CPU adottano delle unità funzionali chiamate unità di predizione
dei salti (in inglese Branch Prediction Unit) che fanno delle previsioni sul flusso
del programma. Queste unità riducono notevolmente i cicli persi per i salti.
Evoluzioni

54 Capitolo 3
Gli studi per migliorare le prestazioni delle CPU hanno portato ad affermare la
strategia di integrare in un unico microprocessore più pipeline che funzionano
in parallelo. Questi microprocessori sono definiti superscalari, in quanto sono in
grado di eseguire mediamente più di un’operazione per ciclo di clock. Queste
pipeline ovviamente rendono ancora più complessa la gestione dei problemi di
coerenza dei dati e dei salti condizionati.
Nelle CPU moderne inoltre, le pipeline non sono composte da soli cinque stadi
ma in realtà ne utilizzano molti di più (anche fino a 30). Questo si è reso
necessario per potere innalzare la frequenza di clock. Spezzettando le singole
operazioni necessarie per completare un’istruzione in tante sotto operazioni si
può elevare la frequenza della CPU dato che ogni unità deve svolgere
un’operazione più semplice e quindi può impiegare meno tempo per completare
la sua operazione. Questa scelta di progettazione consente effettivamente di
aumentare la frequenza di funzionamento delle CPU ma rende critico il
problema dei salti condizionati. In caso di un salto condizionato non previsto il
processore può essere costretto a svuotare e ricaricare una pipeline di numerosi
stadi.
Come esempio di pipeline profonda ricordiamo quella del Pentium ® 4 a 20 stadi.
Figura 3.7- La pipeline del Pentium ® 4 costituita da 20 stadi

Modifiche architetturali per il miglioramento delle prestazioni 55
Front End e Back End
Concettualmente ogni processore può essere suddiviso in due blocchi principali.
Il primo si occupa di prelevare le istruzioni dalla gerarchia di memoria e di
predisporle alla esecuzione. Questo significa che le istruzioni devono essere
decodificate (mediante suddivisione in microistruzioni o decodifica hardware)
per renderle "comprensibili" dalle unità di esecuzione e quindi distribuite
ognuna alla propria unità di esecuzione. Questo blocco è conosciuto come il
Front End del processore. Naturalmente quante più istruzioni esso riesce a
inviare alle unità di esecuzione tanto più è efficiente. Importante per questo
stadio è la comunicazione con la gerarchia di memoria (quindi le modalità e la
velocità con cui essa opera) per rifornire continuamente di istruzioni il Front
End, e la predizione delle diramazioni che cerca di impedire che la pipeline del
processore abbia stadi che non eseguono alcuna operazione in attesa che sia
noto l’esito della condizione di diramazione.
Il secondo stadio del processore è quello che esegue effettivamente il "lavoro"
cioè esegue le istruzioni e fornisce i risultati. Questo stadio è chiamato Back
End. L’efficienza di questo stadio è fortemente condizionata dal numero di
unità di esecuzione di cui dispone (per cominciare l’esecuzione di più di una
istruzione per ciclo) e dal tempo di cui necessita ciascuna unità per processare
una istruzione. I processori moderni fanno uso dell’esecuzione fuori ordine
proprio per fare fronte alla carenza di risorse (registri, unità di esecuzione) di
cui generalmente soffrono.

56 Capitolo 3
Quello che qui si intende rimarcare è che questi due stadi influenzano
reciprocamente le proprie prestazioni. Un Back End che esegue un elevato
numero di istruzioni per clock deve essere continuamente rifornito di nuove
istruzioni dal Front End da elaborare per non essere sottoutilizzato.
Analogamente per facilitare il lavoro di distribuzione delle istruzioni alle unità
di esecuzione del Front End le istruzioni devono essere eseguite efficacemente
per liberare le risorse che questi deve alimentare e dirimere le diramazioni.
Multiple issue (processori superscalari)
La seconda strategia di ILP dinamico prevede l’utilizzo di più unità di
esecuzione indipendenti che eseguano istruzioni in parallelo. Questa tecnica
viene detta multiple issue e il suo svantaggio principale è una maggior
complessità del processore. Oltre alla presenza di più unità di calcolo, il
processore deve disporre di un bus interno ampio, capace di trasportare i dati tra
le varie unità senza colli di bottiglia. Inoltre le singole unità funzionali come le
cache devono poter rilasciare più dati in parallelo e gli stessi registri devono
poter leggere e scrivere più dati in parallelo.
Le architetture in grado di eseguire più istruzioni in parallelo sono dette
superscalari, e l’analisi del parallelismo a livello di istruzione per questa
tipologia di processori è ovviamente fondamentale.
Cenni storici
Le architetture superscalari ebbero origine nell’ambiente RISC, dato che questo
tipo di design richiede unità funzionali semplici, che possono essere incluse in

Modifiche architetturali per il miglioramento delle prestazioni 57
più esemplari in una unica CPU. Questa è la ragione per cui questi processori
erano più veloci dei CISC tra gli anni ‘80 e gli anni ‘90. Tuttavia, col progresso
della tecnologia, anche design ingombranti come l’IA-32 poterono essere
progettati in modo superscalare.
Punti Deboli
Osserviamo innanzitutto che il numero e la tipologia di unità funzionali possono
limitare il numero di esecuzioni contemporanee: banalmente se il processore è
dotato di quattro unità di calcolo, questo non potrà eseguire più di quattro
istruzioni in parallelo anche se nel codice fossero presenti più istruzioni
eseguibili in parallelo.
Le unità di controllo, ovvero quelle che stabiliscono quali istruzioni possono
essere eseguite in parallelo e le inviano alle rispettive unità, diventano critiche
in queste architetture. Il loro compito infatti non è semplice, dato che
un’istruzione può richiedere il risultato della precedente come proprio
operando, oppure può dover impiegare il dato conservato in un registro usato
anche dall’altra istruzione; il risultato può quindi cambiare secondo l’ordine
d’esecuzione delle istruzioni. La maggior parte delle CPU moderne dedica un
elevato numero di transistor allo svolgimento di questo compito, per permettere
al processore di funzionare a pieno regime in modo costante; compito che si è
reso sempre più importante con l’aumento del numero delle unità. Mentre le
prime CPU superscalari possedevano due ALU ed una FPU, processore del
2003 come ad esempio il PowerPC 970 possedeva già quattro ALU, due FPU e

58 Capitolo 3
due unità SIMD. Se l’unità di decodifica delle istruzioni non mantiene occupate
tutte le unità funzionali del processore, le prestazioni ne soffrono grandemente.
Evoluzioni
Attualmente è impensabile un futuro miglioramento sensibile del sistema di
controllo, ponendo di fatto un limite ai miglioramenti prestazionali dei
processori superscalari. Il progetto VLIW (Very Long Instruction Word) cerca
una soluzione scaricando parte del processo di controllo delle istruzioni in fase
di scrittura del programma e di compilazione, evitando al processore di doverlo
ripetere ad ogni esecuzione del programma.
Un’altra evoluzione dei processori superscalari è l’integrazione di più
processori indipendenti (core) in un singolo processore, come presenteremo nel
paragrafo (3.2.3). Un approccio intermedio prevede una separazione logica e
non fisica delle pipeline con le pipeline separate ma i circuiti di controllo e
gestione ancora in comune. Si parla in questo caso si Multi Thread e verrà
illustrata nel paragrafo (3.2.2).
La realizzazione di processori multi core e multi threading sono una soluzione
migliore rispetto alla semplice aggiunta di nuove unità pipeline dato che ogni
nuova pipeline aumenta la possibilità di eseguire istruzioni che siano in conflitto
con altre e quindi spingersi oltre quattro pipeline risulta spesso sconveniente.
Eseguendo più thread in parallelo si eliminano i problemi dati che i thread sono
separati e quindi le varie pipeline non possono entrare in conflitto tra di loro.
Questi processori però costringono i programmatori a realizzare programmi
paralleli per fruttare al meglio i processori moderni e la realizzazione di

Modifiche architetturali per il miglioramento delle prestazioni 59
programmi paralleli non è semplice ed per alcuni algoritmi non esistono
nemmeno metodi per renderli paralleli in modo efficiente.
Esecuzione fuori ordine
Tutti i processori moderni utilizzano le pipeline, le quali, quando si trovano in
presenza di alee sui dati o sul flusso di controllo, devono introdurre degli stalli
(detti anche bolle) per permettere la risoluzione delle alee stesse.
Il parallelismo delle istruzioni migliora pertanto se vengono ridotte le Alee. Una
tecnica per ridurle consiste nel riorganizzare le istruzioni opportunamente.
Consideriamo ad esempio il seguente codice:
Istruzione 1:
Istruzione 2:
Istruzione 3:
h = a + b
f = h + d
g = w * 100
La seconda istruzione dipende dal risultato della prima istruzione mentre la
terza istruzione è indipendente dalle altre. Eseguendo le istruzioni all’interno di
una pipeline a 5 stadi si avrebbe uno stallo (o due, a seconda di come viene
implementata la pipeline) tra la prima e la seconda istruzione. Riorganizzando
le istruzioni ed inviando alla pipeline la prima istruzione, poi la terza istruzione
(indipendente dalle altre) e infine la seconda istruzione, si ottiene un’esecuzione
senza stalli. Questa modalità di esecuzione viene detta out-of-order, dato che le
istruzioni vengono eseguite e completate fuori ordine rispetto al codice
sviluppato dal programmatore.

60 Capitolo 3
Figura 3.8 - Schema concettuale dell’esecuzione fuori ordine. Il programma viene
caricato come istruzioni seriali, le istruzioni vengono analizzate, riordinate tenendo
conto delle dipendenze, eseguite in parallelo, ed riordinate prima di provvedere al
salvataggio dei dati in memoria.
È ovvio che l’esecuzione fuori ordine è di per se stessa causa di abbandono
della logica sequenziale del programma che invece deve essere preservata.
Occorre perciò un meccanismo di emissione/completamento capace di garantire
che il risultato dell’esecuzione fuori ordine sia equivalente all’esecuzione
strettamente sequenziale.
Nel seguito vengono presentati i due principali metodi per la gestione
dell’esecuzione fuori ordine:
• Metodo del Reorder Buffer. Le istruzioni possono essere emesse in
ordine o fuori ordine e possono completare fuori ordine, ma sono
forzate a modificare lo stato della macchina in ordine. La tecnica si basa
sull’interposizione di un buffer tra l’unità di emissione e quella di

Modifiche architetturali per il miglioramento delle prestazioni 61
scrittura nei registri (o in memoria): le istruzioni completate vengono
ritirate dal buffer secondo l’ordine del programma.
• Metodo dell’History Buffer. Le istruzioni possono essere emesse in
ordine o fuori ordine e possono completare e aggiornare lo stato di
macchina in qualsiasi ordine, tuttavia viene conservata l’informazione
necessaria a ripristinare lo stato coerente in presenza di situazioni di
conflitto (salti e interruzioni).
Metodo del Reorder Buffer
Il metodo del Reorder Buffer (ROB), utilizzato in numerosi processori moderni,
permette alle istruzioni di essere eseguite fuori ordine, ma imponendo la
scrittura dei risultati in modo coerente rispetto al modello sequenziale. Il ROB è
un buffer interposto tra le unità funzionali e i registri, come mostrato in Figura
3.9.
Figura 3.9 - Organizzazione di una pipeline col metodo del Reordering Buffer

62 Capitolo 3
Lo schema di Figura 3.9 presuppone che i risultati prodotti dall’esecuzione delle
istruzioni vengano depositati nel ROB e da qui trasferiti ai registri. Più
specificatamente il ROB ha queste funzioni:
• tenere traccia dell’ordine naturale delle istruzioni. A tal fine, quando
un’istruzione viene emessa (in ordine) viene anche presa per essa,
sequenzialmente, una posizione nel ROB;
• servire da appoggio per i risultati delle istruzioni completate
(eventualmente fuori ordine);
• tenere traccia del completamento delle istruzioni, in modo da
permettere l’estrazione (ritiro) in ordine dei risultati delle istruzioni
completate.
Con lo schema di Figura 3.9, le istruzioni sono avviate alle unità funzionali solo
se esse non dipendono dai risultati delle istruzioni che ancora non sono uscite
dal ROB. Quando una istruzione viene avviata verso un’unità funzionale viene
presa per essa una posizione in ROB, secondo l’ordine testuale del programma.
Quando un’istruzione termina, il risultato da esso prodotto viene scritto nel
ROB. I risultati vengono estratti dal ROB (e scritti nei registri di destinazione)
prelevandoli dalla testa del ROB, in modo da mantenere l’ordine del
programma, garantendo così la coerenza tra lo stato macchina e il modello
sequenziale di esecuzione.
Il ROB è gestito come una coda circolare. A tale scopo sono richiesti due
puntatori: un puntatore di testa Pt e un puntatore di coda Pc. Sono considerate
valide le entrate che si trovano nelle posizioni comprese tra quella puntata da Pt

Modifiche architetturali per il miglioramento delle prestazioni 63
e quella puntata da Pc. Un elemento di ROB è costituito dalle 4 componenti {C,
PC, Rd, RIS}, dove:
C: bit di completamento; dice se l’istruzione ha completato la
fase di esecuzione;
PC: valore del program counter dell’istruzione;
Rd: identificatore (tag) del registro di destinazione;
RIS: risultato prodotto dall’istruzione
L’utilizzo del ROB, pur permettendo alle istruzioni di terminare la loro
esecuzione fuori ordine, forza lo stato del processore ad essere aggiornato
nell’ordine del programma. Di conseguenza, un’istruzione che prevede la lettura
di dati ancora in ROB, cioè non ancora scritti nei rispettivi registri di
destinazione, deve essere tenuta in stallo nel registro di emissione, bloccando
anche le istruzioni che la seguono. Ciò porta inevitabilmente alla riduzione delle
prestazioni.
Un metodo per ridurre questa penalizzazione consiste nel disporre di percorsi di
bypass che connettono gli elementi presenti all’interno del ROB con le uscite
del banco dei registri (Figura 3.10). In questo modo le istruzioni possono usare,
come operandi sia i dati contenuti nel banco dei registri, sia quelli che ancora si
trovano nel ROB, evitando l’attesa nel registro di emissione per la scrittura nel
banco dei registri. La presenza dei percorsi di bypass non impedisce che lo stato
della macchina sia coerente, dal momento che il banco dei registri, esattamente
come avviene in assenza dei percorsi di bypass, viene aggiornato in modo
coerente col modello sequenziale di esecuzione del programma.

64 Capitolo 3
Figura 3.10- Percorsi di by-pass e ROB. Essi rendendo immediatamente disponibili i
dati appena calcolati alle istruzioni in attesa di emissione, riducono al minimo il tempo
di permanenza delle istruzioni nel registro di emissione.
Una soluzione differente è quella di introdurre in ingresso alle unità funzionali
dei propri buffer 4
; questi consentono di parcheggiare eventuali istruzioni che
richiedono di leggere dati ancora non scritti, evitando lo stallo nel registro di
emissione.
Metodo dell’History Buffer
La gestione dell’esecuzione fuori ordine mediante l’uso di un History Buffer
(HB), ossia di un registro che tenga traccia dell’evoluzione dello stato della
macchina durante l’esecuzione di un programma, nasce dall’esigenza di
migliorare le prestazioni del ROB.
L’idea alla base del metodo è quella di permettere alle istruzioni di completare
l’esecuzione, permettendo la scrittura dei registri ma conservando abbastanza
informazioni sugli stati passati da poter ripristinare, in caso di necessità, lo stato
4 Questi registri sono chiamati “reservation stations”

Modifiche architetturali per il miglioramento delle prestazioni 65
appropriato. L’ History Buffer è un registro organizzato in modo assai simile al
ROB e inserito nell’ architettura come mostrato in Figura 3.11.
Figura 3.11- Organizzazione della pipeline con un History Buffer (HB) Esso entra in
gioco in caso di necessità, rimettendo i vecchi valori nei registri modificati
speculativamente. [8].
Quando un’istruzione viene inviata dall’unità di emissione a un’unità
funzionale, viene inserito un nuovo elemento in HB. HB è gestito come una
coda circolare, in modo analogo al ROB.
Un elemento di HB è costituito da 4 componenti: {C, PC, Rd, OLD}, dove C,
PC e Rd hanno lo stesso significato del caso del ROB, mentre la componente
OLD viene usata per tenere il valore contenuto in Rd al momento
dell’emissione dell’istruzione. In caso di necessità, questo valore viene riscritto
nel registro in modo da ripristinare una situazione di stato coerente.
Quando un’istruzione arriva in testa a HB col bit di completamento a l (ovvero
l’istruzione è stata eseguita) e non è sorta nessuna necessità di ripristinare lo
stato coerente, il corrispondente elemento in HB non è più necessario e viene
eliminato (aggiornando il Pt).

66 Capitolo 3
Poiché l’ordine di emissione garantisce la coerenza rispetto alle dipendenze dei
dati, i motivi per i quali si deve ripristinare lo stato corrente sono legati alle
previsioni di salto errate e alle interruzioni.
In presenza di interruzione, l’emissione di nuove istruzioni da parte dell’Issue
Register viene immediatamente bloccata. Sulla base del criterio di risoluzione
dell’interruzione, viene identificata l’istruzione in pipeline che discrimina quelle
che vengono portate a completamento da quelle che vengono. Le istruzioni che
devono completare scrivono su RF e vengono estratte da HB. Per le istruzioni
che seguono l’ultima da portare a termine, che fossero eventualmente
completate e avessero scritto il loro registro di destinazione, viene ripristinato il
vecchio valore prendendoli da HB. Servita l’interruzione, il programma riparte
dalla prima istruzione che non è stata fatta procedere.
Predizione dei salti
Per ridurre al minimo l’impatto delle alee di controllo, i microprocessori
includono quasi sempre una qualche tipologia di unità di predizione delle
diramazioni. Questa unità, tenendo traccia dei risultati delle istruzioni di salto
eseguiti, ogni volta in cui si incontrano delle istruzioni di salto cerca di
prevedere se il salto verrà eseguito o no. La predizione dei salti permette di
caricare in anticipo le istruzioni successive al salto e, nel caso di corretta
predizione del salto, il processore non deve bloccare o svuotare la pipeline.
Esistono molte tecniche per implementare la predizione dei saltati. Tecniche più
complesse portano ad ottenere percentuali di previsione migliori ma
comportano anche costi maggiori per via del maggior numero di transistor

Modifiche architetturali per il miglioramento delle prestazioni 67
impiegato e quindi spesso non viene utilizzata la migliore strategia di previsione
ma strategie più semplici e quindi più economiche da implementare.
Predizione elementare
I primi esemplari di SPARC e MIPS (due delle prime architetture RISC
commerciali) facevano una specie di predizione, molto elementare:
consideravano sempre il salto come “non accettato”, e decodificavano
l’istruzione seguente. L’operazione di salto veniva effettutata solo dopo che la
condizione veniva valutata.
Entrambe le CPU effettuavano questa "predizione" in fase di decodifica e
dedicavano al fetch delle istruzioni un solo ciclo di clock. In questo modo per
effettuare un salto servivano due cicli di clock, ma dopo il primo la CPU aveva
già effettuato il fetch dell’istruzione subito successiva al salto; piuttosto che
sprecare questo lavoro, entrambi i microprocessori eseguivano anche queste
istruzioni, avvantaggiandosi magari per fasi successive del lavoro.
Predizione statica
I processori che impiegano questa tecnica considerano sempre i salti verso la
parte precedente del codice come “accettati” (ipotizzando che siano le istruzioni
riguardanti un ciclo) e i salti in avanti sempre come “non accettati” (ipotizzando
che siano uscite precoci dal ciclo o altre funzioni di programmazione
particolari). Per cicli che si ripetono molte volte, questa tecnica fallisce solo alla
fine del ciclo.

68 Capitolo 3
La predizione statica è usata come “paracadute” quando non ci sono elementi
per usare altre tecniche come la predizione dinamica e il processore deve andare
“alla cieca”.
Predizione della linea successiva
Alcuni processori superscalari (es.: MIPS R8000 e DEC Alpha EV6/EV8)
eseguivano il fetch di una linea di istruzioni, anche il puntatore alla linea
successiva. Questo metodo è piuttosto diverso dagli altri trattati, perché esegue
sia la previsione del salto, che la previsione della direzione del salto stesso.
Quando un puntatore indica un gruppo di 2, 4 o 8 istruzioni, solitamente
l’istruzione ricercata non è la prima (per un fatto statistico), così la scansione
delle prime istruzioni è tempo perso. Generalizzando, vengono scartate
rispettivamente 0,5, 1,5 e 3,5 istruzioni decodificate. Lo stesso discorso vale per
le istruzioni successive all’istruzione di salto, che devono essere scartate con
identica distribuzione media.
Le istruzioni scartate dall’unità di predizione fanno guadagnare quasi un
completo ciclo di fetch, anche con predizioni eseguite solo sulla linea
successiva e in un solo ciclo di clock.
Un esempio di processore che utilizza la predizione della linea successiva è il
Pentium ® 4.
Predizione dinamica
Una possibilità consiste nel verificare l’indirizzo dell’istruzione per controllare
se l’ultima volta che si era considerata quell’istruzione il salto fosse stato
eseguito: in caso positivo, si caricano le istruzioni successive a partire dalla

Modifiche architetturali per il miglioramento delle prestazioni 69
stessa posizione della volta precedente. Questa tecnica viene chiamata
predizione dinamica dei salti.
Un modo per implementare questa strategia consiste nell’utilizzare un buffer di
predizione dei salti (branch prediction buffer), o tabella di storia dei salti
(branch history table) . Un buffer di previsione dei salti è una piccola memoria
indicizzata attraverso la parte bassa dell’indirizzo dell’istruzione di salto. La
memoria contiene un bit che indica se recentemente il salto è stato eseguito o
meno.
Questo semplice schema a un bit ha dei problemi di prestazioni: anche se un
salto è quasi sempre preso, lo prediremo probabilmente due volte in maniera
scorretta, piuttosto che una volta, quando è effettivamente non preso.
Si consideri, ad esempio, un salto condizionato presente all’interno di un ciclo,
e si supponga che il salto venga eseguito nove volte di seguito, e poi non venga
eseguito per una volta. A regime la previsione non sarà corretta nella prima e
nell’ultima iterazione del ciclo. L’errore sull’ultima iterazione è inevitabile in
quanto la previsione dirà che il salto deve essere eseguito, essendo stato
eseguito nove volte di seguito fino a quel punto. L’errore sulla prima iterazione
si verifica perché il bit è stato complementato in occasione dell’esecuzione
dell’ultima iterazione del ciclo, quando il salto non era stato eseguito. Di
conseguenza l’accuratezza della previsione per questo salto (che viene eseguito
nel 90% dei casi) è pari all’8O% (due previsioni sbagliate e otto corrette).

70 Capitolo 3
Predizione bimodale
Questa tecnica è una evoluzione della precedente e migliora i salti altamente
regolari. In linea di principio si vorrebbe che per questi salti l’accuratezza della
predizione corrispondesse alla frequenza di esecuzione del salto. Per rimediare a
questa mancanza si usano spesso degli schemi di previsione a 2 bit. In uno
schema a 2 bit la predizione deve essere sbagliata per due volte prima di essere
modificata. La Figura 3.12 mostra la macchina a stati finiti relativa a questo
schema di previsione.
Un buffer di predizione dei salti può essere realizzato come un piccolo buffer
accessibile tramite l’indirizzo dell’istruzione durante lo stadio di fetch della
pipeline. Se si predice che il salto debba venire eseguito il caricamento viene
effettuato a partire dall’indirizzo destinazione non appena è noto il valore del
PC; come detto in precedenza questo può avvenire già nello stadio di
decodifica, in caso contrario il caricamento e l’esecuzione in sequenza
continuano. Se la predizione si rivela sbagliata i bit di predizione sono
modificati come mostrato nella Figura 3.12.
Un pregio di questo sistema è che i cicli vengono sempre accettati, e viene
fallita solo la previsione relativa all’uscita del ciclo, mentre un sistema con
contatori a bit singolo fallisce sia la prima che l’ultima istruzione.
Esempi di unità di predizione molto grandi basate su questo sistema hanno
ottenuto una percentuale di successo pari al 93,5% su benchmark SPEC.

Modifiche architetturali per il miglioramento delle prestazioni 71
Predizione locale
Preso
Strongly taken
(preso molto spesso)
Preso
Weakly not taken
(non preso poco spesso)
Non preso
Preso
Non preso
Preso
Weakly taken
(preso poco spesso)
Non preso
Strongly not taken
(non preso molto spesso)
Non Preso .
Figura 3.12- Gli stati possibili della predizione bimodale
La predizione bimodale fallisce all’uscita di ogni ciclo: per cicli che si ripetono
con andamento sempre simile a sé stesso si può fare molto meglio.
Con questo metodo ci si avvale di due tabelle. Una è indicizzata con i bit meno
significativi dell’istruzione relativa, e tiene traccia della condizione nelle ultime
n esecuzioni. L’altra è una tabella molto simile a quella usata nella predizione
bimodale, ma è indicizzata sulla base della prima. Per effettuare una predizione,
l’unità cerca, grazie alla prima tabella, la parte della seconda che tiene traccia
del comportamento della condizione non in media, ma a quel punto del ciclo.
Sui benchmark SPEC, sono stati ottenuti risultati intorno al 97,1%.
Questa tecnica è più lenta perché richiede il controllo di due tabelle per
effettuare ogni previsione. Una versione più veloce organizza un insieme
separato di contatori bimodali per ogni istruzione a cui si accede; in questo
modo il secondo accesso all’insieme può procedere in parallelo con l’accesso

72 Capitolo 3
all’istruzione. Questi insiemi non sono ridondanti, in quanto ogni contatore
traccia il comportamento di una singola condizione.
Predizione globale
Nella predizione globale si fa affidamento sul fatto che il comportamento di
molte condizioni si basa su quello di condizioni vicine e valutate da poco. Si
può così tenere un unico registro che tiene conto del comportamento di ogni
condizione valutata da poco, e usarne i valori per indicizzare una tabella di
contatori bimodali. Questo sistema è di per sé migliore della predizione
bimodale solo per grandi tabelle, e non è migliore della predizione locale in
nessun caso.
Se invece si indicizzano i contatori bimodali con la storia recente delle
condizioni concatenata ad alcuni bit dell’indirizzo delle istruzioni si ottiene un
previsore gselect, che supera la previsione locale in tabelle piccole e viene
staccato di poco in tabelle maggiori di un KB.
Si ottiene un metodo ancora migliore per le tabelle più grandi di 256 B, detto
gshare, sostituendo nel gselect la concatenazione con l’operazione logica XOR.
Quest’ultimo metodo ottiene nei benchmark un’efficienza del 96,6%, di poco
inferiore alla predizione locale.
Le predizioni globali sono più facili da rendere più veloci della predizione
locale in quanto richiedono in controllo di una sola tabella per ogni previsione.
Esistono altre tipologie di predizioni ma sono tecniche che richiedono un
dispendio di transistor eccessivo per le prestazioni che effettivamente offrono.
Data l’importanza delle predizione dei salti comunque tutti i processori moderni

Modifiche architetturali per il miglioramento delle prestazioni 73
implementano unità di predizione dei salti molto avanzate. Per esempio il
POWER 5 prodotto da IBM implementa tre unità di predizione dei salti. Due
unità cercano di predire i salti utilizzando strategie diverse e la terza unità tiene
traccia delle percentuali di successo delle due unità e a seconda dell’istruzione
sceglie l’unità che ha avuto la percentuale di successo maggiore.
Esecuzione speculativa
Per ridurre il problema delle alee di controllo, alcuni processori implementano
un espediente chiamato esecuzione speculativa. Supponendo che un salto
condizionato dipenda da dei dati non ancora elaborati, sulla base della storia
passata dell’istruzione di salto il processore effettua una previsione sul risultato
del salto (speculano sul possibile risultato) e carica le istruzioni conseguenti la
previsione. Questa tipologia di esecuzione richiede molti transistor per essere
implementata perché oltre all’unita di speculazione bisogna tener traccia delle
istruzioni in esecuzioni che dipendono dalla speculazione e, in caso di errata
previsione, queste istruzioni vanno eliminate, mentre i loro effetti sui dati
devono essere annullati.
Ridenominazione dei registri:
Alcune alee dipendo dal fatto che più istruzioni utilizzano gli stessi registri o le
stesse locazioni di memoria, ad esempio per scrivere i risultati
dell’elaborazione. Le due istruzioni seguenti:
Istruzione 1:
Istruzione 2:
h = a + b
h =
c − d

74 Capitolo 3
sono dal punto di vista dei dati indipendenti, ma non possono essere scambiate
dato che entrambe scrivono i risultati in h; invertendo le istruzioni alla fine
dell’elaborazione si troverebbe il valore calcolato da “ a + b ” e non “ c − d ”,
ottenendo un’esecuzione errata del programma. Questa non è una vera alea dei
dati, visto che in realtà le due istruzioni non sono realmente limitate dai dati ma
sono limitate dai registri nei quali salvare i dati.
I microprocessori possono allora implementare la cosiddetta “ridenominazione
dei registri”: in sostanza si introducono dei registri temporanei che vengono
utilizzati per salvare i dati temporaneamente, in modo da poter eseguire le
istruzioni in modo indipendente; alla fine dell’esecuzione sarà l’unità di
ridenominazione a salvare nei registi reali i dati corretti. Nell’esempio visto
sopra, il codice diverrebbe:
Istruzione 1:
Istruzione 2:
Temp = a + b
Temp
1
2
= c − d
Ciascuna istruzione salva i dati in un registro temporaneo, e quindi le due
istruzioni possono essere eseguite in parallelo tanto alla fine l’unità di
ridenominazione provvederà a memorizzare in sequenza i dati nel registro h
mantenendo la coerenza logica del programma. Lo scheduling dinamico della
pipeline e la ridenominazione dei registri permette di eliminare la maggior parte
delle alee riducendo significativamente gli stalli nelle pipeline. L’utilizzo di
queste tecniche viene governato dall’algoritmo di Tomasulo o da sue varianti
più moderne e efficienti.

Modifiche architetturali per il miglioramento delle prestazioni 75
Srotolamento dinamico del loop
Spesso i programmi sono formati da gruppi di istruzioni che vengono eseguite
più volte in sequenza. Utilizzando le unità di scheduling dinamico della pipeline
e di ridenominazione dei registri, i processori possono eseguire alcune istruzioni
dei vari cicli in parallelo e possono eliminare alcuni salti condizionati.
Consideriamo per esempio il codice:
Istruzione 1:
Istruzione 2:
Istruzione 3:
Istruzione 4:
a = 0
FOR a <
END
dopo lo srotolamento del loop ottengo:
Istruzione I:
Istruzione II:
Istruzione III:
Istruzione IV:
Istruzione V:
a = 0
2
k = k − d
a = a + 1
FOR
k = k − d
a = a + 1
k = k − d
a = a + 1
Senza srotolamento il processore dovrebbe eseguire 8 istruzioni (1 2 3 4 2 3 4
2), delle quali tre sono salti condizionati (l’istruzione 2). Dopo lo srotolamento
ottengo 5 istruzioni, i salti sono stati eliminati e le istruzioni possono essere
eseguite dalla pipeline senza stalli.

76 Capitolo 3
ILP STATICO
ILP statico a differenza dell’ILP dinamico viene eseguito durante la fase di
compilazione del codice, il compilatore analizza il codice rilevando le istruzioni
parallelizzabili e le segnala in modo che durante l’esecuzione il processore
sappia già quasi istruzioni sono parallelizzabili e come vadano eseguite. L’ILP
statico è particolarmente utilizzato dai processori embedded che per questioni di
costo e di consumi non possono implementare i complessi metodi di analisi
richiesti dall’ILP dinamico. Comunque l’ILP statico viene utilizzato in qualche
modalità anche dai processori ad alte prestazioni: la famiglia di processori
Itanium, ad esempio è basata su questa filosofia.
ILP statico, come l’ILP dinamico, cerca di massimizzare le prestazioni
utilizzando al massimo le pipeline minimizzandone gli stalli; questo viene
ottenuto riorganizzando le istruzioni in un modo simile a quanto fa l’ILP
dinamico. Il compilatore per poter produrre del codice efficiente deve conoscere
nel dettaglio le caratteristiche del processore; deve conoscere dettagli come la
lunghezza delle pipeline, la loro organizzazione, i tempi di esecuzione, etc. Due
processori con identico set di istruzioni (ISA) ma con diversa microarchitettura,
eseguendo lo stesso codice con ottimizzazioni statiche, possono fornire
prestazioni molto diverse. Un cambio di microarchitettura può richiedere una
ricompilazione del codice per poter sfruttare le reale prestazioni del
microprocessore, cosa non necessaria con l’ILP dinamico.

Modifiche architetturali per il miglioramento delle prestazioni 77
L’ILP statico utilizza molte tecniche di analisi e di ottimizzazioni comuni a
l’ILP dinamico ma non dovendo eseguire le ottimizzazioni in tempo reale le
analisi possono essere molto più approfondite e quindi ottenere prestazioni
migliori. Per esempio nel caso della tecnica di srotolamento dei loop il
compilatore analizzando il codice può riconoscere i loop e ottimizzandolo. Per
esempio supponendo di avere del codice del tipo:
Istruzione 1:
Istruzione 2:
Istruzione 3:
Istruzione 4:
i = 0
FOR 1<
1000
END
x [ i]
= x[
i]
+ s
i = i + 1
FOR
Il compilatore riconoscendo il codice potrebbe notare che il loop viene eseguito
mille volte e dato che la parte critica è il salto condizionato (istruzione 2)
potrebbe scrivere:
Istruzione 1:
Istruzione 2:
Istruzione 3:
Istruzione 4:
Istruzione 5:
Istruzione 6:
i = 0
FOR 1<
1000
x [ i]
= x[
i]
+ s
i = i + 1
x [ i]
= x[
i]
+ s
i = i + 1
END
FOR

78 Capitolo 3
Questo loop viene eseguito solo 500 volte dato che dentro un singolo loop sono
state inserite le istruzioni che precedentemente venivano eseguite in due loop. Il
procedimento può essere iterato includendo altre istruzioni, riducendo così il
numero di salti da eseguire; i salti infatti sono delle istruzioni che, dal punto di
vista del programma, non producono risultati utili, in quanto non influenzano
direttamente i dati ma solo il flusso del programma stesso. Il codice generato
dallo srotolamento del loop può essere migliorato eseguendo una
ridenominazione dei registri e una riorganizzazione delle istruzioni che migliora
le prestazioni. Per esempio il codice iniziale eseguito su un processore MIPS
senza nessuna ottimizzazione richiede 10 cicli di clock per ogni loop;
applicando le varie ottimizzazioni si ottiene un’esecuzione in 3.5 cicli di clock
per ogni loop. Il compilatore quando applica queste tecniche deve tenere conto
anche dei problemi che queste portano. Lo srotolamento del loop aumenta la
dimensione del codice e quindi la possibilità di non trovare i dati in cache;
inoltre un eccessivo uso della ridenominazione dei registri può terminare i
registri temporanei costringendo il processore a utilizzare la lenta memoria di
sistema per salvare i registri non usati.
L’ILP statico ovviamente cerca di sfruttare la presenza di più unità di calcolo:
nell’esempio del loop, supponendo di avere un processore con due pipeline
indipendenti, si potrebbe ridurre il tempo di esecuzione da 3,5 cicli di clock per
loop a 2,5 cicli di clock per loop.

Modifiche architetturali per il miglioramento delle prestazioni 79
I processori che utilizzano l’ILP statico utilizzano generalmente meglio le
pipeline: il compilatore infatti può analizzare il codice in profondità e cercare
l’organizzazione migliore delle istruzioni che ne massimizza l’utilizzo.
Spesso questi compilatori raggruppano le istruzioni in pacchetti che, una volta
ricevuti dal processore, vengono semplicemente inviati alle pipeline; il
processore non deve controllare alee o altro dato perché tutto è stato analizzato
dal compilatore e gli eventuali problemi sono già stati risolti. Questi processori
sono detti processori Very Long Instruction Word (VLIW).
Nei processori VLIW il compilatore esegue tutte le ottimizzazioni mentre il
processore non fa altro che ricevere le istruzioni ed eseguirle quindi un
processore VLIW è molto più semplice di un processore con ILP dinamico di
pari velocità.
Dipendendo in modo totale dal compilatore per le prestazioni, i compilatori
utilizzano tecniche di analisi avanzate del codice per individuare il parallelismo
intrinseco. Le principali sono:
Tecniche predicative
Le tecniche di analisi del codice funzionano bene quando si riesce a prevedere
con un elevato margine di accuratezza il comportamento dei salti condizionati. I
salti condizionati sono molto frequenti nel codice (mediamente ogni 7-10
istruzioni si ha un salto) e possono ridurre le prestazioni delle architetture a
pipeline in modo rilevante. Le tecniche di analisi statistiche funzionano bene nel

80 Capitolo 3
caso di istruzioni di salto che si ripetono in modo regolare (per esempio nei
cicli) mentre negli altri casi i salti sono difficilmente prevedibili. Per limitare
l’impatto di questi salti si possono utilizzare le istruzioni predicative (o
condizionate). Le istruzioni predicative convertono una dipendenza dal
controllo in una dipendenza sui dati eliminando in alcuni casi dei salti
condizionati difficilmente prevedibili. Le istruzioni predicative sono delle
normali istruzioni che però vengono eseguite se una certa condizione è vera (o
falsa a seconda dei casi). L’esempio più semplice (e comune) è la “move
condizionata”. Questa istruzione copia il valore di un registro in un altro
registro se la condizione associata è vera. Per esempio il codice
if (A == 0) H = J
verrebbe tradotto senza istruzioni condizionate come:
Istruzione 1:
Istruzione 2:
Se
h =
Istruzione 3: …
a = 0
Con le istruzioni condizionate invece ottengo
Istruzione 1:
j
salta a (2)
a = 0 allora h = j 5
altrimentisalta
a (3)
Il nuovo codice utilizza una sola istruzione quindi è più compatto ed inoltre
elimina un salto; invece di un’istruzione di salto e di una “move” ho solo una
5 Si parla di istruzioni predicative in quanto la condizione di salto è stata sostituita da un
predicato associato alla istruzione. In questo caso il predicato è la condizione sulla
variabile “a”.

Modifiche architetturali per il miglioramento delle prestazioni 81
“move condizionata” che dipende unicamente dai dati: ho eliminato l’istruzione
di salto che, essendo singola e non legata a una qualche logica, è difficile da
prevedere. Questa strategia può essere estesa includendo praticamente tutte le
istruzioni del processore; i processori Itanium per esempio possiedono istruzioni
predicative che possono sostituire tutte le istruzioni classiche (il processore è
del tipo “full predication”). Comunque la maggior parte dei processori si limita
alle “move predicative” dato che negli altri casi l’utilizzo di istruzioni
predicative aumenta la dimensione del processore senza necessariamente
incrementare le prestazioni dello stesso.
Le “move predicative” sono talmente utili che anche molti processori che
implementano sofisticate tecniche di ILP dinamico utilizzano anche questa
tecnica per migliorare le prestazioni.
L’approccio delle “istruzioni predicative” parte dalla constatazione che i
microprocessori moderni sono dotati di molte unità funzionali in grado di
eseguire operazioni in parallelo ma queste unità sono quasi sempre vuote.
Processori anche molto complessi come il Pentium ® 4 pur potendo in teoria
eseguire fino a 6 operazioni in contemporanea in realtà per la maggior parte del
tempo eseguono una o due operazioni in parallelo. L’approccio predicativo
punta a riempire al massimo le unità di elaborazioni eliminando poi in seguito le
istruzioni eseguite ma non necessarie.

82 Capitolo 3
Very Long Instruction Word
Le architetture Very Long Instruction Word sono basate sull’utilizzo del
parallelismo intrinseco presente delle istruzioni. Similmente ai microprocessori
superscalari queste CPU sono dotate di più unità di calcolo indipendenti (per
esempio due moltiplicatori) per permettere alla CPU di eseguire più calcoli
contemporaneamente (per esempio due moltiplicazioni).
Progetto
In un progetto superscalare il numero di unità di calcolo non è visibile nel set di
istruzioni. Ogni istruzione codifica una sola istruzione, e per molti
microprocessori sono lunghe 32 bit o meno.
Invece ogni istruzione VLIW codifica più istruzioni elementari specificando
una istruzione per ogni unità di calcolo. Per esempio un dispositivo VLIW con
5 unità di calcolo sarà dotato di istruzioni con cinque campi, ognuno specifico
per ogni unità di calcolo. Ovviamente le istruzioni VLIW sono molto più lunghe
delle classiche istruzioni: sono lunghe almeno 64 bit ma spesso sono di 128 bit
o più.
Sin dalle prime architetture ci si è resi conto che aggiungendo unità di calcolo
alle macchine si potevano incrementare le prestazioni senza aumentare i costi in
maniera eccessiva. Nelle CPU superscalari è la CPU stessa che durante
l’esecuzione decide dinamicamente quali istruzioni mandare in esecuzione in
parallelo. nelle CPU VLIW è il compilatore che durante la fase di traduzione
decide quali istruzioni vadano eseguite in parallelo.

Modifiche architetturali per il miglioramento delle prestazioni 83
Per esempio, una CPU può essere in grado di eseguire due moltiplicazioni
contemporaneamente. Supponendo che la CPU riceva le due moltiplicazioni, la
prima sarà mandata in esecuzione nella prima unità ma se la seconda
moltiplicazione dipendesse dal risultato della prima questa non potrebbe essere
mandata in esecuzione e al suo posto verrebbe effettuato un blocco in hardware.
In un’istruzione VLIW il compilatore individuerebbe il conflitto e introdurrebbe
una NOP per la seconda unità di calcolo. Questo riduce la complessità della
CPU.
Inoltre un compilatore VLIW può riconoscere il problema delle due
moltiplicazioni e quindi anticipare una istruzione che non ha precondizioni per
poter incrementare le prestazioni della CPU evitando l’utilizzo dell’istruzione
NOP. Un simile approccio viene seguito anche da alcune CPU superscalari
moderne che però, dovendo eseguire queste decisioni in tempo reali, forniscono
un modesto miglioramento delle prestazioni a fronte di un importante
incremento della complessità del progetto.
Un simile problema si presenta se il risultato di un’istruzione viene utilizzato
per definire se uscire da un ciclo o no. Molte CPU moderne scelgono in anticipo
un percorso in modo da poter caricare i dati corrispondente. Alcune CPU sono
dotate di una unità di predizione delle diramazioni che effettua una analisi del
codice per prevedere la diramazione più probabile. Questi metodi incrementano
la complessità del progetto e corrompono la filosofia originaria delle
architetture RISC anche perché la CPU deve contenere anche l’elettronica che

84 Capitolo 3
in caso di errore della predizione elimina le istruzioni in esecuzione e elimina le
eventuali modifiche già eseguite.
In un’architettura VLIW il compilatore utilizza delle euristiche o dei profili per
predeterminare in anticipo il ramo più probabile. Avendo il compilatore molto
più tempo della CPU e la possibilità di analizzare tutto il codice invece che solo
qualche istruzione, le sue previsioni sono molto più precise di quelle effettuate
da una CPU in tempo reale. Comunque il compilatore sviluppa il codice con il
ramo più probabile già codificato nel codice e fornisce anche il codice per
eliminare le istruzioni già eseguite nel caso la previsione non sia quella corretta.
Problematiche
Il principale problema di questa architettura è l’estrema dipendenza dei
programmi dal compilatore. Un programma ottimizzato per un processore
VLIW per lavorare in modo efficiente sulla generazione successiva di
microprocessori va quasi sempre ricompilato. Questo rende problematico per un
utente cambiare il computer, dato che anche il suo parco software andrebbe
adattato al nuovo processore, a meno che i programmi non siano scritti con un
linguaggio come il Java che, essendo in realtà compilato durante l’esecuzione,
possa essere adattato alla macchina durante l’esecuzione. Un’altra strategia è
utilizzare uno strato software che interpreti il vecchio codice e lo adatti al nuovo
processore ma in questo caso si ha un deperimento delle prestazioni che può
essere anche molto marcato. Questa strategia viene utilizzata per esempio dal
processore Efficeon della Transmeta che interpreta codice Intel ® x86 standard e
internamente lo traduce in codice VLIW per la CPU.

Modifiche architetturali per il miglioramento delle prestazioni 85
Evoluzioni
L’architettura VLIW ha indubbiamente molti vantaggi ma i suoi problemi ne
rendono problematico l’utilizzo in processori per computer. La necessita di
ricompilare il codice per ogni generazione di processori in particolare si scontra
con la necessita degli utenti di poter mantenere il parco software. Per eliminare
questi problemi diverse società hanno sviluppato delle evoluzioni
dell’architettura VLIW, tra le varie evoluzioni la più famosa è l’architettura
EPIC sviluppata da Intel ® e Hewlett-Packard ® congiuntamente di cui
accenneremo nel paragrafo 5.4.4. L’architettura EPIC (Explicitly Parallel
Instruction Computing) raggruppa le istruzioni elementari in parole come una
classica architettura VLIW e inserisce inoltre delle informazioni sul
parallelismo tra le varie parole. In questo modo le varie generazioni del
processore possono variare internamente la loro architettura senza troppi
problemi. Le informazioni sul parallelismo permettono di realizzare unità di
decodifica che sfruttano il parallelismo efficientemente ma sono nel contempo
semplici dato che l’analisi del codice parallelo e la sua suddivisione è stata
effettuata dal compilatore.
Caricamento speculativo
Nei primi capitoli abbiamo visto come i processori siano diventati sempre più
veloci e nel giro di un decennio siano passati da frequenze di poche decine di
Megahertz a frequenze di funzionamento dell’ordine dei Gigahertz. Le memorie
invece non sono diventate altrettanto veloci.

86 Capitolo 3
Figura 3.13 - Crescita del GAP tra la velocità delle memorie e delle CPU
I processori per limitare il problema hanno implementato cache di primo,
secondo e a volte anche di terzo livello. La presenza delle cache con gli ultimi
processori non è più sufficiente per evitare un eccessivo deperimento delle
prestazioni.
Un metodo per migliorare le prestazioni può essere allora quello del
“caricamento speculativo”: il compilatore, analizzando il codice, potrebbe
individuare delle istruzioni o dei dati che probabilmente verranno richiesti e
quindi porre delle load speculative. Queste load caricano i dati o le istruzioni
prima della loro effettiva richiesta eliminando o comunque limitando i tempi di
caricamento dalla memoria.
Il precaricamento dei dati e delle istruzioni introduce dei problemi.
Ad esempio se i dati caricati venissero modificati prima del loro reale utilizzo.
Occorre allora che, in tutti i casi di scrittura, il processore controlli se le celle
scritte erano state caricate in modo speculativo e in tal caso eliminarle in modo
da evitare incoerenze di esecuzione.

Modifiche architetturali per il miglioramento delle prestazioni 87
Se invece il microprocessore carica delle istruzioni dipendenti da un salto e quel
salto non viene eseguito, il processore deve provvedere ad eliminare le
istruzioni caricate erroneamente prima di caricare le istruzioni da eseguire.
Problemi anche maggiori si hanno nel caso di generazione di un’eccezione, per
esempio l’accesso a una locazione non consentita genera una eccezione che va
segnalata al sistema operativo, ma la segnalazione va effettuata quando
dovrebbe effettivamente avere luogo e non prima per via del precaricamento.
Questi problemi rendono il precaricamento dei dati e delle istruzioni molto
complesso da implementare in hardware senza un supporto diretto del set di
istruzioni. Invece se il set di istruzioni supporta nativamente questa
caratteristica la sua gestione diventa molto più semplice.
Altre tecniche di ottimizzazione
Static branch prediction
Il compilatore cerca di prevedere il risultato dei salti (branch) tramite analisi
statistiche del codice in modo da mantenere le pipeline sempre cariche. Queste
tecniche ricalcano quelle applicate dai processori con ILP dinamico ma in
questo caso forniscono mediamente prestazioni inferiori dato che il processore è
in grado di adeguarsi all’esecuzione dinamica del programma mentre il
compilatore non può prevedere come il programma si comporterà durante
l’esecuzione.
Loop Level Parallelism.

88 Capitolo 3
Questa tecniche cerca di individuare il parallelismo tra iterazioni successive del
loop nel caso di loop con cicli non indipendenti.
Symbolic loop unrolling.
Con questa tecnica si decide di non srotolare i loop ma di aggiungervi
all’interno delle istruzioni indipendenti in modo da evitare stallo durante
l’esecuzione.
Global code scheduling.
Questa tecnica analizza il codice alla ricerca di istruzioni indipendenti;
l’esplorazione prosegue anche se il compilatore trova delle istruzioni
condizionate (come salti o cicli).
3.2.2 Multithreading
Un altro modo per parallelizzare l’esecuzione di codice è quello di suddividere
il programma in thread, ovvero due o più task che possono essere eseguiti in
modo concorrente. L’implementazione dei thread e dei processi viene gestita in
modo diverso a seconda del sistema operativo ma, in generale, si può dire che
un thread è contenuto all’interno di un processo e che diversi thread contenuti
nello stesso processo condividono alcune risorse (spesso la memoria del
computer), mentre processi differenti non condividono risorse.
La suddivisione dei programmi in thread può essere utilizzata sia in architetture
multiprocessore che a singolo processore.

Modifiche architetturali per il miglioramento delle prestazioni 89
Nelle architetture a processore singolo quando la CPU esegue alternativamente
istruzioni di thread differenti si parla di multithreading a divisione di tempo. La
commutazione fra i thread avviene di solito tanto frequentemente da dare
all’utente l’impressione che tutti i task siano eseguiti contemporaneamente.
Nelle architetture multi-processore i thread vengono invece realmente eseguiti
contemporaneamente, ciascuno su un distinto processore.
Figura 3.14 - Un processore single thread esegue un solo thread per volta
Figura 3.15 -Un sistema multiprocessore classico esegue un thread per unità di calcolo

90 Capitolo 3
Figura 3.16 - Un sistema superthreading schedula più thread ma ne esegue uno solo
per ciclo di clock
CENNI STORICI
Il paradigma del multithearding è diventato molto popolare verso la fine degli
anni novanta quando le ricerche sull’incremento dell’Instruction Level
Parallelism si sono bloccate. Allora l’attenzione si è spostata dall’eseguire un
singolo programma alla massima velocità, all’occupare con la massima
efficienza possibile le unità di calcolo. Si è appurato che molti programmi erano
composti da più thread paralleli o potevano essere scomposti in più thread
paralleli con lievi modifiche al codice sorgente. Quindi migliorando
l’esecuzione di thread paralleli si poteva migliorare l’esecuzione complessiva
dei programmi. Questo ha spinto lo sviluppo dei sistemi multithreading e dei
sistemi multiprocessore.

Modifiche architetturali per il miglioramento delle prestazioni 91
TIPI DI MULTITHREADING
Possiamo individuare tre tipologie di Multithreading:
• Coarse-Grained Multithreading (CMT)
• Fine-Grained Multithreading (FMT)
• Simultaneous Multithreading (SMT)
COARSE-GRAINED MULTITHREADING
Idea di base
Il multithreading coarse-grained (a grana grossa) è detto anche Block or
Cooperative multithreading.
Esso prevede che il processore esegua un singolo thread fino a quando questo
non viene bloccato da un evento che normalmente ha una elevata latenza (per
esempio un cache miss), in questo caso il processore provvede a eseguire un
altro thread che era pronto per l’esecuzione. Il thread di rimpiazzo rimane in
esecuzioni fino a quando il primo thread non è pronto per l’esecuzione.
Per esempio:
Ciclo i : l’istruzione j del thread A viene caricata
Ciclo i+1 : l’istruzione j+1 del thread A viene caricata
Ciclo i+2 : l’istruzione j+2 del thread A viene caricata, il
caricamento provoca un cache miss con
corrispondente richiesta nella memoria centrale
Ciclo i+3 : il processore avvia l’esecuzione del thread B
Ciclo i+4 : l’istruzione k del thread B viene caricata
Ciclo i+5 : l’istruzione k+1 del thread B viene caricata

92 Capitolo 3
Costo hardware
Il multithreading parte dal presupposto che il passaggio tra thread avvenga in
modo rapido, questa tecnica effettua il passaggio in un ciclo di clock. Al fine di
ottenere questo risultato, il processore deve replicare alcune componenti per i
due thread come i registri interni, il program counter e alcuni registri di stato.
Anche gli adattamenti a livello software sono relativamente modesti dato che il
sistema operativo deve gestire un numero modesto di thread in esecuzione
contemporanea.
FINE-GRAINED MULTITHREADING
Idea di base
Questa tecnica di multithreading inizialmente venne chiamata “barrel
processing” ma attualmente la terminologia moderna definisce questa tecnica
come “pre-empiteve” o “interlaved” o “time-sliced” o “fine-grained
multithreading”.
Si tratta di una tipologia di multithreading molto spinto e prevede che il
processore scambi il thread in esecuzione a ogni ciclo di clock.
Per esempio:
Ciclo i : l’istruzione j del thread A viene caricata
Ciclo i+1: l’istruzione k del thread B viene caricata
Ciclo i+2: l’istruzione h del thread C viene caricata
Questa tipologia di mutithreading dovrebbe rimuovere la dipendenza dai dati
dei singoli thread e quindi dovrebbe azzerare o comunque ridurre gli stalli della
pipeline dovuta alla dipendenza dai dati. Dato che ogni thread dovrebbe

Modifiche architetturali per il miglioramento delle prestazioni 93
funzionare in modo indipendente, i singoli thread eseguiranno programmi non
correlati e quindi vi saranno poche probabilità che le istruzioni di un thread
necessitino dei risultati elaborati da un’istruzione di un altro thread in
esecuzione in quel momento.
Concettualmente questa tecnica è simile al “multitasking pre-emptive” presente
in molti sistemi operativi. Questa analogia parte dal presupposto che ogni slot di
tempo dei programmi sia posto uguale a un ciclo di clock del processore.
Costo hardware
In aggiunta alle componenti indicate precedentemente questa tecnica di
multithreading richiede delle componenti aggiuntive che assegnino a ogni
istruzione in esecuzione un’ID che ne permetta di identificare il thread
proprietario. Questa tecnica richiede che lo scambio tra i thread avvenga senza
cicli di clock di stallo e quindi richiede hardware più sofisticato; inoltre la
presenza di molti thread in esecuzione in parallelo, richiede generalmente cache
e TLB più capienti, al fine di poter servire i vari thread in modo efficiente.
SIMULTANEOUS MULTI-THREADING
Idea di base
Per distinguerlo degli altri tipi di multithreading il termine “temporal
multithreading” indica un tipo di multithreading che permette il completamento
di istruzioni di un solo thread per ciclo di clock.
I moderni processori hanno più unità di calcolo che vengono utilizzate
eseguendo le istruzioni dei singoli thread in parallelo. Gli attuali processori

94 Capitolo 3
sono in grado di eseguire solamente poche istruzioni in parallelo di un signolo
thread per via del ridotto parallelismo a livello di istruzioni che normalmente i
thread possiedono. Spesso perciò alcune unità di elaborazione rimangono
inutilizzate durante le elaborazioni. Per evitare questo, il Simultaneous Multi-
threading (SMT) esegue più thread in contemporanea e utilizza le istruzioni dei
singoli thread per mantenere le unità di elaborazione sempre operative.
Per esempio:
Costo hardware
Ciclo i: istruzione j e j+1 dal thread A, istruzione k dal
thread B, tutte eseguite in simultanea
Ciclo i+1: istruzione j+2 dal thread A, istruzione k+1 dal
thread B, istruzione m dal thread C, eseguite in
simultanea
Ciclo i+2: istruzione j+3 dal thread A, istruzione m+1 e
m+2 dal thread C, eseguite in simultanea.
In aggiunta all’hardware richiesto dal precedente multithreading, questa tecnica
richiede che ogni stadio della pipeline tracci il thread d’appartenenza
dell’istruzione e dato che il processore ha più unità d’esecuzione vi sono molte
istruzioni da tracciare. Inoltre la cache e la TLB deve essere molto ampia per
poter gestire un numero di thread molto elevato che eseguendo più istruzioni in
parallelo fanno un uso molto intenso delle risorse suddette.

Modifiche architetturali per il miglioramento delle prestazioni 95
Figura 3.17 - Un sistema Simultaneous Multi-Threading schedula più thread e ne
esegue in contemporaneo le istruzioni al fine di occupare al meglio le unità
d’elaborazione
3.2.3 Multi core
Il termine “multi core” si usa per descrivere una CPU composta da 2 o più core,
ovvero da più “cuori” di processori fisici montati sullo stesso package.
TECNICHE DI REALIZZAZIONE
Al momento, esistono 3 metodi differenti per creare un chip dual core:
• Die 6
Singolo
• Die Doppio
• Die Monolitico
6
Il "Die" è il blocco di silicio al centro di un processore che contiene il cuore
elaborativo della CPU, il core.

96 Capitolo 3
DIE SINGOLO
È l’approccio senz’altro più semplice, e quindi più economico rispetto agli altri,
per realizzare un chip dual core ma, ovviamente, è anche più limitante per
quanto riguarda le prestazioni e la resa produttiva.
In maniera un po’ semplicistica, possiamo dire che per realizzarlo è sufficiente
utilizzare la stessa maschera litografica disegnata per un processore single core,
e “stamparla” 2 volte sul wafer di silicio interconnettendo i due core così
realizzati. Rimane comunque il problema che se anche solo uno dei 2 core
stampati è difettoso, tutto il chip diventa inutilizzabile 7
L’evoluzione delle tecniche produttive probabilmente ha già decretato la
“morte” di tale approccio, che sebbene semplice da realizzare può risultare
indirettamente costoso per la probabilità di non avere molti core attigui sul
wafer perfettamente funzionanti.
DIE DOPPIO
Tale metodo consiste nel posizionare 2 die, fisicamente separati, su un unico
package e collegarli successivamente con collegamenti esterni. Tale metodo è
leggermente più complesso nella realizzazione di quello a die Singolo, in
quanto collegare i core in un secondo momento richiede maggiore tempo che
realizzare i collegamenti direttamente sul silicio. Esso però risulta
complessivamente il metodo più economico dal punto di vista del produttore:
infatti è possibile “scegliere” quali devono essere i due core che andranno poi
7 In questo caso il processore potrebbe essere rivenduto come semplice single core dopo
aver opportunamente disabilitato il core non funzionante.

Modifiche architetturali per il miglioramento delle prestazioni 97
collegati insieme, facendo cadere la necessità dei due core affiancati e
massimizzando la resa produttiva.
Soprattutto agli albori dell'utilizzo di quest’approccio i chip che superavano i
test, venivano valutati sui margini di clock e tensioni; i modelli che tolleravano
frequenze di clock elevate potevano essere marchiati come veloci processori
single core, mentre gli altri potevano essere accoppiati per realizzare i modelli
dual core che generalmente funzionavano a clock inferiori.
C’è tuttavia un grande svantaggio nell'inserire due core indipendenti in un solo
package. Quando un core accede ai dati, anche l’altro farà lo stesso, utilizzando
risorse non necessarie.
DIE MONOLITICO
L'approccio a “Die Monolitico” è certamente quello più sofisticato da realizzare
ma ovviamente è anche quello che garantisce le migliori prestazioni di una CPU
multi core. Tale approccio deve essere preventivato fin dalle prime fasi della
progettazione del processore. Il suo più grande pregio consiste nell'offrire ai
progettisti l'opportunità di condividere alcune unità del processore; nel caso più
semplice, tale condivisione si limita alla cache che viene realizzata in un unico
blocco condiviso tra tutti i core 8
. In casi più complessi le unità condivise
possono essere anche altre, come il controller della memoria RAM, gli
scheduler che ripartiscono il carico tra i vari core, ecc.
8 in processori che utilizzano gli altri approcci costruttivi, la cache è necessariamente
equamente divisa tra i core e l'accesso diretto a ciascuna cache è riservato
esclusivamente al rispettivo core, il quale per accedere alle altre deve far transitare i dati
sul BUS

98 Capitolo 3
Tutti i più recenti progetti di processori multi core puntano soprattutto
all'utilizzo di quest'ultimo approccio costruttivo, riservando gli altri (soprattutto
quello a die doppio), per risolvere specifiche esigenze.
COME REALIZZARE CHIP MULTI CORE
Analogamente ai differenti metodi appena esposti per realizzare un chip dual
core, anche per quelli multi core è possibile utilizzare gli stessi diversi approcci.
In questo caso però è anche possibile “combinare” i metodi per ottimizzare la
produzione a seconda delle esigenze dei progettisti e del mercato.
3.2.4 Parallelismo dei dati e Unità Vettoriali
IDEA DI BASE
Un processore vettoriale o “array processor” è una CPU progettata per svolgere
operazioni matematiche su più dati elementari contemporaneamente. Questo in
contrasto con l’architettura classica di un processore scalare che prevede
l’elaborazione di un singolo dato per volta. La maggior parte dei processori
sono scalari (o esternamente lo sembrano). I processori vettoriali sono comuni
nelle applicazioni scientifiche e sono spesso alla base dei supercomputer fin
dagli anni 80. Con la fine degli anni 90 i microprocessori sono cresciuti di
prestazioni e molti processori per applicazioni generiche si sono dotati di unità
vettoriali o sono diventati vettoriali al loro interno. Nel 2000 IBM Toshiba e
Sony hanno iniziato lo sviluppo del processore Cell, un microprocessore ad

Modifiche architetturali per il miglioramento delle prestazioni 99
elevate prestazioni dotato di svariate unità vettoriali e rivolto ad applicazioni
che spaziano dalle consolle al supercalcolo.
Attualmente praticamente ogni CPU moderna include istruzioni vettoriali
tipicamente conosciute come istruzioni SIMD. Le consolle per i videogiochi e
le schede grafiche fanno un ampio uso di processori vettoriali dato che
l’elaborazione di flussi audio e video in tempo reale è un campo che ben si
presta all’elaborazione vettoriale.
VANTAGGI
Dato che un’unica operazione vettoriale opera su più dati contemporaneamente
questo consente di leggere meno dati rispetto a un classico processore. I dati
vettoriali sono tra di loro indipendenti e quindi si può realizzare unità con un
elevato parallelismo con unità di controllo più semplici e quindi con pochi
transistor. Un numero ridotto di transistor consente di ottenere frequenze di
funzionamento elevate. Essendo il compilatore che provvede a ridurre le
dipendenze le unità di gestione diventano ancora più semplici. Le istruzioni
vettoriali accedono alla memoria secondo schemi noti quindi si possono
ottimizzare gli accessi dato che i dati vengono salvati in ampi registri vettoriali.
Inoltre queste unità possono fare a meno di cache dati.
ARCHITETTURA
Internamente un processore vettoriale è formato da un’architettura basata su
registri vettoriali. Ogni registro vettoriale è composto da un insieme di registri
caratterizzati da un unico nome e un indice che permette di accedere al singolo

100 Capitolo 3
dato. Le operazioni vettoriali lavorano unicamente tra registri vettoriali tranne
ovviamente le operazioni di load e di store che provvedono a caricare e
scaricare i dati dai registri verso la memoria.
I componenti di un processore vettoriale sono:
• CPU scalare: Questa unità è composta da registri, logica per la lettura
delle istruzioni e della loro decodifica.
• Registri vettoriali: Questi registri sono formati da un insieme di registri
accorpati per nome e indirizzabili tramite un indice. Sono dotati di
almeno due porte di lettura e di una di scrittura e possono essere da 8
fino a 32. A volte i registri supportano parole di lunghezza variabile
(8,16,32,64 bit) questo risulta comodo per applicazioni multimediali.
• Unità funzionale vettoriale: Questa unità è di tipo pipeline per poter
iniziare una nuova operazione ogni ciclo di clock. Tipicamente ne
esistono da 2 a 8 in grado di lavorare su interi o su numeri in virgola
mobile.
• Unità vettoriale di load-store: Questa unità è un’unità pipeline che
provvede a leggere e scrivere i dati dai registri alla memoria. L’unità
può leggere o scrivere più dati in contemporanea e in un processore
possono esserci più unità di load-store.
• Matrice di commutazione: Questa matrice mette in comunicazione le
varie unità funzionali del processore.

Modifiche architetturali per il miglioramento delle prestazioni 101
METODI DI ACCESSO
Figura 3.18 – Schema a blocchi di una architettura vettoriale
L’unità vettoriale di load-store usualmente supporta almeno tre modalità di
accesso.
• Metodo di accesso a passo unitario, il più veloce.
• Metodo di accesso a passo costante
• Metodo di accesso indicizzato. Accede alla memoria tramite un indice,
SVANTAGGI
è molto utile per accedere alle matrici sparse e permettere di
vettorializzare molti programmi
Questi processori sono poco adatti all’elaborazione di dati distribuiti in modo
non costante e quindi le loro reali prestazioni dipendono dalla tipologia di
programma in esecuzione e in alcuni casi anche dai dati trattati.

102 Capitolo 3
UNITÀ VETTORIALI
Tutti i processori moderni supportano operazioni vettoriali. Questo perché i
processori classici mal si prestano all’elaborazione di dati multimediali.
L’utilizzo di chip dedicati per l’elaborazione multimediali non ha mai preso
piede dato che quieti chip sono limitati nell’utilizzo, complicano lo sviluppo dei
computer e non sono mai stati ben supportati dal software. Invece l’inclusione
di queste unità nei processori moderni permette di migliorare le prestazione nel
campo del multimedia senza incrementare i costi in modo significativo. Difatti
basta aggiungere qualche registro (o utilizzarne alcuni poco usati come quelli
del processore matematico), modificare le pipeline in modo da poter gestire
gruppi di dati in parallelo e aggiungere la decodifica di alcune istruzioni in più.
3.2.5 Limiti sul livello di parallelismo
Il massimo numero di istruzioni eseguibili in parallelo viene limitato da tre
problemi (in inglese definiti alee); il numero di unità funzionali, le dipendenze
sui dati e le dipendenze sul controllo. Nello specifico:
• Alee Strutturali: Banalmente se il processore è dotato di quattro unità di
calcolo questo non potrà eseguire più di quattro istruzioni in parallelo
anche se nel codice fossero presenti più istruzioni eseguibili in
parallelo.
• Alee sui dati: Il processore non può eseguire (o completare)
un’istruzione se non ha tutti i dati, se alcuni dati devono essere ancora
elaborati (come nell’esempio con l’istruzione 3) il processore non può

Modifiche architetturali per il miglioramento delle prestazioni 103
mandare in esecuzione (o completare, dipende da come è costruita
l’unità funzionale) l’istruzione.
• Alee di controllo: Il codice che si trova dopo un salto condizionato non
3.3 Cache
può essere eseguito se prima non si stabilisce il risultato del salto
condizionato.
La memoria principale costituita da RAM dinamica (DRAM) è molto più lenta
della CPU e pertanto la necessità di leggere istruzioni e operandi dalla memoria
causa un rallentamento rispetto alle prestazioni teoriche della CPU. Il
meccanismo di pipeline può in alcuni casi diminuire l’impatto di questo
problema, eseguendo altre operazioni durante l’attesa.
Il tempo impiegato per leggere un dato dalla memoria (la latenza di lettura),
però potrebbe essere tale per cui la CPU potrebbe completare la propria coda di
operazioni mentre aspetta l’arrivo del dato richiesto, generando uno stallo della
CPU. Con l’aumento della velocità dei microprocessori, l’andare in stallo
spreca molta potenza di calcolo; le CPU moderne, infatti, possono eseguire
centinaia di istruzioni nello stesso tempo necessario per caricare un singolo dato
dalla memoria.
Nei paragrafi precedenti abbiamo illustrato alcune tecniche per "tenere
occupata" la CPU durante questa fase, come l’esecuzione fuori ordine e il
multithreading simultaneo, che permette ad un altro programma di usare la CPU

104 Capitolo 3
mentre un primo programma sta aspettando l’arrivo di dati dalla memoria
principale.
Purtroppo il divario di prestazioni tra memorie e CPU non tende a diminuire,
ma al contrario diviene più marcato di anno in anno (vedi Figura 3.13): le
memorie sembrano rallentare costantemente rispetto alle CPU e risulta sempre
più difficile costruire memorie in grado di fornire operandi in uno o due cicli di
clock. Uno dei modi per far fronte a questo problema potrebbe essere quello di
utilizzare SRAM invece di DRAM: le SRAM sono molto più veloci, ma ahimè,
anche molto più costose. Proprio per motivi di costo, non potendo realizzare
con SRAM tutta la memoria principale, viene introdotto il meccanismo della
cache, ovvero di una memoria veloce, di dimensione limitata rispetto all’intera
RAM, da “interporre” tra CPU e RAM.
Il principio di funzionamento è semplice. La CPU reperisce sempre i dati dalla
memoria cache, come se questa potesse contenere tutta l’informazione
memorizzabile in RAM:
• qualora la parola desiderata sia effettivamente presente in cache (cache
hit) otteniamo un indiscutibile vantaggio nel tempo di accesso.
• d’altro canto se la parola non è presente (cache miss), è necessario
trasferirla da DRAM a cache e poi leggerla; in questo caso il tempo
totale è sostanzialmente maggiore rispetto alla lettura da DRAM.
Pertanto l’utilizzo di cache è vantaggioso solo quando la percentuale di hit è
sufficientemente alta.

Modifiche architetturali per il miglioramento delle prestazioni 105
Questa condizione fondamentale è effettivamente verificata grazie a due
principi, detti di Località Temporale e Località Spaziale.
Grazie alla località temporale è assai probabile che una CPU debba accedere più
di una volta ad uno stesso dato. Ovvero, dopo aver acceduto al tempo t ad un
dato alla locazione addr, è assai probabile che ad un tempo ravvicinato t+dt si
debba accedere alla stessa locazione.
Il principio di località spaziale, invece, afferma che, dopo aver acceduto alla
locazione addr, in un tempo ravvicinato la CPU dovrà accedere con alta
probabilità alle locazioni contigue ad addr.
L’organizzazione delle memorie cache è tale da sfruttare questi due principi e
rendere quindi altamente probabili i casi di hit rispetto a quelli di miss. Il fatto
di trasferire un dato in cache a seguito di una miss, infatti, ha senso solamente
perché è assai probabile doverlo riusare.
Inoltre, le politiche di allocazione di cache tengono conto della località spaziale
leggendo normalmente più dati di quelli necessari (un intero blocco), con la
speranza che questi vengano in seguito richiesti; infine tengono conto della
località temporale per decidere quale blocco di cache rimpiazzare (cioè quale
blocco debba essere sovrascritto dal nuovo blocco entrante).
Le prestazioni ottenute utilizzando le memorie cache risultano quindi molto
migliori dell’uso della sola memoria RAM.
Il termine Cache deriva dal termine francese “caché” che significa “nascosto”,
ed indica che il funzionamento di questa memoria è per scelta completamente
trasparente (nascosto) al programmatore e gestito completamente in hardware.

106 Capitolo 3
L’origine del nome ci sottolinea pertanto come i dati siano memorizzati in una
posizione temporanea, dalla quale possono essere recuperati velocemente su
richiesta.
Le parole chiave sono “temporanea” e “velocemente”: in pratica, questo
significa che non c’è nessuna certezza che i dati si trovino nella cache, ma che
convenga comunque fare un tentativo per verificarne l’eventuale esistenza.
Il meccanismo di caching è utilizzato a diversi livelli; in questa trattazione
parleremo esclusivamente di CPU cache, ovvero della cache utilizzata dalla
CPU di un computer per ridurre il tempo medio d’accesso alla memoria.
3.3.1 Politiche di rimpiazzamento
Come già detto, le memorie cache sono molto più piccole rispetto alla memoria
principale e quindi è indispensabile definire una politica di rimpiazzamento dei
blocchi. Per poter fare spazio a nuovi dati nel caso di un cache miss, la cache
generalmente deve eliminare il contenuto di una delle linee. L’euristica che
utilizza per scegliere quale dato eliminare è chiamata politica di
rimpiazzamento. Il problema fondamentale di ogni politica di rimpiazzamento è
quello di dover predire il dato della cache che verrà richiesto nel futuro con
minor probabilità. Predire il futuro è difficile, soprattutto per le cache hardware
che devono sfruttare regole facilmente implementabili in circuiteria, perciò
esistono una serie di politiche di rimpiazzamento e nessuna di esse può essere
ritenuta perfetta. Una delle più popolari, la LRU (dall’inglese Least Recently

Modifiche architetturali per il miglioramento delle prestazioni 107
Used, cioè usato meno recentemente), rimpiazza, appunto, il dato al quale si è
fatto accesso meno recentemente.
3.3.2 Politiche di salvataggio
Quando un dato è scritto nella cache, dopo un po’ di tempo deve comunque
essere scritto in memoria principale. La decisione del momento in cui questa
scrittura deve aver luogo è controllata dalla politica di scrittura. In una cache
“write-through”, ogni scrittura sulla cache comporta una scrittura
contemporanea nella memoria principale. In alternativa, una cache “write-
back” non esegue immediatamente questa azione: al contrario, la cache tiene
traccia delle linee che contengono dati da aggiornare settando opportunamente
quello che viene chiamato il dirty bit. Il dato viene effettivamente scritto in
memoria solo quando esso deve essere eliminato dalla cache per far spazio a
nuove informazioni. Per questa ragione, una ricerca fallita in una cache write-
back spesso genera due accessi alla memoria: uno per leggere il nuovo dato,
l’altro per scrivere la vecchia informazione (se indicato dal dirty bit).
Esistono anche alcune politiche intermedie. La cache potrebbe essere ad
esempio write-through, ma le scritture potrebbero essere temporaneamente
inserite in una coda, così da processare insieme scritture multiple, ottimizzando
l’accesso al bus.

108 Capitolo 3
3.3.3 Protocolli di coerenza
I dati in memoria principale, dei quali esiste una copia nella cache, potrebbero
essere modificati da altre cause (evento non improbabile, ad esempio, in un
sistema multiprocessore), perciò i dati nella cache potrebbero diventare obsoleti.
I protocolli di comunicazione tra i sistemi di gestione delle cache che
conservano la consistenza dei dati sono chiamati protocolli di coerenza.
3.3.4 Associatività
La politica di rimpiazzamento decide dove, nella cache, può risiedere una copia
di una particolare locazione di memoria. Se la politica di rimpiazzamento è
libera di scegliere in quale linea di cache caricare il dato, la cache è chiamata
“fully associative” (o anche completamente associativa). Invece, se ogni dato in
memoria può essere posizionato solo in una particolare linea di cache, essa è
detta “direct mapped” (o anche a mappatura diretta). La maggior parte delle
cache, però, implementa un compromesso chiamato “set associative” (o anche
parzialmente associativa). Per esempio, la cache dati di livello 1 dell’AMD ®
Athlon è 2-way set associative, cioè una particolare locazione di memoria può
essere caricata in cache in due distinte locazioni nella cache dati di livello 1.
Se ogni locazione in memoria principale può essere caricata in due locazioni
diverse, la domanda sorge spontanea: quali? Lo schema utilizzato più
frequentemente è mostrato nella Figura 3.19: i bit meno significativi dell’indice
della locazione di memoria vengono usati come indici per la cache e ad ognuno

Modifiche architetturali per il miglioramento delle prestazioni 109
di questi indici sono associate due linee di cache. Una buona proprietà di questo
schema è che le etichette dei dati caricati in cache non devono includere quella
parte dell’indice già codificata dalla linea di cache scelta. Poiché i tag sono
espressi su meno bit, occupano meno memoria ed il tempo per processarli è
minore.
Figura 3.19 –Modalità di riempimento della cache nel caso di memoria cache
“Mappata Direttamente” e “Associativa a 2 vie”
Sono stati suggeriti altri schemi, come quello della “skewed cache”, dove
l’indice della way 0 è diretto, come sopra, mentre l’indice per la way 1 è
calcolato attraverso una funzione di hash. Una buona funzione di hash ha la
proprietà che gli indirizzi che sono in conflitto con il direct mapping tendono a
non collidere quando sono mappati con la funzione di hash, così è meno
probabile che un programma soffra di un numero imprevedibilmente grande di
collisioni dovuti ad un metodo d’accesso particolarmente patologico. Lo
svantaggio è il ritardo aggiuntivo necessario per calcolare il risultato della
funzione di hash. In aggiunta, quando diventa necessario caricare una nuova

110 Capitolo 3
linea ed eliminarne una vecchia, potrebbe rivelarsi difficile determinare quale
tra le linee esistenti è stata usata meno recentemente, in quanto la nuova linea
entra in conflitto con differenti "set" di linee per ogni "way"; il tracciamento
LRU è infatti normalmente calcolato per ogni set di linee.
L’associatività è un compromesso. Se ci sono dieci posizioni, la politica di
rimpiazzamento può riempire una nuova linea, ma quando bisogna cercare un
dato devono essere controllate tutte e 10 le posizioni. Controllare più posizioni
necessita di più potenza, area e tempo. D’altra parte, le cache con più
associatività soffrono di meno cache miss. La regola di massima è che
raddoppiare l’associatività ha circa lo stesso effetto sull’hit rate che il raddoppio
della dimensione della cache, da 1-way (direct mapping) a 4-way. Aumenti
dell’associatività oltre il 4-way hanno molto meno effetto sull’hit rate e sono
generalmente utilizzati per altri motivi (come ad esempio il virtual aliasing).
Uno dei vantaggi della cache direct mapped è che permette una esecuzione
speculativa semplice e veloce. Una volta che l’indirizzo è stato calcolato, è nota
quale sia la linea di cache che potrebbe contenere il dato. Questa può essere
letta ed il processore può continuare a lavorare con quel dato prima che finisca
di controllare che l’etichetta effettivamente combaci con l’indirizzo richiesto.
L’idea che il processore utilizzi i dati in cache prima ancora che sia verificata la
corrispondenza tra etichetta ed indirizzo può essere applicata anche alle cache
associative. Un sottoinsieme dell’etichetta, chiamato in inglese hint, può essere

Modifiche architetturali per il miglioramento delle prestazioni 111
utilizzato per scegliere temporaneamente una delle linee di cache associate
all’indirizzo richiesto. Questo dato può essere utilizzato dalla CPU in parallelo,
mentre l’etichetta viene controllata completamente. Questa tecnica lavora al
meglio quando usata nel contesto della traduzione degli indirizzi, come spiegato
più in basso
3.3.5 Obiettivo: Minimizzare i Cache miss
Con il termine “cache miss” (ovvero fallimento della cache) ci si riferisce ad un
intento fallito nel leggere o scrivere un pezzo di dati nella cache, che ha come
risultato una latenza molto più lunga nell’accesso alla memoria principale.
Quando si verifica un fallimento nella lettura dalla cache istruzioni, il
processore deve aspettare (si genera cioè uno stallo) finché l’istruzione non è
caricata dalla memoria principale. Un fallimento della cache causato dal
caricamento di un dato può invece essere meno doloroso, perché le altre
istruzioni non correlate ad esso possono comunque essere eseguite, finché
l’operazione che richiede i dati da caricare può essere eseguita. Comunque, i
dati sono spesso usati immediatamente dopo l’istruzione di caricamento.
L’ultimo caso di cache miss, cioè un fallimento in scrittura, è il meno
preoccupante, perché di solito la scrittura è bufferizzata. Il processore può
continuare tranquillamente finché il buffer non è pieno. (Non esiste un
fallimento nella scrittura della cache istruzioni perché esse sono di sola lettura.)

112 Capitolo 3
Per minimizzare la frequenza di cache miss, un grande sforzo di analisi è stato
fatto sul comportamento della cache per trovare la miglior combinazione di
dimensione, associatività, dimensione dei blocchi e così via. Sequenze di
referenze di memoria create dai programmi di benchmark sono salvati come
“address traces”. Ulteriori analisi simulano molte differenti possibilità di
implementazione della cache basate su queste lunghe address traces. Far capire
come le molteplici variabili modifichino la frequenza di cache hit può risultare
abbastanza confusionario. Un contributo significante fu fatto da Mark Hill, il
quale separò i vari fallimenti della cache in tre categorie (conosciute come "le
tre C") [13]:
• Compulsory misses sono quei fallimenti causati dalla prima referenza
ad un dato. La dimensione della cache e la associatività non fanno
differenze al numero di compulsory misses. Il prefetching può aiutare
qui, così come lo possono fare larghe dimensioni dei blocchi della
cache (che sono un tipo di prefetching).
• Capacity misses sono quei fallimenti che una cache di una data
dimensione avrà, a dispetto dell’associatività o della dimensione del
blocco. La curva della frequenza dei capacity misses rispetto alla
dimensione della cache fornisce una qualche misura della località
temporanea di un particolare flusso di referenze.
• Conflict misses sono quei fallimenti che si sarebbero potuti evitare, se la
cache non avesse ripulito un dato precedentemente. I conflict misses
potrebbero essere ulteriormente divisi in mapping misses, che sono

Modifiche architetturali per il miglioramento delle prestazioni 113
inevitabili data una particolare associatività, e replacement misses, che
sono causati dalla particolare scelta della regola di rimpiazzamento.
Figura 3.20 - Frequenza di fallimento (miss rate) a confronto con la dimensione della
cache (Cache size) sulla porzione degli interi di SPEC CPU2000
Il grafico in figura riassume la performance della cache vista dai benchmarks
della porzione degli interi di un SPEC CPU2000, ripresa da Hill e Cantin.
Questi benchmark servono a rappresentare il tipo di carico di lavoro che una
postazione di lavoro potrebbe subire un giorno qualsiasi. In questo grafico
possiamo vedere i differenti effetti delle tre C.
All’estrema destra, quando la cache size assume un valore "Inf" (che, in altre
parole, tende all’infinito), abbiamo i compulsory misses. Se volessimo
migliorare le caratteristiche dello SpecInt2000, aumentare la dimensione della
cache oltre 1MB sarebbe praticamente inutile.

114 Capitolo 3
La frequenza di fallimento della cache fully-associative rappresenta a pieno la
frequenza dei capacity misses. Nelle simulazioni, è stata scelta una regola di
rimpiazzamento LRU: questo mostra che per minimizzare la frequenza dei
capacity misses sarebbe necessaria una regola di rimpiazzamento perfetta, come
se ad esempio un veggente indagasse nel futuro per trovare una posizione della
cache che non stia per essere utilizzata.
È da notare come, nella nostra approssimazione della frequenza dei capacity
misses, il grafico abbia una brusca caduta tra i 32KB e i 64KB. Questo indica
che il benchmark ha un settaggio di lavorazione di circa 64KB. Un progettista
di cache, esaminando questi benchmark, sarebbe fortemente tentato di settare la
dimensione della cache appena sopra i 64KB, piuttosto che appena sotto questo
valore. Bisogna notare inoltre che, su questa simulazione, nessun tipo di
associatività può far andare una cache a 32KB bene come una da 64KB 4-way,
o addirittura come una direct-mapped da 128KB.
Infine, tra i 64KB ed 1MB c’è una grande differenza tra la cache di tipo direct-
mapped e quella fully-associative. Questa differenza è la frequenza dei conflict
misses. Secondo i dati del 2004, le cache di secondo livello montate
direttamente sul chip del processore tendono a stare in questo intervallo di
valori, in quanto le cache piccole sono abbastanza veloci da essere cache di
primo livello, mentre quelle più grandi sono troppo costose per essere montate
economicamente sul chip stesso (l’Itanium 2 ha una cache di terzo livello da

Modifiche architetturali per il miglioramento delle prestazioni 115
9MB, la più grande cache on-chip disponibile sul mercato nel 2004). Dal punto
di vista della frequenza dei conflict misses, risulta che la cache di secondo
livello trae un grande beneficio dall’alta associatività.
Questo beneficio era ben conosciuto nei tardi anni 80 e primi anni 90, quando i
progettisti di CPU non potevano far stare grandi cache sui chip e non
disponevano di sufficiente larghezza di banda per implementare alta
associatività sulle cache al di fuori del chip del processore. Furono provate varie
soluzioni: il MIPS R8000 usava delle costose SRAM off-chip dedicate, che
includevano dei comparatori di etichette e dei grandi driver, per implementare
una cache associativa 4-way da 4MB. Il MIPS R10000 usava dei chip ordinari
di SRAM per le etichette. L’accesso alle etichette, in entrambe le direzioni,
necessitava di due cicli: per ridurre la latenza, il R10000, per ogni accesso,
cercava di predire quale modo della cache sarebbe stato quello corretto.
3.3.6 Gerarchie delle cache
Nei calcolatori moderni vengono spesso utilizzate più cache. Innanzitutto le
cache sono oggigiorno differenziate in cache dati e cache istruzioni. Infatti per i
due gruppi di informazioni le località e le politiche sono diverse. Inoltre è
possibile aumentare il parallelismo evitando conflitti tra le fasi di fetch e di
trasferimento degli operandi.
Inoltre si usano diversi livelli di cache (L1, L2, ...) in cascata per ottimizzare il
trade-off costi/prestazioni. Si parte quindi da un primo livello molto veloce,

116 Capitolo 3
normalmente integrato con la CPU, ma di dimensione limitata. Il secondo
livello, più lento e distante dalla CPU del primo, è invece più grande in termini
di numero di locazioni, e così via. Di solito vengono utilizzati 2 soli livelli di
cache. Normalmente la cache di livello i+1-esimo mantiene l’intero contenuto
di quella di livello i-esimo. Analizziamo in dettagli questi due aspetti, chiamati
rispettivamente “specializzazione delle cache” e “cache multilivello”.
SPECIALIZZAZIONE DELLE CACHE
Il primo motivo è che CPU con pipeline accedono alla memoria da molteplici
punti nella pipeline: recupero delle istruzioni, traduzione indirizzi da virtuali a
fisici, e recupero dei dati.
La naturale implementazione è di utilizzare differenti cache fisiche per ognuno
di questi punti, cosicché nessuna risorsa fisica debba essere programmata per
servire due punti nella pipeline. La pipeline verrà pertanto normalmente servita
con almeno tre cache separate (istruzioni, TLB, e dati), ognuna specializzata in
un ruolo particolare.
VICTIM CACHE
Una “victim cache” è una cache utilizzata per mantenere blocchi rimossi dalla
cache della CPU a causa di un conflict miss o capacity miss. La victim cache è
situata tra la cache primaria e la memoria sottostante, e mantiene solamente i
blocchi rimossi dopo un miss. Questa tecnica è utilizzata per ridurre la penalità
in cui si incorre per un fallimento della cache.
TRACE CACHE

Modifiche architetturali per il miglioramento delle prestazioni 117
Uno dei più estremi esempi di specializzazione della cache è quello della trace
cache utilizzata nei microprocessori Pentium ® 4. Una trace cache è un
meccanismo per aumentare il fetch bandwidth di istruzioni immagazzinando
tracce di istruzioni che sono già state immagazzinate. Il meccanismo fu per la
prima volta proposto da Eric Rotenberg, Steve Bennett, e Jim Smith nel loro
articolo del 1996: “Trace Cache: a Low Latency Approach to High Bandwidth
Instruction Fetching”[14].
Una trace cache immagazzina le istruzioni sia dopo che esse sono state
decodificate, che quando sono ritirate. Generalmente, le istruzioni vengono
aggiunte alle trace cache in gruppi che rappresentano sia blocchi individuali di
base che tracce dinamica di istruzioni. Un blocco base consiste in un gruppo di
istruzioni non-branch (Non suddivise) che finiscono con una ramificazione. Una
traccia dinamica ("trace path" o "traccia del percorso") consiste nelle sole
istruzioni di cui il risultato viene effettivamente utilizzato, ed elimina le
istruzioni seguenti che prendono ramificazioni (Siccome non sono eseguite);
una traccia dinamica può essere il concatenamento di più blocchi base. Questo
permette all’unità di recupero delle istruzioni di recuperare parecchi blocchi di
base, senza la preoccupazioni riguardanti la ramificazione nel flusso di
esecuzione.
Le linee di traccia vengono immagazzinate nella trace cache in base al program
counter della prima istruzione nella traccia e un set di predizioni di

118 Capitolo 3
ramificazioni. Questo permette l’immagazzinamento di differenti tracce di
percorsi che iniziano con lo stesso indirizzo, ognuna delle quali rappresenta
differenti risultati di ramificazione. Nello stage dell’immagazzinamento delle
istruzioni di una Instruction pipeline, il program counter corrente insieme ad un
set di predizioni di ramificazione viene controllato nella trace cache per un hit.
Se un hit avviene, una linea di trace viene fornita per recuperare quale non deve
andare in una cache regolare o in memoria per queste istruzioni. la trace cache
continua ad alimentare la fetch unit fino a che la trace line finisce o fino a che vi
sia una misprediction nella pipeline. Se c’è un fallimento, una nuova traccia
inizia ad essere creata. Il vantaggio rispetto alle normali cache per il codice è
che non vengono mantenute in cache tutte le istruzioni successive ad un branch
che sia incondizionato o predetto come non seguito: il risultato è che non si
formano "bolle" di codice non utilizzato che sprecano spazio di memoria della
cache.
Le Trace cache vengono anche impiegate in processori quali l’ Intel ® Pentium ® 4
per immagazzinare micro operazioni già decodificate, o traduzioni di complesse
istruzioni x86, cosicché la prossima volta che una istruzione sia richiesta, non
debba essere decodificata un’altra volta.
L’idea che sta alla base della trace cache è che nei processori CISC che
internamente utilizzano istruzioni RISC, come il Pentium ® 4, la decodifica delle
istruzioni è una operazione estremamente onerosa, e il suo risultato dovrebbe

Modifiche architetturali per il miglioramento delle prestazioni 119
essere sfruttato al meglio. Utilizzare una trace cache in luogo di una normale
cache ha proprio questo vantaggio: non dover decodificare una istruzione già
incontrata durante l’esecuzione di un programma.
Ultimamente la trace cache non gode di molti favori a causa di alcuni difetti. Il
primo è che molte istruzioni RISC sono tradotte in una singola istruzione CISC
in un solo ciclo di clock, e le istruzioni che necessitano di più cicli di clock per
essere tradotte in più istruzioni di tipo RISC sono relativamente poche e poco
frequenti, per cui il vantaggio effettivo della trace cache è limitato. A questo si
aggiunge il fatto che, nel caso dell’architettura di Intel ® , le istruzioni di tipo
CISC hanno lunghezza variabile in genere tra 1 e 6 byte (tra gli 8 e i 48 bit),
mentre tutte le istruzioni RISC utilizzate internamente hanno lunghezza fissa di
118 bit. Quindi a parità di dimensioni una trace cache contiene molte meno
istruzioni di una cache normale.
CACHE MULTILIVELLO
Il secondo motivo è il fondamentale compromesso tra la cache latency ed l’hit
rate. Le cache più grandi sono più lente e hanno migliori hit rate. Per migliorare
questo tradeoff, molti sistemi utilizzano livelli multipli di cache, con cache
piccole e veloci che si appoggiano a cache più grandi e più lente.

120 Capitolo 3
Figura 3.21 - Un esempio di architettura con 3 livelli di cache. Le cache sono
normalmente inclusive, ossia L1⊆ L2 ⊆ L3 [12]
Siccome la differenza di latenza tra la memoria principale e le cache più veloci
è diventata più grande, alcuni processori hanno cominciato ad utilizzare anche
tre livelli di cache nel chip. Per esempio nel 2003, Itanium II iniziò ad essere
fornito con una cache sul chip unificata di livello 3 di 6MB. L’IBM Power 4
series ha una cache di livello 3 a 256MB fuori dal chip, condivisa tra parecchi
processori.
Le cache multilivello generalmente operano controllando dapprima le cache a
livello 1; se avviene un hit, il processore procede ad alta velocità. Se la cache
più piccola “fallisce”, allora viene controllata quella più grande e così via, fino
ad dover accedere alla memoria principale.
Le cache multi livello introducono un nuovo modello decisionale. Per esempio,
in alcuni processori (come gli Intel ® Pentium ® 2, 3, e 4, così come in molti
RISC), i dati nella cache L1 possono essere anche in quella L2. Queste cache

Modifiche architetturali per il miglioramento delle prestazioni 121
vengono denominato inclusive. Altri processori (come l’AMD ® Athlon) hanno
cache exclusive in cui è garantito che i dati siano al massimo in una delle cache
L1 o L2.
Il vantaggio delle cache exclusive è che memorizzano più dati. Questo
vantaggio aumenta con cache più grandi (le implementazioni Intel ® x86 invece
no). Un vantaggio delle cache inclusive è che quando devices esterni o altri
processori in un sistema multiprocessore desiderano rimuovere una linea di
cache dal processore, devono far controllare al processore solo la cache L2.
Nelle gerarchie di cache che non usano l’inclusione, le cache L1 devono essere
controllate anch’esse. C’è una correlazione tra la associatività delle cache L1 e
L2: se le cache L2 non hanno almeno tanti modi come tutte le L1 insieme,
l’effettiva associatività delle cache L1 risulta confinata.
Un altro vantaggio delle cache inclusive è che le cache più grandi possono usare
linee di cache più grandi, che riducono la dimensione delle etichette delle cache
secondarie. Se la cache secondaria è di un ordine di grandezza maggiore di
quella primaria, e i dati della cache sono di un ordine di grandezza più grande
delle etichette della cache, queste etichette di dati salvati può essere confrontato
con l’area incrementale necessaria ad immagazzinare i dati nella cache L1 ed
L2.

122 Capitolo 3
Come menzionato prima, grandi computer hanno a volte un’altra cache tra
quella L2 e la memoria principale chiamata cache L3. Questa cache è
implementata generalmente su di un chip separato dalla CPU, e come nel 2004,
ha un capacità dai 2MB ai 256MB. Queste cache costeranno ben oltre i $1000
da costruire, ed i loro benefici dipenderanno dai percorsi di accesso delle
applicazioni. Workstation x86 di fascia alta e server sono ora disponibili con
un’opzione per la cache L3.
Infine, dall’altro lato della gerarchia della memoria, Il Register file della CPU
può essere considerato la più piccola, veloce cache nel sistema, con la speciale
caratteristica che viene richiamata dal software, tipicamente da un compilatore,
siccome alloca registri che devono mantenere valori recuperati dalla memoria
principale.
3.4 Set di Istruzioni
Negli anni settanta si delineano in particolare due filosofie di progettazione
differenti inerenti il set di istruzioni: RISC (Reduced Instruction Set
Computing) e CISC (Complex Instruction Set Computing).
La Figura 3.22 mostra sinteticamente le differenze delle due filosofie così come
si erano delineate negli anni ’70.

Modifiche architetturali per il miglioramento delle prestazioni 123
Figura 3.22 – CISC vs RISC[15]
A partire dall’inizio degli anni ‘90 si assiste invece una sostanziale mescolanza
delle caratteristiche delle due con maggiore attenzione al raggiungimento delle
migliori prestazioni che ai ‘precetti’ che questi due acronimi sottendono.
Naturalmente le differenze strutturali tra i due approcci permangono, una su
tutte: il numero di registri indirizzabili dai rispettivi set di istruzioni che
consente ad esempio una gestione del compilatore per l’ottimizzazione più
aggressiva da parte dei processori RISC, potendo questi disporre di un numero
di registri nettamente superiore.
Qualsiasi sia l’approccio utilizzato, i set di istruzioni di tutte le CPU sono ormai
da tempo in grado, da un punto di vista funzionale, di eseguire qualsiasi tipo di
operazione. Il problema è, ancora una volta, quello di individuare soluzioni
ottimizzate per ambiti specifici.
Si pensi ad esempio alle applicazioni multimediali. Come abbiamo già
accennato al paragrafo 3.2.4 parlando delle unità vettoriali, avere a disposizioni

124 Capitolo 3
delle istruzioni ottimizzate in grado di sfruttare queste unità, porterà
sicuramente grandi benefici. In questo caso si parla proprio di istruzioni SIMD.
Un altro interessante campi di applicazione di queste istruzioni sono i calcoli
matematici per applicazioni scientifiche.
La prima architettura SIMD a essere disponibile commercialmente fu
l’architettura MMX realizzata da Intel ® .
PROBLEMI
Nell’evoluzione di un qualsiasi set di istruzioni, si pone un problema cruciale
che ne ha da sempre influenzato lo sviluppo: è il problema della retro-
compatibilità. Se infatti voglio realizzare una nuova architettura, ma al
contempo ho la necessità di porvi far funzionare i programmi attuali senza
ricompilarli (è quello cha auspica qualsiasi utente quando cambia il suo PC),
devo assolutamente fare in modo di mantenere inalterato il comportamento
delle istruzioni pre-esistenti.
Di fronte a questa scelta, i vari produttori hanno avuto un approccio non sempre
identico: c’è chi ha preferito mantenere la compatibilità a discapito magari di
prestazioni o del prezzo, mentre c’è chi ha realizzato soluzioni completamente
nuove, non retro compatibili.

Capitolo 4
Il risparmio energetico
Sono ormai lontani i giorni quando le prestazioni in termini di velocità erano
l’unica cosa che contava per i progettisti di CPU.
Basta infatti osservare i dati tecnici delle potenze dissipate delle CPU dei
principali produttori per osservare come ci sia stata una inversione di tendenza
molto drastica. Da quattro o cinque anni a questa parte il loro assorbimento è
ridotto notevolmente, pur mantenendo un incremento delle prestazioni (es core
2 duo consuma circa il 50% di energia rispetto al suo predecessore il
Pentium ® 4)
Ma quali sono i motivi di questa crescente attenzione? Forse solo gli aspetti
ambientali?
In realtà i motivi di fondo sono ben altri.
La resistenza dei circuiti elettrici all’interno della CPU genera calore e questo
implica problemi di funzionamento dei dispositivi nonch’è la riduzione della
loro vita media.
In più, in una società sempre più “Mobile”, la necessità di utilizzare risorse
limitate (batterie per i Portatili) per molto tempo mantenendo un sufficiente
grado di prestazioni è diventata sempre più un elemento essenziale.
L’approccio tradizionale che negli anni passati avevano i progettisti era legato
più ad aspetti tecnologici: l’idea era quella di miniaturizzare sempre più i

126 Capitolo 4
transistor, permettendo così la riduzione del voltaggio operativo, che si traduce
in minor dissipazione termica.
In realtà la miniaturizzazione ha portato si ad una riduzione della potenza
dissipata per transistor, ma è anche vero che la miniaturizzazione ha permesso
di aumentare il numero di transistor nel chip nonché di aumentare la frequenza
di clock. Il bilancio energetico complessivo è pertanto sempre stato
peggiorativo in termini di dissipazione complessiva del Chip.
Da alcuni anni a questa parte, i produttori sono molto attenti a trovare tecniche
per ridurre il consumo di energia, e anche gli aspetti architetturali devono dare il
loro contributo.
Ci aspettiamo ad esempio che i processori di prossima generazione siano in
grado di spegnere i transistor inutilizzati (sleep transistor), intere unità
funzionali come dei segmenti di cache L2, nonché la possibilità di spegnere
dinamicamente interi core per risparmiare energia. Probabilmente accelereranno
anche i core per carichi di lavoro single-threaded (Intel ® EDAT, Enhanced
Dynamic Acceleration Technology, tecnologia aspettata con i processori a 45
nm Wolfdale e Yorkfield). Con molti processori che supportano già il carico
dinamico e la regolazione della velocità, questo è chiaramente il passo logico
successivo.
Data la natura più tecnologia che microarchitetturale del problema, in questa
tesi si daranno solamente cenni sul problema, senza la pretesa di una trattazione
dettagliata ed esaustiva.

Capitolo 5
Applicazione nei processori Intel ®
5.1 I processori della Intel ® Corporation
Intel ® Corporation è ormai da anni l’azienda leader nel mercato dei
microprocessori a 32 bit. È per questo che vogliamo approfondire come questo
produttore ha introdotto le architetture di cui abbiamo parlato nei paragrafi
precedenti, soffermandoci via via ad osservare come esse sono state migliorate
nelle varie famiglie di processori prodotti nell’ultimo ventennio.
Nelle appendici A e B, viene illustrata una breve storia del colosso statunitense,
nonché una cronistoria dei processori e del periodo di introduzione sul mercato.
5.2 Modello Tick tock
Lo sviluppo e l’uscita su mercato del processori del produttore americano
Intel ® , seguono un approccio noto con i termini Tick e Tock [16]. Ogni anno
Intel ® presenta una nuova generazione di processori, che possono o
implementare un’architettura completamente nuova oppure essere costruiti
utilizzando una nuova tecnologia produttiva più sofisticata rispetto a quanto in
precedenza disponibile. Prendendo come riferimento le cpu Nehalem (ovvero le
ultime nate di casa Intel ® , note sul mercato con il nome di Core i7) a queste
corrisponde una fase Tock, cioè quella di una nuova generazione di

128 Capitolo 5
microarchitettura completamente differente rispetto alla precedente. Lo stesso
era accaduto 2 anni fa con il debutto delle cpu della famiglia Merom, che hanno
poi preso il nome commerciale di Core 2 Duo e Core 2 Quad a seconda delle
versioni; in quel caso il cambio architetturale è avvenuto in sostituzione delle
cpu Pentium ® D.
Le fasi Tick indicano l’utilizzo di un nuovo processo produttivo: le cpu
Nehalem sono costruite con tecnologia a 45 nanometri, la stessa adottata dalle
cpu della famiglia Penryn (Core 2 Duo e Core 2 Quad) attualmente disponibili
in commercio. Alla fase Tick corrisponde tipicamente anche un refresh
dell’architettura, con l’implementazione di alcune funzionalità
complessivamente considerate minori; ad esempio, con le cpu Penryn ha
debuttato la tecnologia produttiva a 45 nanometri e contestualmente sono state
introdotte le istruzioni SSE4 non presenti nelle soluzioni della famiglia Merom.
L’evoluzione a 32 nanometri di tecnologia produttiva delle cpu Nehalem è nota
con il nome di Westmere; i processori di questa famiglia debutteranno non
prima della fine di quest’anno, anche in questo caso con presumibili
innovazioni e migliorie ma senza stravolgimenti dell’architettura.
Per quale motivo Intel ® ha scelto di presentare le proprie soluzioni con questo
tipo di cadenza? L’alternativa potrebbe essere quella di introdurre nuove
architetture di processore congiuntamente ad un nuovo processo produttivo, ma
questa strada è ricca di numerose variabili che possono pregiudicare la riuscita
di un progetto e storicamente non è stata quasi mai adottata. La scelta è quindi
quella di presentare nuove architetture utilizzando tecnologia produttiva avviata

Applicazione nei processori Intel® 129
da tempo, con la quale non si corrono rischi particolari di rese inferiori alle
aspettative, utilizzando per i processi più sofisticati architetture che sono già
state evolute e sviluppate da tempo.
Figura 5.1 – Tick-tock in azione: Prima il “Tick” (anno 1) nel quale Intel ® sviluppa un
nuovo processo tecnologico incrementando la densità dei transistori fino a conseguire
miglioramento delle performance e dell’efficienza energetica con una sola rifinitura
della esistente microrchitettura. Segue poi il “Tock” (anno2) nel quale viene concepita
una nuova microarchitettura per ottimizzare gli aggiornamenti tecnologici ora
disponibili[16].

130 Capitolo 5
Figura 5.2-Per la sua politica di update Intel ® ha coniato il termine tick-tock
(equivalente del tic-tac italiano). Nelle roadmap della casa di Santa Clara lo stadio tick
è rappresentato dalla fase di miglioramento dell’architettura pre-esistente,
miglioramento che passa per l’ottimizzazione e la riduzione del processo produttivo. Lo
stadio tock prevede invece il lancio di un’architettura completamente nuova, però
realizzata con il processo produttivo della fase precedente.
5.3 Nomi delle architetture e relative CPU
La seguente tabella sintetizza le varie microarchitetture sviluppate da Intel ® fino
ad oggi.
Anno
Nome
Processori appartenenti
Introduzione Architettura
1978 8086/8088 Intel ® 8086
Intel ® 8088
1982 286 Intel ® 80286
1985 386 Intel ® 80386
1989 486 Intel ® 80486
1993 Pentium Intel ® Pentium
1995 P6 Intel ® Pentium ® Pro
Intel ® Pentium ® II
Intel ® Pentium ® II Xeon
Intel ® Celeron
Intel ® Pentium ® III
Intel ® Pentium ® III Xeon
2000 NetBurst Intel ® Pentium ® IV

Applicazione nei processori Intel® 131
Anno
Introduzione
Nome
Architettura
Processori appartenenti
Intel ® Xeon
Intel ® Pentium ® M
Intel ® Pentium ® D
Intel ® Xeon Dual Core
2006 Core Intel ® Core 2 Duo
Intel ® Core 2 Quad
Intel ® Xeon 51xx, 71xx, 53xx, 73xx, 54xx
2008 Nehalem Core i7
Tabella 5.1 - Microarchitetture Intel ® e relativi processori
Per quanto riguarda la nomenclatura dei processori Intel, è da osservare come
ad ognuno di essi sono associati due nomi.
• Nome commerciale: è il nome con cui il processore viene immesso sul
mercato e viene assegnato nel momento in cui il prodotto viene
commercializzato
• Nome in Codice o “codename”: è il nome associato a ciascun
processore durante le fase di sviluppo della CPU stessa.
5.4 Parallelismo “on Chip”
5.4.1 Pipeline
386
La primordiale implementazione della pipeline si ha già dal processore 80386
(1985) con una suddivisione dell’esecuzione delle istruzioni in due fasi:
“Istruction decode” ed “execution units”.

132 Capitolo 5
486
INTEGER PIPELINE
Il processore Intel ® 80486 (1989) aggiunge maggior capacità di esecuzione
parallela espandendo l’ “instruction decode” e l’ “execution units” in 5 stadi
pipelined. Ogni stadio opera in parallelo agli altri, in modo tale che
contemporaneamente risiedono 5 istruzioni nei 5 diversi stadi della pipeline.
Gli stadi delle pipeline di questa CPU sono illustrati nella Figura 5.3:
Figura 5.3 – La integer pipeline del processore 486[17]
Le fasi di questa pipeline possono essere così sintetizzate[18]:
• PF: Prefetch – Le istruzioni, a blocchi di 16 bytes, vengono richiamate
dalla cache sul chip o dalla memoria in un buffer di prefetch buffer,
recuperando circa 5 istruzioni per ogni fetch;
• D1: Prima decodifica – Vengono processati fino a tre byte di istruzioni
alla volta; viene quindi determinata la lunghezza dell’istruzione e di
conseguenza posizionato il prefetch buffer per l’esecuzione dello step

Applicazione nei processori Intel® 133
relativo alla istruzione successiva; Viene aggiunto un “extra cycles” nel
caso di istruzioni con prefisso o operandi di 2 byte
• D2: Seconda decodifica – In questa fase viene effettivamente calcolato
l’indirizzo degli operandi; Istruzioni che contengono
contemporaneamente un operando immediato e un displacement, e
anche comandi che utilizzano contemporaneamente indirizzamenti di
base e indicizzati vengono eseguiti in due cicli di clock
• EX: Esecuzione – questa fase include anche il fetch degli operandi da
registro e l’accesso ai dati su cache. Operazioni di Data Cache Hit sia
per delle load che per le store, operazioni della ALU con operandi e
risultati tutti nei registri, possono essere eseguite in un ciclo; Sono
invece necessari dei cicli extra per le istruzioni complesse (ad esempio
un “reg-to-memory add” richiede 3 EX cycles: uno per il data fetch
dalla cache, uno per l’effettiva operazione di add, e uno per scrivere i
risultati nella cache).
• WB: Write back – ovvero la scrittura nei registri
Possiamo vedere gli le varie fasi della pipeline anche nello schema a blocchi di
questa CPU illustrato nella Figura 5.4

134 Capitolo 5
UNITÀ FP
Figura 5.4 – Schema a blocchi della CPU 486. [18]
L’unità Floating point, ora integrata nella CPU, prevede invece una pipeline a 8
stadi. Essa è costituita dai primi 4 stadi della pipeline integer F/D1/D2/EX,
seguiti dai seguenti stati FP:
• X1: execute-1
• X2: exexute-2
• WF: FP write-back
• ER: error reporting
La pipeline del 486 prevede una gestione dei salti elementare considerando
sempre il salto come “non preso”. Questo comporta sempre la perdita di 2 cicli
ogni volta che viene modificato il Program Counter: il salto viene infatti
determinato nella fase EX e il contenuto di D1 e D2 deve essere rimpiazzato.

Applicazione nei processori Intel® 135
PENTIUM
INTEGER
Nel processore Pentium ® la pipeline rimane della stessa profondità del 486, ma
l’architetture diventa superscalare: abbiamo infatti due “instruction pipeline”,
definite “u” e “v”, che lavorano in parallelo. Entrambe le pipeline svolgono
operazioni Integer, pertanto il processore risulta ora in grado di svolgere due
istruzioni intere per ogni ciclo.
Figura 5.5 – La integer pipeline del Pentium.[17]
Le due pipe differiscono tra loro in quanto la “u” può svolgere qualsiasi
istruzione dell’architettura x86, la “v” pipe esegue solo comandi semplici che
non richiedono microcodici di alcun tipo (harwired instructions).
L’assegnamento in parallelo di due istruzioni sulle pipelines “u” e “v” viene
chiamato “instruction pairing”.Se le istruzioni vengono assegnate a coppie alla
pipelines, l’istruzione sulla pipe “v” è sempre quella che segue l’istruzione sulla
pipe “u”. Il fatto che le istruzioni di base (come ad esempio le operazioni ALU

136 Capitolo 5
e MOV) siano ora realizzate cablate fa sì che la loro velocità di esecuzione sia
sostanzialmente aumentata. Inoltre tutte le microistruzioni sono state
ottimizzate, ottenendo così un ulteriore aumento della velocità di esecuzione. La
struttura delle pipelines della CPU i486 Intel ® è stata conservata ed ottimizzata
nel processare Pentium, per ottenere un flusso più elevato.
Figura 5.6 - Architettura interna del processore Pentium[17]
Osservando lo schema a blocchi dell’architettura interna del Pentium ® di Figura
5.6, possiamo osservare che la fase di Prefetch fa ora riferimento ad una “cache
code” distinta dalla cache dei dati. la separazione delle cache per codice e dati
sulla CPU vengono evitati conflitti nella cache quando vengono prelevati

Applicazione nei processori Intel® 137
istruzioni con contemporanea lettura di dati. Due coppie indipendenti di
prefetch buffers permettono la contemporanea esecuzione di prefetch e di
codice su entrambe le pipelines. I due prefetch buffers operano in
sovrapposizione con il branch target buffer (BTB).
Il BTB è l’unità funzionale di predizione dei salti, che serve per ridurre al
minimo gli stalli della pipelines a causa dei salti condizionati. Dei due prefetch
buffers, è attivo uno solo per volta, per prelevare istruzioni sequenziali. Ciò vale
finchè non si preleva un'istruzione non sequenziale. In tale caso, il BTB viene
utilizzato per prevedere se il "loop" sia da eseguire (taken) o da non eseguire
(not taken). Il prefetch viene proseguito sequenzialmente solo nel caso in cui il
loop venga valutato "not taken". Se il loop viene predetto come "taken", l'altro
prefetch buffer viene chiamato in causa ed inizia a prelevare opcode come se il
loop fosse già in esecuzione. Se poi la previsione si rivela errata, la pipeline
viene svuotata, e il code prefetching prosegue alternativamente sull'altro
prefetch buffer.
Nel secondo step della pipeline, la decodifica delle istruzioni (D1), viene
determinato il tipo di comando, e si decide se si possono passare alle integer
pipeline una o due istruzioni. Il passaggio di istruzioni accoppiate viene
determinato dalle seguenti regole:
• le due istruzioni seguenti devono essere "comandi semplici",
interamente cablati.
• non devono esserci dipendenze di registro

138 Capitolo 5
• istruzioni con prefisso (con l'eccezione di OFh in collegamento con
istruzioni di loop condizionate) possono essere eseguite solo dalla "u"
pipe.
• nei comandi eseguiti in parallelo non possono essere
contemporaneamente presenti displacement e operandi immediati.
Nel secondo passo di decodificazione (D2) vengono determinati gli indirizzi
degli operandi. Al contrario di quanto avveniva per l'i486, le istruzioni che
contengono contemporaneamente un operando immediate e un displacement,
nonché i comandi che utilizzano contemporaneamente indirizzamenti di base e
indicizzati possono essere eseguiti in un solo ciclo.
Nella fase di esecuzione di una istruzione (EX) vengono eseguite una
operazione ALU ed un ricorso alla cache. Comandi che specifichino sia
l'operazione ALU che l'accesso alla cache richiedono più di un ciclo in questa
fase. Nella fase EX i comandi sulla "u" pipe e sulla "v" pipe vengono verificati
per quanto riguarda la correttezza della branch prediction. Un’eccezione sono i
loop condizionati, che vengono verificati solo nello step WB.
L'ultimo stadio di pipeline è il writeback (WB). I comandi eseguiti possono
alterare lo stato del processo re e terminare l'esecuzione delle istruzioni. I loops
condizionati vengono verificati per quanto riguarda la correttezza della
predizione della sequenzialità. Nel corso delle diverse fasi, possono avvenire
delle interruzioni di pipeline. È assicurato che le pipes "u" e "v" entrano sempre
contemporaneamente in D1 e D2, e abbandonano tali fasi sempre in modo

Applicazione nei processori Intel® 139
contemporaneo. Se in una delle due pipelines un comando viene eseguito con
maggiore lentezza, automaticamente l'esecuzione del comando sulla pipe
parallela viene sospesa, in modo che le pipeline entrino sempre
simultaneamente nella fase EX. Una volta in fase EX, l'esecuzione
dell'istruzione nella pipe "u" può proseguire, mentre può essere messa in attesa
un'istruzione nella pipe "v". Nessuna nuova istruzione può entrare nella fase EX
finché le istruzioni in entrambe le pipelines abbiano raggiunto la fase EX.
UNITÀ FP
L’unità a virgola mobile del processore Pentium ® è stata completamente
rielaborata ed è implementata come pipeline a 8 stadi con adder, multiplier e
divider separati.
Figura 5.7- LA FPU del processore Pentium[17]
Come nelle FPU precedenti. si ottempera alla IEEE 754, ma anche al nuovo
standard IEEE 854. La FPU è concepita in modo da eseguire un’operazione in
virgola mobile per ciclo. Sono possibili fino a due istruzioni per ciclo, ma la

140 Capitolo 5
seconda deve essere FXCHG. cioè floating point exchange. I primi quattro stadi
della pipeline vengono condivisi con la unità integer.
La FP-pipeline a 8 stadi è strutturata come segue
• PF: prefetch
• Dl: decodifica delle istruzioni
• D2:generazione degli indirizzi
• EX: lettura di registri e memoria;
conversione in formato FP esterno
e scrittura in memoria
• Xl: step 1 di esecuzione FP:
conversione del formato dati FP esterno a quello interno
scrittura degli operandi nell’ FP register file.
• X2: step 2 di esecuzione FP.
• WF: arrotondamento e scrittura del risultato FP nel register file
• ER: segnalazione di errore o aggiornamento della parola di stato
Le seguenti regole valgono per l’impartizione dei comandi FP 9
:
• In generale le istruzioni FP non possono essere eseguite in coppia con
istruzioni integer, ma una certa misura di esecuzione parallela è
comunque possibile (concurrefit processing).
• Se due istruzioni vengono trasmesse contemporaneamente una delle due
deve essere l’istruzione FXCHG, mentre l’altra deve appartenere al
9 Queste regole di base permettono di aggirare il collo di bottiglia che si genera
attraverso l’architettura a catasta (stack) dei registri FP.

Applicazione nei processori Intel® 141
gruppo F (FLD. FLD(i), FADD, FSUB. FMUL, FDIV, FCOM,
FUCOM, FIST, FABS, FCHS).
• Comandi diversi da FXCHG o da quelli appartenenti al gruppo F
vengono impartiti alla FPU in modo sequenziale.
• Comandi cui non segue immediatamente l’istruzione FXCHG vengono
impartiti singolarmente.
Nonostante l’architettura sia in massima parte un’architettura pipeline, è stata
implementata una forma di sicurezza per il riconoscimento delle istruzioni (SIR
safe instruction recognition). La SIR viene eseguita nella fase Xl della pipeline
e serve a rivelare il potenziale di errore presente nell’istruzione FP da eseguire.
Un’istruzione FP è considerata “safe” se non contiene alcuna condizione di
eccezione FP, come overflow e underflow aritmetici, o non genera una
condizione di eccezione non corretta. “Safe” significa anche che non è
necessario alcun microcodice per arrivare a risultati speciali, e che il prossimo
comando FP può concludere la fase EX della pipeline. Se un’istruzione FP
viene definita “unsafe” la successiva istruzione viene sospesa nella fase EX
finché l’attuale operazione non ha passato la fase ER. Ciò provoca un
rallentamento pari a 4 cicli, anche se alla fine tale istruzione non dovesse affatto
generare condizioni di eccezione.
MMX
L’introduzione della tecnologica MMX, una estensione della Intel ®
Architectural Instruction Set che discuteremo al paragrafo 5.7.2, ha determinato
anche una aggiunta di stadi alla pipeline. L’integrazione della pipeline MMX

142 Capitolo 5
con la integer pipeline è molto simile a quella dell’unità Floating Point[19]. La
Figura 5.8 mostra la struttura della pipeline MMX del Pentium.
Figura 5.8 – Struttura della pipeline MMX [19]
Il Pentium ® con tecnologia MMX introduce uno stadio aggiuntivo alla integer
pipeline. I byte di istruzioni sono pre-caricati dalla cache code nello stadio di
Prefetch (PF) e sono analizzate come istruzioni nello stage di Fetch (F). Sempre
nella fase F vengono decodificati tutti i prefissi.
L’analisi dell’istruzione è divisa dalla decodifica dell’istruzione attraverso un
buffer istruzioni di tipo FIFO (First In, First Out), situato tra gli stadi F e D1
Il buffer permette di contenere fino a 4 istruzioni. Questo buffer FIFO è
trasparente e non aggiunge latenza aggiuntiva quando è vuoto.
Durante ogni ciclo di clock, 2 istruzioni possono essere inserite nel buffer ( a
seconda della disponibilità di byte di codice e di altri fattori come i prefissi. Le
istruzioni sono estratte dal buffer FIFO a coppie e inviate allo stato D1. Dal
momento che la velocità media dell’esecuzione delle istruzioni è minore di 2
per clock il buffer è normalmente pieno. Finché il FIFO è pieno, esso può
salvare ogni stallo che può capitare durante il fetch e l’analisi dell’istruzione. Se

Applicazione nei processori Intel® 143
ci si imbatte in uno stallo di questo tipo, il FIFO evita che lo stallo si ripercuota
sullo stadio di esecuzione. Se il FIFO è vuoto, si innesca uno stallo dello stadio
di esecuzione, per carenza di istruzioni da eseguire.
Figura 5.9 - Introduzione del Buffer FIFO e dello stadio PF nella pipeline MMX
rispetto a quella del Pentium ® [20]
La Figura 5.10 mostra nel dettaglio la pipeline MMX del processore
superscalare Pentium ® e le condizioni che generano gli stalli.

144 Capitolo 5
Figura 5.10 - Flusso di istruzioni MMX nel processore Pentium ® con tecnologia MMX
La Figura 5.11 mostra le unità funzionali, la latenza, il throughput e l’execution
pipe per ogni tipo di istruzione MMX.
Figura 5.11 - Tipi di istruzioni MMX e relative unità funzionali [19]

Applicazione nei processori Intel® 145
P6 FAMILY
PENTIUM ® PRO
L’architettura successiva al processore Pentium ® prende il nome di architettura
P6 in quanto la sesta architettura dei processori Intel ® x86. Il primo esemplare
di questa architettura fu il Pentium ® Pro che incrementò il numero di stages
della pipeline da 5 a 12.
Figura 5.12 - La pipeline del processore Pentium ® Pro [19]
Con l’introduzione del Pentium ® Pro, viene introdotta nella pipeline una nuova
architettura dinamica di esecuzione che nasce dall’applicazione di tecniche di
esecuzione speculativa, esecuzione out-of-order, ridenominazione hardware dei
registri e predizione dei salti di cui discuteremo nei paragrafi seguenti. Per il
momento osserviamo solo come il core dell’out-of-order del processore
contiene diverse pipelines alle quali sono attaccate le execution unit integer,
branch, floating-point e memory.
Varie e differenti unità di esecuzione possono essere così raggruppate nella
stessa pipeline.
Per esempio una Integer ALU e la FPU (adder, multiplier and divider)
condividono la pipeline. La “data cache” è interallacciata attraverso una
“pseudo-dual ported”, in cui una porta è dedicata alla lettura e l’altra alla

146 Capitolo 5
scrittura. Molte operazioni semplici (come integer ALU, addizioni e
moltiplicazioni floating-point) possono essere inserite nella pipeline con un
throughput di una o due operazioni per ciclo di clock.
Le divisioni floating-point non sono invece “pipelined”. Long latency
operations can proceed in parallel with short latency operations.
La pipeline del Pentium ® Pro di Figura 5.12 può essere raggruppata in tre macro
blocchi:
• In-order front-end,
• Out-of-order core,
• In-order retirement unit.
In Order Front-End
La Errore. L'origine riferimento non è stata trovata. mostra nel dettaglio gli
elementi che appartengono a questo primo blocco.
L’introduzione del concetto di esecuzione fuori ordine impone, affinché si
possano riscontrare dei miglioramenti di prestazioni, che ciascuno istruzione
venga suddivisa in sufficienti µ-operazioni (chiamate in seguito µ-ops) pronte
per essere eseguite Anche la corretta predizione dei salti e una decodifica veloce
sono essenziali ottenere le migliori prestazioni in uscita dell’ “in order front-
end”. Nel paragrafo 5.4.3 verrà descritto più nel dettaglio il “Branch
Prediction” e il BTB. Occupiamoci ora della decodifica.

Applicazione nei processori Intel® 147
BTB0
BTB1
IFU0
IFU1
IFU2
ID0
IFU0: Instruction Fetch Unit
IFU1: In this stage 16-byte instruction p
The packets are aligned on
IFU2: Instruction Predecode
packets aligned on any boundary
Figura 5.13 – In order FrontEnd del Pentium ® Pro [19]
ID0: Instruction Decode.
Durante ogni ciclo di clock, possono essere decodificate fino a 3 macro-
istruzioni da parte dello stadio ID1. Pertanto se l’istruzione è complessa o è più
lunga di sette byte, il decoder è limitato a decodificare meno istruzioni.

148 Capitolo 5
I decoders possono decodificare:
• fino a 3 macroistruzioni per ciclo di clock
• fino a 6 µ-ops per ciclo di clock
• macro istruzioni fino a 7 byte di lunghezza
Il Pentium ® Pro ha 3 decodificatori nello stadio D1. Il primo è capace di
decodificare una macro istruzione in 4 o meno µ-ops in ogni ciclo di clock. Gli
altri due possono ciascuno decodificare una istruzione in una µ-ops per ogni
ciclo di clock.
Istruzioni composte da più di 4 µ-ops impiegano più cicli per essere
decodificate.
Se le istruzioni sono in una sequenza tale da venir convertite in 4-1-1 µ-ops,
viene incrementato il numero di istruzioni che possono essere decodificate per
ogni ciclo di clock. In generale:
• Istruzioni semplici nel formato registro-registro sono costituite da una
µ-ops
• Istruzioni di load prevedono una sola µ-ops
• Istruzioni di store hanno 2 µ-ops
• Istruzioni di semplice lettura modificano 2 µ-ops
• Istruzioni semplici nella forma registro-memoria hanno da 2 a 3 µ-ops.
• Istruzioni semplici read-modify write hanno 4 µ-ops
• Istruzioni complesse in generale hanno più di 4 µ-ops e pertanto
necessitano diversi cicli per essere decodificati

Applicazione nei processori Intel® 149
Out Of Order core
Quando le µ-ops sono decodificate, esse vengono rilasciate dal “front-end in-
order” verso il “Reservation Station” (RS), con la quale iniziano gli stati del
blocco “Out-of order”. Nel RS, le µ-ops aspettano finché i dati dei loro operandi
non sono disponibili. Quando la µ-ops ha tutti i dati degli operandi disponibili,
la µ-ops viene mandata dal RS all’execution unit. Se una µ-ops entra in RS con
i dati già tutti disponibili ed è disponibile l’execution unit appropriata, la µ-ops
viene inviata all’execution unit immediatamente. In questo caso, le µ-ops non
verranno spesi extra cicli di clock nel RS. Tutte le unità di esecuzione sono
raggruppate sulle porte di uscita dell’RS. La Figura 5.14 mostra lo schema di
questo blocco, mentre la Figura 5.15 mostra l’associazione delle execution unit
con le varie porte.
Figura 5.14 - L'Out-of order Core del Pentium ® Pro [19]

150 Capitolo 5
In order retirement unit
Figura 5.15 - Execution units del Pentium ® Pro. [19]
Quando le µ-ops sono state eseguite vengono salvate nel Re-Order Buffer
(ROB) ed attendono il retirement. In questo stadio della pipeline, tutti i valori
dei dati sono scritti nella memoria e tutte le µ-ops sono completate in ordine, 3
alla volta. La Figura 5.16 mostra nel dettaglio questa sezione.
Figura 5.16 - Retirement unit del Pentium ® Pro

Applicazione nei processori Intel® 151
PENTIUM ® II
Il Pentium ® II usa la stessa pipeline del Pentium ® Pro, ma integra anche le
funzioni MMX già introdotte nel Pentium. La Figura 5.17 mostra l’aggiunta
della tecnologia MMX rispetto alle execution unit del Pentium ® pro.
PENTIUM ® III
Figura 5.17 - Execution units del Pentium ® II
La pipeline del Pentium ® III resta praticamente invariata. Si sono solo aggiunte
delle execution unit in grado di eseguire le istruzioni SIMD (vedi paragrafo
5.7.2) ed una nuova unità Floating Point.

152 Capitolo 5
Figura 5.18 - Architettura del Pentium ® II e del Pentium ® III [21]
Figura 5.19 - Execution unit e porte del core Out-of-order del Pentium ® III [21]

Applicazione nei processori Intel® 153
Figura 5.20 – Execution Unit del Pentium ® III. Per i tempi di latenza delle unità SIMD,
si rimanda all’appendice D del manuale Intel ® Architecture Optimization Reference
Manual [21].

154 Capitolo 5
NETBURST
Nel 2000 con il Pentium ® 4 viene introdotta da Intel ® una nuova
microarchitettura chiamata NetBurst. Gli obiettivi principali del progetto di
questa nuova microarchitettura erano fondamentalmente 2:
Eseguire sia applicazioni IA-32 anche obsolete che nuove applicazioni basate
sulla tecnologia SIMD con un alto Throughput
Operare ad alte frequenze di clock e consentire nel futuro di aumentare le
prestazioni aumentando la frequenza di clock stessa.
L’architettura NetBurst è stata sviluppata infatti nel periodo in cui quando la
strada maestra per aumentare le prestazioni sembrava l’innalzamento della
frequenza operativa. Si trattava infatti di un’architettura nata per spingere il
processore fino a frequenze di 10 GHz.
Per ottenere questo, il progetto prevedeva una pipeline con queste
caratteristiche:
Elevata profondità 10
con parti funzionanti anche a diverse frequenze di clock.
Ottimizzazione per i casi comuni delle istruzioni usate frequentemente: le
istruzioni più frequentemente eseguite in circostanze comuni (come un cache
hit) sono decodificate efficientemente ed eseguite con una bassa latenza.
Impiego di tecniche per ridurre le penalità in caso di stallo; tra cui esecuzioni
parallele, buffering ed esecuzioni speculativa. La microarchitettura esegue le
10 Il primo esemplare del Pentium 4 aveva una profondità della pipeline di 20 stadi. Tra
i vari processori con architettura NetBurst si è arrivati fino a 31 stadi. Intel parla di
Hyper Pipelined Technology.

Applicazione nei processori Intel® 155
istruzioni dinamicamente e fuori ordine, in modo che il tempo necessario
all’esecuzione di ogni istruzione non sia sempre deterministico.
Figura 5.21 - Microarchitettura Intel ® NetBurst [22]
Come nelle precedent architetture l’approccio è quello di raggruppare gli stadi
della Pipeline in 3 blocchi.
In Order Front End
Il front end della microarchitettura NetBurst consiste di due parti:
• fetch/decode unit
• execution trace cache

156 Capitolo 5
Esse eseguono le seguenti operazioni:
• Prefetch delle istruzioni IA32 che sono probabilmente da eseguire
• Fetch delle istruzioni richieste e che non sono state prevaricate
• Decodifica delle istruzioni in µops
• Generazione di microcodice per istruzioni complesse e codice special-
purpose
• Recapito delle istruzioni decodificate attraverso l’execution trace cache
• Predizione dei salti usando algoritmi avanzati
Il Front end è stato progettato per rispondere in particolare a 2 problemi che
sono sorgenti di ritardo:
• Il tempo richiesto per decodificare le istruzioni caricate dalla
destinazione
• La larghezza di banda per la decodifica sprecata a causa di salti o a salti
di destinazione a metà di una cache line
Le istruzioni sono caricate e decodificate da meccanismo d traslazione.
Quest’ultimo sistema le istruzioni decodificate in sequenze di µ-ops chiamate
tracce. Queste tracce sono salvate nell’ “Execution Trace Cache”.
Quest’ultimo salva le µ-ops nel percorso del flusso di esecuzione; nella stessa
cache line è salvato anche il risultato dei salti del codice.
Questo incrementa il flusso di istruzioni dalla cache e permette il miglior uso
dello spazio globale di salvataggio della stessa in quanto non memorizza più le
istruzioni che sono state evitate da un salto e quindi mai eseguite.

Applicazione nei processori Intel® 157
Il trace cache può distribuire fino a 3 µ-ops per clock all’execution core.
“Execution trace cache” e “Translation engine” hanno in comune hardware
dedicato alla predizione dei salti. La destinazione dei salti sono predetti in base
all’indirizzo lineare usando la logica di branch prediction ed effettuando il fetch
appena possibile.
La destinazione del salto è caricata dall’execution trace cache se era stata
salvata, altrimenti viene caricata dalla gerarchia di memoria.
Prefetch
Sono supportati 3 meccanismi di prefetch:
• Un “Hardware Instruction Fetcher” effettua in automatico il prefetch
delle istruzioni
• Un meccanismo hardware che automaticamente esegue il Fetch dei dati
e delle istruzioni nella cache di secondo livello unificata.
• Un meccanismo che esegue il fetch solo di dati che include due
componenti:
1. Meccanismo hardware per effettuare il fetch delle linee di
cache adiacenti utilizzando un settore di 128 Byte che contiene
i dati vicini ad una cache line miss (normalmente si parla di
Adjacent Cache Line Prefech)
2. Un meccanismo software che consente di eseguire il prefetch
dei dati tramite apposite istruzioni

158 Capitolo 5
Execution Trace Cache
L’ “Execution Trace Cache” (TC) è la prima cache di istruzioni nella
microarchitettura NetBurst. The TC salva le µ-ops ottenute dalla decodifica
delle istruzioni IA-32.
Nel Pentium ® 4, l’implementazione del TC può salvare fino a 12K µ-ops e può
distribuire fino a 3 µ-ops per ciclo. TC non salva tutte le µ-ops che devono
essere eseguite: in alcune situazioni l’execution core necessita di eseguire un
flusso di microcodice invece delle traces di µ-op che sono salvate nel trace
cache.
Il Pentium ® 4 è ottimizzato in modo che le istruzioni IA32 di frequente utilizzo
escono dal trace cache, mentre solo poche istruzioni richiedono microcodice
ROM.
Out Of Order superscalar execution unit
La capacità del core di eseguire istruzioni fuori ordine è un fattore chiave per il
parallelismo. Questa caratteristica abilita il processore a riordinare le istruzioni
in modo che se una µ-ops è ritardata in attesa di dati o a causa della contesa di
risorse, le altre µ-ops che nella sequenza del programma appaiono
successivamente, possono essere processate prima. Questo implica che quando
una porzione della pipeline necessita di un ritardo, quest’ultimo può essere
coperto da altre operazioni che possono essere eseguite in parallelo o
dall’esecuzione di µ-ops in coda nel buffer.
Il core è progettato per facilitare l’esecuzione in parallelo. Esso può distribuire
fino a 6 µ-ops per ciclo attraverso le porte di uscita (Figura 5.22)

Applicazione nei processori Intel® 159
Da notare come 6 µ-ops per ciclo eccedono la larghezza di banda del trace
cache e dell’unità di retirement. La maggior larghezza di banda del core
permette di gestire queste situazioni.
La maggior parte delle unità di esecuzione possono iniziare l’esecuzione di una
nuova µ-op ogni ciclo in modo che diverse istruzioni possono attraversare nello
stesso tempo la pipeline. Alcune istruzioni ALU possono essere avviate con una
frequenza di 2 per ciclo 11
; diverse istruzioni FP iniziano invece ogni 2 cicli.
Infine le µ-ops possono iniziare ad essere eseguite fuori ordine non appena i dati
in ingresso sono pronti e le risorse disponibili.
Figura 5.22- Execution Unit e porte della architettura NetBurst. [22]
11 Intel chiama questa tecnologia “Rapid Execution Engine”

160 Capitolo 5
In order retirement unit
La “retirement unit” riceve i risultati dell’esecuzione di µ-ops dall’execution
core e processa i risultati in modo che lo stato architetturale sia aggiornato in
accordo con la corretta sequenza del programma originale. Per una esecuzione
semanticamente corretta, i risultati delle istruzioni IA-32 devono essere
processati nell’ordine originale del programma prima che l’istruzione sia
considerata “retired”.
Quando una µ-op è completata e viene scritto il risultato nella destinazione, essa
viene ritirata. Possono essere ritirate fino a 3 µ-ops per ciclo. Il reorder buffer
(ROB) è l’unità del processore che memorizza le µ-ops completate, aggiorna lo
stato architetturale e gestisce l’ordine delle eccezioni.
La retirement unit tiene anche traccia dei salti e invia informazioni sulle
destinazioni degli stessi al BTB. Questo aggiorna così il “Branch History”. La
Figura 5.21 illustra i percorsi che più frequentemente vengono eseguiti
all’interno della microarchitettura NetBurst: l’esecuzione di un loop che
interagisce con la gerarchia di cache multilivello e il Bus di sistema.

Applicazione nei processori Intel® 161
CORE
Figura 5.23 - Schema a blocchi dell'architettura del Pentium ® 4 [23]
Con la microarchitettura Core, Intel ® introduce diverse innovazioni per poter
conseguire alte prestazioni e allo stesso tempo garantire efficienza nel consumo
energetico. Viene in particolare introdotto il concetto di “Intel ® Wide Dynamic
Execution” che permette di caricare, distribuire ed eseguire istruzioni con una
ampia larghezza di banda e completare fino a 4 istruzioni per ciclo di clock per
ogni core. Le sue caratteristiche principali sono:
• pipeline efficiente a 14 stadi
• 3 ALU
• 4 decodificatori in grado di decodificare fino a 5 istruzioni per ciclo

162 Capitolo 5
• Tecniche di Macro-fusion e micro-fusion per aumentare il front-end
throughput
• Velocità di picco di emissione fino a 6 µ-ops per ciclo
• Picco della larghezza di banda di completamento fino a 4 µ-ops per
ciclo
• Branch prediction evoluto
• Stack pointer tracker per migliorare l’efficienza dell’esecuzione di
entrate ed uscite delle funzioni/procedure
La pipeline della microarchitettura Core contiene I seguenti elementi:
• InOrder front end: lo streams di istruzioni viene caricato dalla memoria,
decodificato in µ-ops da 4 decoders e inviato al Out-of-Order Execution
core.
• out-of-order superscalar execution core: permette di completare fino a 6
µ-ops per ciclo e riordinare le µ-ops da eseguire appena sono
disponibili i dati e le risorse di esecuzione.
• in-order retirement unit: garantisce che il risultato delle esecuzioni delle
µ-ops sia processato e che lo stato architetturale venga aggiornato in
accordo con l’ordine originale del programma.
Nella Figura 5.24 è mostrato lo schema a blocchi della pipeline Core.

Applicazione nei processori Intel® 163
Figura 5.24 - Funzionamento della pipeline della microarchitettura Intel ® Core[24]
FRONT END
Il front end deve provvedere alla decodifica di istruzioni (µ-ops) e sostenere il
flusso di 6 µ-ops da fornire al motore out-of-order.
I componenti del front end, le loro funzioni e l’impatto che hanno sulle
prestazioni sono descritte nella Figura 5.25.

164 Capitolo 5
Figura 5.25- Elementi del Front End della microarchitettura Core [24]
EXECUTION CORE
L’execution Core della microarchitettura Intel ® Core è superscalare e può
processare istruzioni fuori ordine. Quando una catena di dipendenze impone alla
macchina di aspettare a causa di una risorsa (come per esempio second-level
data cache line), l’execution core esegue altre istruzioni. Questo incrementa la
velocità complessiva delle istruzioni eseguite per ciclo (IPC).

Applicazione nei processori Intel® 165
I componenti principali che permettono questo tipo di esecuzione sono:
• Renamer: Muove le µ-ops dal front end verso l’execution core. Esso
effettua anche la ridenominazione dei registri architetturali in un ampio
set di registri microarchitetturali. La Ridenominazione dei registri
elimina false dipendenze note, come i rischi di read-after-read e write-
after-read.
• Reorder Buffer (ROB): trattiene le µ-ops nei vari stadi di
completamento, bufferizza quelle completate, aggiorna lo stato
architetturale in ordine e gestisce l’ordine delle eccezioni. Il ROB ha 96
entries.
• Reservation Station (RS): Accoda µ-ops finché tutti gli operandi
sorgente sono pronti, schedula e distribuisce le µ-ops pronte alle unità
di esecuzione disponibili. RS ha 32 entries.
Lo stadio iniziale del core out of order muove le µ-ops dal front end verso il
ROB and RS. In questo processo, compie i seguenti passi:
• Alloca risorse per le µ-ops (ad esempio queste risorse possono essere
load or store buffers).
• Associa ogni µ-op all’appropriata porta.
• Rinomina sorgente e destinazione delle µ-ops, abilitando l’esecuzione
fuori ordine.
• Recupera i dati delle µ-ops quando essi sono un valore immediato o il
valore di un registro che è già stato calcolato.

166 Capitolo 5
Lo schedulatore può distribuire fino a 6 µ-ops per ciclo attraverso le issue ports.
Queste ultime sono descritte nella Figura 5.26, mostrando i tempi di latenza, il
throughput delle comuni operazioni integer e FP per ciascuna porta espressi in
cicli.
Figura 5.26 - Issue ports della Microarchitettura Intel ® Core. La tabella mostra I dati
per due modelli di processore. [24]

Applicazione nei processori Intel® 167
In ogni ciclo, l’RS può distribuire fino a 6 µ-ops. Ogni ciclo possono essere
scritti all’indietro fino a 4 risultati su RS e ROB, in modo che possano essere
già utilizzati al prossimo ciclo di clock dall’RS.
L’execution core contiene i 3 seguenti execution stack
• SIMD integer
• regular integer
• x87/SIMD floating point
Esso contiene poi i collegamenti da e per la memoria come illustrato in Figura
5.27
Figura 5.27 - Execution core della microarchitettura Intel ® Core [24]
Si noti la presenza di due blocchi scuri nei percorsi che collegano le Integer e le
Integer SIMD con l’unità FP. Questi blocchi indicano la necessità di inserire un
ritardo noto col nome di “bypass delay”. Anche i dati dalla cache L1 verso il FP
presentano un ciclo extra di latenza .

168 Capitolo 5
NEHALEM
La microarchitettura Nehalem mantiene la pipeline a 4 vie sviluppata nella
microarchitettura Core a 65nm. La Figura 5.28 illustra i componenti di base
della pipeline della Nehalem implementata nei processori Intel ® Core i7,
mostrando però solo 2 dei quattro core presenti in queste CPU.
Figura 5.28 - Funzionamento della pipeline della microarchitettura Intel ® Nehalem
[24]

Applicazione nei processori Intel® 169
La lunghezza della pipeline è di due cicli più lunga rispetto al processore Intel ®
Core 2 a 45nm, misura ottenibile mediante il ritardo che si verifica in caso di
errata predizione del salto.
Il front end può decodificare fino a 4 istruzioni in un ciclo e supporta 2
hardware threads attraverso la decodifica di un streams di istruzioni tra due
processori logici in cicli alternati. Il front end include miglioramenti nella
gestione dei branch, nel rilevamento dei loop, MSROM throughput, etc
Il reservation station può distribuire fino a 6 µ-ops in un ciclo attraverso 6 issue
ports (5 issue ports sono mostrate in Figura 5.28; le operazioni di store
utilizzano porte separate per salvare dati ed indirizzi: nel diagramma queste
porta sono mostrate come una sola).
L’ out-of-order engine ha molte unità di esecuzione che sono disposte in 3
execution cluster. Essa può ritirare 4 µ-ops in un ciclo come il suo predecessore
FRONT END
La Figura 5.29 mostra i componenti chiave del front end della microarchitettura
Nehalem.
L’ “instruction fetch unit” (IFU) può caricare fino a 16 bytes di istruzioni
allineate al bytes ogni ciclo dalla cache istruzioni verso l’ “instruction length
decoder” (ILD). L’ “instruction queue” (IQ) bufferizza le istruzioni processate
dall’ILD e può distribuire all’ “Instruction Decoder” fino a 4 istruzioni in un
ciclo.

170 Capitolo 5
Figura 5.29 - Front end della pipeline della microarchitettura Nehalem [24]
L’ “instruction decoder” ha 3 unità di decodifica che possono decodificare una
istruzione semplice per ciclo ciascuna. L’altra unità di decodifica può
decodificare una istruzione ogni ciclo, sia essa una istruzione semplice o una
istruzione complessa costituita da diverse µ-ops. Istruzioni costituite da più di 4
µ-ops sono consegnate dall’ MSROM.
Fino a 4 µ-ops possono essere consegnate ad ogni ciclo all’ “instruction
decoder queue” (IDQ).
Un “loop stream detector” è posizionato nell’ IDQ per migliorare il consumo di
Potenza e l’efficienza del front end per i loop con una basso numero di
istruzioni.
L’instruction decoder supporta la tecnica detta di Microsfusion per migliorare il
throughput del front end, aumentando l’effettiva dimensione delle code nello
schedulatore (RS) e nel ROB. Il regole del Microfusion sono simili a quelle
della microarchitettura Core.

Applicazione nei processori Intel® 171
L’ “instruction queue” supporta invece la macro-fusion per combinare istruzioni
adiacenti in una µ-op quando possibile. Rispetto alla microarchitettura Core la
Macro-fusion è ora supportata da diverse istruzioni e anche nella modalità a 64
bit.
EXECUTION ENGINE
L’ IDQ (Figura 5.29) consegna il flusso di µ-ops allo stadio
“allocation/renaming” della pipeline (Figura 5.28). L’out-of-order engine
supporta fino a 128 µ-ops contemporaneamente. Ogni µ-ops deve essere
allocata con le seguenti risorse: un’entry nel re-order buffer (ROB), un’entry nel
reservation station (RS), ed una load/store buffer se è richiesto un accesso alla
memoria.
L’ “allocator” rinomina anche i registri per ogni µ-ops. I dati di ingresso
associati con le µ-ops sono generalmente letti o dal ROB o dal “retired regiter
file”.
La profondità del RS è espansa a 36 entry (rispetto alle 32 entries delle
precedenti generazioni). Esso può consegnare fino a 6 µ-ops in un ciclo se le µ-
ops sono pronte per essere eseguite. RS consegna ogni µ-op attraverso una issue
port verso il cluster di esecuzione specifico
Ogni cluster può contenere una raccolta di unità di esecuzione
integer/FP/SIMD.
Il risultato dell’esecuzione della µ-op è scritto dall’unità di esecuzione indietro
nei registri, o forwardato attraverso una rete di bypass ad un’altra µ-op “in
volo” che richiede il risultato. La microarchitettura Nehalem, può supportare il

172 Capitolo 5
“write back” con un throughput di una scrittura su registro per ciclo per ogni
porta. La rete di bypass consiste di 3 spazi integer/FP/SIMD. Il forwarding del
risultato nello stesso spazio di bypass, da una µ-op ad un’altra viene portata a
termine efficientemente in hardware senza ritardo. Il forwarding tra spazi di
bypass differenti è invece soggetto ad un ritardo illustrato in Figura 5.30.
Figura 5.30- Bypass Delay tra µ-ops espresso in cicli [24]
La illustra le caratteristiche principali delle issue port e ed i tempi di latenza e
throughput delle unità di esecuzione per le operazioni più comuni

Applicazione nei processori Intel® 173
Figura 5.31 - Issue Ports della microarchietettura Nehalem [24]
5.4.2 Processori Superscalari
Il primo esempio di applicazione superscalare nei processori Intel ® si ha con il
Pentium, nel quale viene introdotta una seconda execution pipeline (come
illustrato al paragrafo 5.4.1).

174 Capitolo 5
Nei processori della famiglia P6, l’architettura superscalare viene migliorata
rendendola a 3 vie: questo significa che mediamente vengono decodificate,
inviate alle unità di esecuzione ed eseguite 3 istruzioni per ciclo di clock. Per
poter far questo, l’unità di esecuzione ha a disposizione diverse unità funzionali
collegate tra di loro attraverso 5 porte come evidenziato nella Figura 5.14 e
nella Figura 5.15. Nel Pentium ® Pro le unità funzionali sono 6, nel Pentium ® 2
sono 11, mentre nel Pentium ® 3 sono 12.
Nella microarchitettura NetBurst, il trace cache può consegnare all’execution
core fino a 3 µ-ops per ciclo di clock. Le unità di esecuzione sono ora 7 e
risultano accessibili attraverso 4 porte (Figura 5.22) .
Con la microarchitettura Core si parla della tecnologia “Intel ® Wide Dynamic
Execution”, la quale permette a ciascun processor core di caricare, consegnare
ed eseguire con una alta larghezza di banda, supportando il retirement fino a 4
istruzioni per ciclo.
5.4.3 Predizione dei salti
Con l’introduzione delle pipeline e delle architetture superscalari diventa
indispensabile implementare un sistema di predizione dei salti.
486
Nel 486, primo CPU Intel ® con pipeline, la gestione dei salti è elementare: il
salto vene sempre considerato come “non preso”. Il salto viene individuato
nello stadio EX della pipeline (paragrafo 5.4.1). Questo comporta sempre la

Applicazione nei processori Intel® 175
perdita di 2 cicli ogni volta che viene modificato il Program Counter, in quanto
il contenuto di D1 e D2 deve essere rimpiazzato.
PENTIUM
Il processore Pentium ® dispone di un algoritmo di predizione dinamico, che
viene implementato con il “branch target buffer” (BTB), per prevedere possibili
ramificazioni di programma.
II BTB può essere visto come una piccola cache nella quale ogni voce è
rappresentata dall'indirizzo di programma dell'istruzione di diramazione, e da un
indirizzo target subordinato. Bit addizionali, chiamati “History bit”, vengono
impiegati per definire se un loop è "preso" o "non preso", al fine di ottimizzare
il flusso del programma in caso di esecuzioni ripetute. Ciò permette di evitare
interruzioni di pipeline a causa di prefetch di codice (Figura 5.32). Come già
accennato, il BTB è strettamente accoppiato con i preferch buffers del primo
stadio della pipeline.
I loop possono essere eseguiti in parallelo con un'altra istruzione integer. Se la
previsione sulla ramificazione si rivela non corretta, le pipelines subiscono un
flush completo, seguito dal prelevamento di un'istruzione. Se la previsione non
corretta riguarda un loop non condizionato sono necessari tre cicli addizionali,
come anche nel caso di una non corretta previsione di loops condizionati nella
“u” pipe. Nella “v” pipe occorrono altri 4 cicli.

176 Capitolo 5
Figura 5.32- BTB del Pentium. Se nella fase D1 (instruction decode) della pipeline
viene scoperta una diramazione del programma, l'indirizzo di programma
dell'istruzione di loop viene usata come riferimento nel BTB, per comunicare la
destinazione della diramazione e far partire il meccanismo del code prefetch. Se la
previsione è corretta, la pipeline non viene interrotta. In tal modo possono venire
eseguile in un unico ciclo istruzioni di loop condizionate e non condizionale, come
anche NEAR procedure calls in parallelo ad esempio con una istruzione integer. [17]
Osserviamo come i salti che sono “non presi”, non vengono inseriti nel BTB
fino a quando la previsione non si rileva errata.
Il BTB del Pentium ® è costituito da 256 entry.
P6
Nella famiglia P6, il BTB e di 512 entry e archivia la storia dei salti
precedentemente incontrati e la loro destinazione. Quando un salto viene pre-
caricato (fase PF), il BTB invia l’indirizzo di destinazione direttamente nella
“Instruction Fetch Unit” (IFU). Appena il salto viene eseguito, il BTB è
aggiornato con il nuovo indirizzo di destinazione. Usando il “branch target

Applicazione nei processori Intel® 177
buffer” I salti che sono stati precedentemente incontrati vengono così predetti
dinamicamente.
L’algoritmo di predizione del “branch target buffer” include un sistema di
“pattern matching” e 4 bit “history bit”. Per esempio un loop costituito da 4
iterazioni si deve concludere con una predizione del 100%.
I salti che non sono nel BTB, vengono predetti da un meccanismo di predizione
statico basato sui seguenti algoritmi di predizione:
• I salti non condizionati sono predetti “Presi”
• I salti condizionati “backward” sono considerati “Presi”. Questa regola
è invertibile per i loops.
• I salti condizionati “forward” sono considerati “Non Presi”.
• I salti indiretti sono considerati “Non Presi”
Questi meccanismi di predizione statica soffrono una piccola penalità compresa
tra i 5 o 6 cicli (la lunghezza della pipeline fino a quel punto).
NETBURST
La estrema profondità della pipeline della NetBurst necessità una predizione dei
salti molto efficiente per non degradare notevolmente le prestazioni.
I sistema di predizione dei salti nella microarchitettura Intel ® NetBurst predice
tutti i salti “near” (conditional calls, unconditional calls, returns and indirect
branches). Esso non effettua predizioni per i trasferimenti “far” (far calls, irets
and software interrupts).

178 Capitolo 5
Diversi sono i meccanismi implementati per ottenere una accurata predizione
dei salti e ridurre il costo dei salti. Tra queste tecniche ricordiamo:
• Predizione dinamica della direzione e della destinazione dei salti in base
all’indirizzo lineare delle istruzioni, utilizzando il “branch target buffer”
(BTB)
• Se la predizione dinamica non è disponibile o è invalida, viene
utilizzata una predizione statica basata sull’Offset della destinazione: un
salto “backward” è considerato “Preso”, mentre un salto “forward” è
considerato “Non Preso”
• Predizione degli indirizzi di ritorno con un “Return Address Stack” di
16-entry.
• Capacità di costruire una traccia delle istruzioni eseguite nel caso di
salti predetti “Presi” per evitare penalità del salto.
Il BTB e la predizione statica sono rimaste invariate rispetto alla generazione
precedente. Gli aspetti innovativi sono invece il “Return Stack” e la “Trace
Cache” di cui abbiamo già parlato a pagina 116 nel paragrafo relativo alla
specializzazione della cache a pagina 158 illustrando la pipeline NetBurst.
I ritorni sono sempre considerate presi, ma quando una procedura viene
richiamata da diversi posti, una singola predizione delle destinazioni è
insufficiente.
Il Pentium ® 4 prevede un Return Stack che può predire l’indirizzo di una serie di
chiamate alle procedure. Questo incrementa i benefici nello svolgimento di cicli
contenenti una serie di chiamate alle funzioni, nonché riduce la necessità di

Applicazione nei processori Intel® 179
utilizzare procedure inline, dal momento che vengono ridotti i ritardi dovuti alle
chiamate alle procedure.
CORE
Dalla tecnologia Core, viene i salti sono predetti da una unità chiamata “Branch
Prediction Unit” (BTU).
Il BTU contiene le seguenti caratteristiche:
• Return Stack Buffer (RSB) di 16-entry per la accurata predizione delle
istruzioni RET
• Front end queuing of BPU lookups. Il BPU fa predizioni di salti per
32Byte alla volta, raddoppiando la larghezza del motore di fetch.
Il BPU garantisce che i salti “presi” siano predetti senza penalità.
Questo deve essere tenuto in considerazione nella fase di stesura del
software
Le predizioni che vengono effettuate dal BTU sono le seguenti:
• Direct Calls and Jumps. Le Destinazioni sono lette come un “Target
Array” senza guardare se la predizione è “Presa” o “Non Presa”.
• Indirect Calls and Jumps. Queste possono essere entrambe predette
come una destinazione unica o avere più destinazioni in accordo con i
modelli di programma recenti.
• Conditional branches. Predice la destinazione del salto e se deve o no
essere preso

180 Capitolo 5
NEHALEM
La predizione dei salti in questa microarchitettura viene gestita in diversi modi.
Il Branch target buffer è stato migliorato perfezionando l’accuratezza delle
predizioni.
La ridenominazione è supportata con il “return Stack Buffer” per ridurre I
misprediction delle istruzioni di ritorno.
Inoltre il miglioramento dell’hardware perfeziona la gestione delle errate
predizioni dei salti facilitando il recupero delle risorse in modo che il front end
non debba aspettare di decodificare le istruzioni.
5.4.4 VLIW e Tecniche Predicative
Intel ® non ha introdotto queste tecniche nei processori desktop e mobile,
applicandole invece in un progetto specifico per applicazioni server sviluppato
insieme ad Hewlett-Packard ® ed alcune università (come quella dell’Illinois).
I concetti di base che sono alla base di questa architettura possono essere così
sintetizzati:
• Parallelismo a livello istruzione (ILP) che viene esplicitato nelle
istruzioni macchina, piuttosto che essere determinato run-time dal
processore;
• Very long instruction words (VLIW) che contengono gruppi di tre
istruzioni like-RISC;
• Branch predication nelle stesse istruzioni macchina, piuttosto che
predizione dei salti;

Applicazione nei processori Intel® 181
• Speculative loading dei dati e delle istruzioni.
Intel ® ed HP ® hanno attribuito a questa combinazione di concetti l’acronimo
EPIC (Explicity Parallel Instruction Computing).
L’applicazione di questi concetti comporta una importanza fondamentale del
compilatore nei riguardi delle prestazioni della macchina.
Il compilatore è quindi parte integrante di una CPU con approccio EPIC. Le
prestazioni dipendono direttamente dalla qualità delle informazioni fornite dal
compilatore. In accordo con l’approccio RISC, la complessità si sposta
dall’hardware al software.
Inoltre l’architettura EPIC, per migliorare le prestazioni, aggiunge molti registri
(diverse centinaia) per evitare di implementare l’unità di ridenominazione
dinamica dei registri e delle istruzioni predicative per evitare lo svuotamento
delle pipeline.
Il primo prodotto di questa architettura è stato l’Itanium ® , un puro esercizio di
stile che in realtà non è stato mai immesso sul mercato a causa delle sue scarse
prestazioni, mentre negli ultimi anni è stato messo in produzione l’Itanium ® 2.
Figura 5.33 - Loghi dei processori Intel® Itanium® ed Itanium®2

182 Capitolo 5
5.4.5 Multithreading
Il multithreading è stato introdotto dalla Intel ® nei processori Xeon già nel
2002, e successivamente nel Pentium ® 4 nella versione a 3,06 GHz con il nome
di HyperThreading. Il nome è altisonante, ma in realtà viene supportata
l’esecuzione di due thread in modalità Simultaneous Multi-Threading.
La tecnologia HyperThreading fa sì che un singolo processore fisico venga visto
come un multiprocessore logico. Per ogni processore logico c’è uno copia dello
stato architetturale e questi processori condividono un singolo set di risorse
fisiche di esecuzione. Da un punto di vista software o architetturale questo
significa che il sistema operativo ed i programmi possono schedulare processi o
threads a ciascun processore logico come se fossero i processori fisici di un
sistema multiprocessore in cui le CPU condividono cache e RAM. Dal punto di
vista microarchitetturale significa che le istruzioni di ciascun processore logico
verranno eseguite simultaneamente su delle risorse di esecuzione condivise;
questo può comportare un miglioramento dell’utilizzo delle risorse del
processore.
La tecnologia HyperThreading implementata sulla microarchitettura NetBurst
ha due processori logici per ogni processore fisico. La Figura 5.34 mostra uno
schema concettuale delle risorse di un processore con tecnologia
HyperThreading.

Applicazione nei processori Intel® 183
Figura 5.34 - Due copie dell' "Architectural State" consentono ai processori con
tecnologia HyperThreading di essere visti come 2 processori logici [25].
Ogni processore logico contiene un set completo dello stato architetturale.
Lo stato architetturale consiste di registri, inclusi i registri general-purpose,
registri di controllo, registri per lo stato macchine e l’advanced programmable
interrupt controller (APIC). Da un punto di vista software duplicare lo stato
architetturale fa sì che ogni processore fisico appaia come due processori. Ogni
processore logico possiede un interrupt controller, o APIC, in modo tale che le
richieste di interruzione siano inviate al processore logico opportuno.
La tecnologia HyperThreading è pienamente compatibile con software e
hardware precedenti, tuttavia per ottenere il massimo vantaggio sono necessarie
ottimizzazioni. Sistemi operativi come Microsoft ® Windows ® XP e Vista ® sono
già ottimizzati per l’utilizzo di questa tecnologia.

184 Capitolo 5
DIMENSIONI E COMPLESSITÀ DEL DIE.
La maggior parte delle tecniche che migliorano le prestazioni di un processore
da una generazione alla successiva sono complesse e spesso implicano un
incremento significativo delle dimensioni del die e del consumo di potenza.
L’incremento delle prestazioni apportate da tali tecniche non raggiunge mai
un’efficienza del 100%. I limiti del parallelismo del flusso di istruzioni, ad
esempio, implica che il raddoppio del numero delle unità di esecuzione di un
processore non ottenga il raddoppio delle sue prestazioni; similmente il
semplice raddoppio della frequenza di clock non raddoppia le prestazioni perché
un certo numero di cicli viene perso a causa dei branch mispredictions.
Assumendo lo stesso processo tecnologico, l’area del die del processore
aumenta di circa tre volte rispetto all’aumento di prestazioni sugli interi.
La tecnologia HyperThreading può ottenere un grosso incremento di prestazioni
ad un costo minimo in quanto implica un piccolo aumento delle dimensioni del
die. I processori logici condividono strettamente tutte le risorse del processore
fisico incluso caches, unità di esecuzione, branch predictors, logiche di
controllo e buses. L’aumento delle dimensioni del die è dovuto al secondo stato
architetturale, a logica di controllo addizionale e alla replica di alcune risorse
chiave. Questi elementi occupano però una porzione molto limitata della
superficie del processore, come mostra la Figura 5.35.

Applicazione nei processori Intel® 185
Figura 5.35 – L’ Intel ® Pentium ® 4 e le risorse del processore visibili che vengono
dulicate per supportare la tecnologia HyperThreading. L’HyperThreading richiede la
duplicazione anche di altri elementi come puntatori e logiche di controllo, la cui
dimensione è però troppo piccola per essere visualizzata. [25]
Secondo quanto dichiarato da Intel ® , l’aumento delle dimensioni del chip non
superava il 5% [25].
GLI ELEMENTI DUPLICATI
Gli elementi duplicati indicati in Figura 5.35 sono i seguenti:
• La tabella degli alias dei registri: associa i registri architetturali a quelli
fisici rinominandoli. I registri architetturali devono essere tracciati
indipendentemente per ogni processore logico, richiedendo una tabella
separata per ogni processore logico.
• Puntatore all’istruzione successiva e la logica di controllo associata:
permette di tracciare indipendentemente l’evoluzione del programma

186 Capitolo 5
per ogni processore logico. Ci sono due sets di puntatori logici
all’istruzione successiva; uno al trace cache, il quale serve come cache
di istruzione di primo livello e memorizza l’istruzioni decodificate;
l’altro set nella logica di decodifica delle istruzioni che viene usato nel
caso di trace-cache miss.
• Il “return stack predictor”: tiene traccia delle coppie di chiamata/ritorni
dalle funzioni.
• “Instruction streaming buffers” e “trace-cache fill buffers”: sono i
buffers di front end e devono essere anch’essi duplicati per il prefetch
delle istruzioni.
• “Instruction translation look-aside buffer”: la scelta di duplicare questo
buffer è basata sulle sue ridotte dimensioni e sul fatto che risulta più
semplice replicarlo che condividerlo.
• APIC (Advanced programmable Interrupt Controller): per consentire
agli interrupts di arrivare indipendentemente ad ogni processore logico.
CONDIVISIONE DELLE RISORSE
Siccome due thread possono usare contemporaneamente la CPU, occorre
adottare delle strategie per fare in modo che entrambi i thread possano utilizzare
le varie risorse della CPU.
Oltre agli elementi duplicati di cui abbiamo parlato sopra, Intel ® individua 3
diverse strategie per la condivisione delle risorse tra due thread.
• Partition: è il partizionamento vero e proprio delle risorse. Alcune
risorse hardware sono partizionate rigidamente tra i due thread. In altre

Applicazione nei processori Intel® 187
parole, ogni thread può usare esattamente la metà della risorsa. E’
questo il caso della coda delle microistruzioni (le µ-ops) che attendono
di essere instradate alle varie stazioni di prenotazione, e del ROB
(chiamata “retirement queue” nel P4). Questa forma di partizionamento
può ovviamente generare una sottoutilizzazione delle risorse gestite in
questo modo, nel caso in cui un thread non usi tutta la sua parte di
risorsa, che potrebbe essere sfruttata dall’altro thread.
• Full Sharing: ovvero condivisione vera e propria delle risorse. La
risorsa hardware è completamente condivisa. Il primo thread che si
impossessa della risorsa la usa, e l’altro thread deve attendere il suo
turno. Questa forma di gestione delle risorse risolve il problema di una
risorsa idle mentre c’è un thread che vorrebbe usarla. Ovviamente nasce
il problema opposto: un thread potrebbe venire rallentato dal fatto che
l’altro occupa completamente la risorsa. Per questa ragione, nel P4 le
uniche risorse completamente condivise sono quelle presenti in
abbondanza, per cui si ritiene che non si possano verificare problemi di
“starvation” per un thread, ad esempio le cache lines.
• Threshold: ovvero Condivisione controllata delle risorse. In sostanza,
un thread può utilizzare la risorsa in modo dinamico, ma solo fino ad un
certo massimo, in modo che ne rimanga sempre una parte (che può
essere però meno della metà) all’altro thread. Ad esempio, lo scheduler
che invia le µ-ops alle varie stazioni di prenotazione è gestito in questo
modo.

188 Capitolo 5
La Figura 5.36 mostra la condivisione delle risorse nella pipeline del Pentium4.
E’ evidente che la condivisione dinamica con limite massimo delle varie risorse
richiede un monitoraggio a run-time di tale risorse, e quindi dell’hardware
aggiuntivo e dell’overhead computazionale.
Figura 5.36 – In questa vista della execution pipeline della microarchitettura NetBurst,
le aree chiare e scure indicano l’utilizzo delle risorse di due threads avviate sui due
processori logici [25].
APPLICAZIONE NELLE CPU INTEL ®
Abbiamo già accennato come questa tecnologia sia stata inserita nelle CPU con
microarchitettura NetBurst. Intel ® ha abbandonato la tecnologia
HyperThreading nel passaggio ai processori dual core (la cui microarchitettura
può essere considerata come una versione aggiornata della microarchitettura P6,
che non supporta il multithreading). È invece stato reintrodotto nella CPU della
famiglia Nehalem.

Applicazione nei processori Intel® 189
5.4.6 Multicore
Intel ® ha introdotto la tecnologia Multicore già con la microarchitettura
NetBurst (Pentium ® D), utilizzando due core su di un singolo die.
Il primo progetto Intel ® ad avvantaggiarsi della tecnologia dual core ma su die
doppio è stato il Pentium ® D Presler, che però ha avuto successo, nonostante
fosse economico.
Solo con l’avvento della famiglia Core, Intel ® ha cominciato ad utilizzare
l’approccio die Monolitico.
Attualmente, nonostante ci siano progetti per architetture a 80 core (che forse
uscirà nel 2011), Intel ® ha commercializzato ad oggi solamente processori a 2 e
4 core per il settore desktop e mobile, mentre uscirà a breve con un processore
Xeon a 8 core per piattaforme server.
In Figura 5.37 si riportano per completezza gli schemi a blocchi delle unità
funzionali dei processori appena citati; da tali schemi è possibile evincere quali
unità sono condivise e quali replicate per ogni core.

190 Capitolo 5
Figura 5.37 – Condivisione delle risorse in alcune CPU Intel Multicore
5.5 Parallelismo a livello di dato
Innanzitutto quando si parla di parallelismo a livello di dato è necessario
definire le dimensioni dei registri interni e del bus dei dati. In particolare, è
doveroso citare il recente passaggio delle architetture Intel ® dai 32 ai 64 bit.

Applicazione nei processori Intel® 191
Molti dubbi sono sorti riguardo la reale necessità di una tale rivoluzione, a tale
riguardo basti pensare a quello che è accaduto anni prima quando si è passati da
16 a 32 bit: pian piano superando alcuni problemi abbiamo vissuto la
transizione da Windows ® for Workgroup 3.11 a Windows ® 95, fino a giungere
all’attuale Windows ® XP, con notevoli benefici per il mercato degli utilizzatori.
Si noti che già nei tardi anni ‘90 sono stati introdotti i primi processori RISC a
64 bit, la cui applicazione è stata strettamente di tipo server, rimanendo perlopiù
sconosciuti al grande pubblico. Questo non è assolutamente un dettaglio da
trascurare, al contrario la storia delle CPU ci ha dimostrato più volte che la
completa affermazione di un processore su di un altro non dipende solamente da
parametri tecnologici ma anche dall’economicità del prodotto e dal momento di
immissione sul mercato (time-to-market): infatti il dominio dell’architettura x86
nel mercato dei Personal Computer è dovuta in gran parte ai microprocessori
Intel ® 8086 ed 8088, il primo dei quali fu immesso sul mercato con un anno e
mezzo di anticipo rispetto agli avversari a 16 bit di Motorola ® e Zilog ® , mentre
il secondo fu l’unico microprocessore con bus dati esterno a 8 bit a poter
indirizzare fino ad 1 Mbyte di memoria ad un prezzo estremamente basso
mantenendo la compatibilità con i programmi del fratello maggiore 8086, e
contribuendo così notevolmente alla diffusione dell’ISA x86.
E proprio facendo tesoro di tali esperienze, il produttore più pronto ad attuare la
transizione ai 64 bit è stata l’AMD ® che ha introdotto l’Athlon ® 64, che si può
considerare il primo processore a 64 bit per soluzioni di tipo desktop.

192 Capitolo 5
I principali vantaggi derivanti da una semplice transizione dell’architettura da
32 a 64 bit sono l’aumento della grandezza dei registri, che era stato già adottato
anni addietro tramite le estensioni SIMD, e l’aumento della memoria principale
indirizzabile che sale dagli attuali 2³² = 4.3 GByte ad un massimo teorico di 18
milioni di Terabyte. Questo rappresenta un evidente vantaggio soprattutto per i
server che possono per esempio caricare direttamente in
memoria interi database di dimensioni superiori ai 4.3 GByte (anche se i
processori Intel ® Xeon © a 32 bit erano già riusciti ad indirizzare fino a 64 GByte
grazie a particolari tecniche), ma potrà tornare molto utile in un futuro non
molto lontano (3 o 4 anni) anche nelle applicazioni multimediali per sistemi
desktop.
Intel ® ha inoltre adottato come in altri casi una strategia di compatibilità col
passato. Mediante la tecnologia EM64T consente ai processori (quali il
Pentium ® D e i multicore) di lavorare sia a 32 che a 64 bit. Solamente la
famiglia Itanium, invece, nasce esclusivamente a 64 bit.
5.6 Nuove tecnologie per le cache di Intel ®
Intel ® ha compiuto passi avanti nella ricerca e sviluppo di una nuova tecnologia
che consentirebbe la produzione di memorie cache alternative rispetto a quelle
comunemente utilizzate oggi. Si tratta delle memorie cosiddette Floating Body
Cell, alle quali il colosso californiano sta lavorando già dal 2006.

Applicazione nei processori Intel® 193
Le memorie cache vengono utilizzate per conservare dati ai quali è necessario
accedere frequentemente, in modo tale che questi dati possano essere resi
disponibili più velocemente rispetto ad uno stoccaggio su hard disk o sulla
memoria di sistema. E’ chiaro che una maggiore densità di memoria per le
cache comporterebbe interessanti vantaggi.
Le celle delle memorie cache, che di fatto sono memorie SRAM, vengono
realizzate con sei transistor e sono in grado di conservare un bit di
informazione. Obiettivo è di riuscire ad arrivare all’impiego di un solo transistor
per un bit di informazione. Questo tipo di struttura è giù utilizzato nelle normali
memorie DRAM, le cui celle sono costituite da un transistor, che tuttavia
risultano troppo lente per un impiego come memorie cache.
Il principio sul quale si basano le memorie di tipo Floating Body Cell prevede la
conservazione di una carica elettrica in una cella di memoria interposta tra uno
strato di Silicon-On-Insulator e un gate di un transistor. Grazie all’affinamento
dei processi produttivi, Intel ® ha potuto realizzare un prototipo utilizzando un
gate metallico da 45 nanometri e posizionando la cella di memoria tra esso e un
substrato SOI (silicon-on-insulator) di appena 22 nanometri di spessore.
Le memorie FBC risultano comunque meno veloci rispetto alle memorie SRAM
ma sono meno costose da produrre. La possibilità di utilizzare un solo transistor
per ogni bit di informazione consente inoltre di poter raggiungere elevate

194 Capitolo 5
densità di memoria permettendo in un futuro di realizzare processori con elevati
quantitativi di memoria cache integrata.
Intel ® non ha tuttavia rivelato particolari prospettive di impiego per questo
nuovo tipo di memorie, precisando che prima di poter giungere alla fase di
implementazione ed integrazione in un chip è necessario dover fronteggiare una
serie di problemi: attualmente infatti le più diffuse implementazioni SOI
prevedono un substrato dallo spessore maggiore rispetto a quello utilizzato per
la realizzazione del prototipo di Intel ® e per i processi produttivi attuali non è
ancora possibile realizzare un unico chip con substrati di spessori differenti.
5.7 Set di Istruzioni
5.7.1 IA-32: CISC o RISC?
Le basi dell’architettura IA-32 sono state poste nel 1978 con il processore 8086
a 16-bit, macchina CISC tradizionale, che si impose subito sul mercato;
sull’onda del successo di questo processore nacquero altri processori a 16-bit,
come l’8088 e l’80286, che mantennero la compatibilità dell’ISA x86. Ma il
primo processore ad architettura IA-32 è stato sicuramente l’80386 che ha
segnato anche la grande transizione dai 16 ai 32 bit. Già nell’80486 si sono
cominciate a vedere le prime influenze di progettazione di tipo RISC con
l’introduzione del concetto di pipeline (una pipeline a cinque stadi: prefetch,
decodifica, generazione dell’indirizzo, esecuzione, Write-Back), ma ancora
senza alcun elemento superscalare. Infatti, è stato con l’introduzione del

Applicazione nei processori Intel® 195
Pentium ® che si è introdotto il concetto di superscalarità con l’adozione di due
unità di esecuzione ad interi poste sulle due pipeline distinte u e v, capaci di
eseguire insieme due istruzioni per clock.
Un ulteriore evoluzione verso una tecnologia intermedia tra CISC e RISC,
possiamo dire si sia avuta con l’uscita del Pentium ® 4, ovvero con la
microarchitettura NetBurst ® . Le operazioni compiute dal Pentium ® 4 possono
essere riassunte così [26]:
• Il processore carica le istruzioni di lunghezza variabile (fino ad un
massimo di una word pari a 32 bit) dalla memoria nell’ordine previsto
dal programma;
• Ogni istruzione del Pentium ® 4 viene tradotta in una o più istruzioni
like-RISC di lunghezza prefissata, chiamate µ-ops (un’istruzione
contiene da 1 a 4 µ-ops di tipo RISC, ognuna delle quali è lunga 118
bit);
• Il processore esegue le µ-ops in una pipeline superscalare grazie ad un
algoritmo di esecuzione fuori ordine;
• Alla fine viene restituito il risultato di ogni µ-ops al corrispondente
registro nell’ordine originale del programma.
In effetti, l’architettura del Pentium ® 4 è composta da una parte esterna di tipo
CISC con un cuore di tipo RISC. Le µ-ops passano attraverso una pipeline
lunga ben 31 stadi (nel Pentium ® 4 con core Prescott); in alcuni casi, le µ-ops
richiedono più stadi di esecuzione, rendendo ancora più lunga la pipeline.

196 Capitolo 5
Perciò possiamo indicare questo tipo di filosofia di progettazione con il termine
Post-CISC[15].
Figura 5.38 – Approccio Post-CISC [15]
Questa soluzione ha permesso di sfruttare la bontà dell’approccio RISC pur
mantenendo la “back-compatibility” con i processori precedenti e decretando
così il successo di questa architettura.
5.7.2 Tecnologia SIMD
Sempre per quanto riguarda la computazione in parallelo, ci si è accorti subito
che l’Instruction set x86 risultava inadatto a questo scopo, ma dovendo essere
mantenuto per ragioni di compatibilità all’indietro si è proceduti ad un
progressivo aumento di istruzioni e di registri specializzati (pratica in auge
anche negli attuali processori RISC), in modo da consentire di eseguire più

Applicazione nei processori Intel® 197
computazioni con una singola istruzione. Il termine Single Instruction Multiple
Data (SIMD), che significa proprio istruzioni che permettono di manipolare più
dati con un singolo comando, sta proprio ad indicare tutte quelle espansioni
(MMX, SSE, SSE2, etc) che si sono succedute nel tempo.
Le SIMD si propongono l’obiettivo di aumentare le prestazioni di applicazioni
grafiche 3D, di riconoscimento vocale, di editing video e multimediali che
abbiano come caratteristica:
• parallelismo intrinseco;
• modelli di accesso in memoria regolari e ricorrenti;
• operazioni ricorrenti sui dati;
• flusso di controllo senza dipendenze dei dati.
Figura 5.39 - Estensioni dell'Instruction set nei processori Intel ® [27]
Di seguito sono brevemente illustrate le sei generazioni di istruzioni SIMD
implementate da Intel ® nei suoi processori:
MMX
Fu introdotta per la prima volta in una versione del Pentium, chiamato appunto
Pentium ® MMX. Prevedeva l’utilizzo degli 8 registri Floating-Point da 80 bit,
come registri a 64 bit da utilizzare con le unità integer, chiamandoli registri

198 Capitolo 5
MMX, e introduceva le istruzioni per potere eseguire operazioni su word e
double word.
Le istruzioni MMX tuttavia fallirono l’obiettivo di portare i benefici del
paradigma SIMD nei comuni personal computer. E questo si era avuto per due
motivazioni principali: lo scarso supporto fornito da Intel ® agli sviluppatori e la
mancanza di istruzioni utilizzabili nell’emergente mondo della grafica 3D. Le
istruzioni MMX manipolano numeri interi e quindi non sono in grado di gestire
le trasformazioni geometriche dei videogiochi perché in questo compito sono
richieste operazioni floating point; inoltre l’utilità di un set di istruzioni capace
di accelerare tali calcoli si è resa visibile in maniera pesante con l’affermazione
di API dedicate alla gestione del 3D quali le Direct 3D e OpenGL, capaci di
astrarre lo sviluppatore dal codice ottimizzato vero e proprio[28].
SSE
Col Pentium ® III viene fatta una estensione del set di istruzioni chiamato
Internet SSE (Internet Streaming SIMD Extension) o, più semplicemente SSE;
questo set metteva a disposizione 8 registri reali a 128 bit chiamati XMM e le
relative istruzioni per compiere operazioni in virgola mobile a singola
precisione. Tra le istruzioni SSE, ne esistono anche 4 per il data prefetch.

Applicazione nei processori Intel® 199
Figura 5.40 - MMX ed SSE a confronto[29]
L’obbiettivo che i progettisti Intel ® si erano proposti, era di raggiungere un
incremento delle prestazioni floating point tra il 70% e il 100%, ritenuto
sufficiente a rendere percettibile la differenza e quindi competitivo il prodotto,
al minor costo possibile in termini di incremento della complessità e aumento
delle dimensioni del die. Nel contempo si decise di estendere la tecnologia
MMX (quale ad esempio istruzioni per facilitare le codifiche in tempo reale di
tipo MPEG-2) e di introdurre istruzioni per mascherare la latenza che deriva
dalle notevoli dimensioni, in termini di memoria, dei dati implicati in
applicazioni video. Il termine Streaming si riferisce appunto alla presenza di
istruzioni che permettono il prefetch di dati simultaneamente all’elaborazione di
altri già disponibili velocizzando il flusso (stream) dei dati in ingresso e in
uscita dal processore nascondendo nel tempo di esecuzione la latenza del fetch.
Una delle scelte basilari nella definizione di un’architettura SIMD consiste nel
definire su quanti dati contemporaneamente si vuole operare in modo da

200 Capitolo 5
raggrupparli in un vettore di dimensioni adeguate, che costituir`a il nuovo tipo
di dato cui faranno riferimento le istruzioni SIMD.
Il team di sviluppatori di Intel ® ritenne che la computazione parallela di 4
floating point a singola precisione (32 bit) e quindi di un data-type SSE da 128
bit consentisse un raddoppio complessivo delle performance senza aggiungere
eccessiva complessità essendo tendenzialmente ottenibile con un doppio ciclo
della esistente architettura a 64 bit. La scelta di operare su 2 floating point non
avrebbe consentito di ottenere paragonabili prestazioni mentre l’adozione di un
datapath di 256 bit (8 FP da 32 bit) avrebbe determinato un impatto maggiore in
termini di complessità. Mentre i 128 bit possono essere separati in 2 istruzioni
da 64 bit che possono essere eseguite, con 256 bit si sarebbe dovuto, per
mantenere lo stesso throughput, raddoppiare la larghezza delle unità di
esecuzione e quindi la banda di memoria per alimentarle. Stabilito il datapath di
128 bit si poneva la domanda se implementare i registri a 128 bit nei registri
MMX/x87 esistenti oppure definire un nuovo stato con registri appositi. La
prima scelta, analoga a quella attuata con l’estensione alla tecnologia MMX,
avrebbe comportato il vantaggio della piena compatibilità con il sistema
operativo ma lo svantaggio di dover condividere i registri, già penalizzanti,
della architettura IA-32. La seconda scelta avrebbe comportato il problema di
dover adattare i sistemi operativi, problema poco sentito da Intel ® data la sua
forza contrattuale, ma avrebbe avuto il vantaggio di facilitare i programmatori e
la possibilità di eseguire contemporaneamente istruzioni MMX, x87 o SIMD-
FP. I progettisti Intel ® optarono per aggiungere un nuovo stato architetturale,

Applicazione nei processori Intel® 201
per la prima volta dai tempi dell’aggiunta di quello x87 ai tempi del i386 nel
1985, con la definizione di 8 nuovi registri da 128 bit (chiamati registri XMM),
cosa che non era stata fatta con l’introduzione delle istruzioni MMX che
operavano sugli stesi registri fisici della Floating Point Unit. [28]
SSE2
Introdotto con il Pentium ® 4, ha permesso di compiere operazioni in virgola
mobile a doppia precisione, nonché moltiplicazioni tra interi a 32bit (importanti
per il processing audio di qualità). L’estensione ha aggiunto altre 144 istruzioni
SIMD che prendono il nome di SSE2, che hanno colmato buona parte delle
mancanze presenti in SSE.
SSE3
Nella versione del Pentium ® 4 con core Prescott è arrivata l’ultima estensione
SSE3, che aggiunge altre 13 nuove istruzioni e ne hanno semplificato l’utilizzo.
SUPPLEMENTAL SSE3
Nei processori con microarchitettura Core, sono ora disponibili 32 nuove
istruzioni, tra le quali operazioni di allineamento e multiply-add, che
permettono un miglioramento delle prestazioni.
SSE4
È la più grande estensione del set di istruzioni in termini di portata e di impatto
dal SSE2. Prevede diverse “Compiler Vectorization Primitives” per ancora
maggiori prestazioni multimediali, come le nuove ed innovative “string

202 Capitolo 5
processing instructions”. L’esordio di questa estensione si è avuto con i
processori Penryn. Per lo sviluppo di questo progetto, Intel ® ha lavorato con
diversi partner, incluso ISVs (indipendent sofwtare vendors) e OSVs (operating
system vendors), in modo da sviluppare SS4 come un nuovo instruction set
standard.
SSE4 prevede decine di nuove istruzioni innovative che possono essere
raggruppate in tre categorie:
• SSE4 Vectorizing Compiler and Media Accelerators: Aggiunge molte
nuove “compiler vectorization primitives” (operazioni fondamentali a
partire dalle quali si possono costruire quelle più complesse) che
estendono le funzionalità dell’architettura Intel ® , consentendo
l’ottimizzazione delle prestazioni e la riduzione della potenza utilizzata.
I compilatori che faranno uso di queste primitive, saranno in grado di
garantire questi benefici per un ampio numero di applicazioni, incluse
le applicazioni server HPC (high performance computing).
Le nuove primitive includono miglioramenti sulle operazioni intere e
floating point, il supporto per operazioni DWORD e QWORD
pacchettizzate, nuove operazioni a singola precisione FP, operazioni
veloci tra i registri, operazioni in memoria performance-optimized, etc.
Le tipiche applicazioni che traggono beneficio da questa architettura
sono quelle che riguardano l’elaborazione delle immagini, la grafica,
l’elaborazione video, la generazione di immagini 3D, multimediali,

Applicazione nei processori Intel® 203
giochi, ad alta intensità di lavoro con le memorie le HPC e molte
ancora.
• SSE4 Efficient Accelerated String and Text Processing: sono presenti
nuove istruzioni per l’elaborazione di stringhe e testo ottimizzate. Tra
queste ricordiamo quelle di comparazione avanzata di pacchetti di
stringhe, che possono eseguire più operazioni di confronto e di ricerca
in una singola istruzione. In generale, ciascuna di queste nuove
istruzioni ha un ricco set di funzionalità innovative sulla elaborazione
delle stringhe che nelle ISA precedenti si potevano eseguire solo con un
elevato numero di istruzioni.
Queste istruzioni permettono un impulso prestazione per una vasta
gamma di applicazioni di elaborazione dei dati, di ricerca e in genere su
tutte le applicazioni basate su testo. Tra queste ricordiamo le
applicazioni che coinvolgono database, ricerche testuali, scansioni
antivirus, librerie di string process come ZLIB, Token
parsing/recognizing applications come i compilatori e applicazioni
“state machine oriented”.
SSE4 Application Targeted Accelerators. Esse estendono le capacità
dell’architettura Intel ® . Si tratta di piccole istruzioni a bassa latenza
destinate all'ottimizzazione di specifiche applicazioni; ad esempio vi è
la possibilità di eseguire una serie di operazioni su codice di linguaggi
specifici, come XML, e in generale per manipolare le stringhe di
caratteri [30]

204 Capitolo 5
Osserviamo infine come l’Intel ® sia sempre riuscita ad imporsi sugli altri
costruttori per questo tipo di istruzioni, diventando lo standard di facto. Un
esempio lampante si è avuto con l’introduzione delle SSE2 in concomitanza con
il 3DNow! di AMD ® . La vasta adozione dell’estensione SSE2 presso le
maggiori software house ha costretto l’AMD ® a tornare sui propri passi
ridimensionando le proprie ambizioni espansionistiche e adottando suo
malgrado le estensioni SIMD dell’ Intel ® (pagandone le royalty).
5.8 Il risparmio energetico
Come descritto nel paragrafo 2.2, i problemi relativi alla potenza dissipata sono
sempre più importanti. Intel ® ha cominciato inizialmente su famiglie apposite
(Mobile) e solo ultimamente ha applicato modifiche architetturali nella
progettazione dei layout di tutti i processori per ottenere la riduzione del
consumo di energia.
La tabella e il grafico seguenti mostrano il TDP di alcuni processori Intel ® per
piattaforme desktop fino al Pentium ® D. Si rimanda al Capitolo 6 le innovazioni
microarchitetturali che Intel ® ha inserito nell’ultima generazione di processori
Nehalem.

Applicazione nei processori Intel® 205
Clock ⎡MHz
⎤
Serie Clock TDP [W]
TDP ⎢
⎣ W ⎥
⎦
Pentium ® II 233 34,80 6,6954023
Pentium ® II (Deschutes) 266 16,80 15,8333333
Pentium ® II (Klamath) 266 38,60 6,89119171
Pentium ® II (Klamath) 300 43,00 6,97674419
Pentium ® II (Deschutes) 400 24,30 16,4609053
Pentium ® II 450 27,10 16,6051661
Pentium ® III 450 25,30 17,7865613
Pentium ® III 500 28,00 17,8571429
Pentium ® III-E 500 13,20 37,8787879
Pentium ® III-(B) 600 34,50 17,3913043
Pentium ® III-E(B) 600 15,80 37,9746835
Pentium ® III 700 18,30 38,2513661
Pentium ® III 733 19,10 38,3769634
Pentium ® III 800 20,10 39,800995
Pentium ® III 850 25,70 33,07393
Pentium ® III 866 26,10 33,1800766
Pentium ® III (SECC2) 933 25,50 36,5882353
Pentium ® III (FC-PGA) 933 26,40 35,3409091
Pentium ® III (FC-PGA) 1000 24,10 41,4937759
Pentium ® III (FC-PGA2) 1000 29,00 34,4827586
Pentium ® III (FC-PGA2) 1200 29,90 40,1337793
Pentium ® III (FC-PGA2) 1266 29,50 42,9152542
Pentium ® III (FC-PGA2) 1400 31,20 44,8717949
Pentium ® 4-C 2400 67,60 35,5029586
Pentium ® 4 HT 3060 81,80 37,408313
Pentium ® 4 520J 2800 84,00 33,3333333
Pentium ® 4 560J 3600 115,00 31,3043478
Pentium ® D 805 2666 95,00 28,0631579
Pentium ® D 820 2800 95,00 29,4736842
Pentium ® D 920 2800 95,00 29,4736842
Pentium ® D 940 3200 130,00 24,6153846
Pentium ® D 960 3600 130,00 27,6923077
Figura 5.41: TDP dei principali processori Intel ® per desktop dal Pentium ® II al
Pentium ® D

206 Capitolo 5
TDP [W]
140,00
120,00
100,00
80,00
60,00
40,00
20,00
0,00
0 1000 2000 3000 4000
Frequenza CPU [MHz]
Figura 5.42 : TDP vs Frequenza di clock
Pentium2
Pentium3
Pentium 4
PentiumD

Capitolo 6
Il nuovo processore Core i7
Intel ® Core i7 è il nome con la quale le nuove CPU Quad Core Intel ® , hanno
fatto il loro debutto sul mercato dei microprocessori.
I nuovi processori di casa Intel ® , presentano
molte innovazioni dal punto di vista
architetturale e prestazionale, battendo di fatto i
"vecchi" Core 2 duo e Quad in tutti i test
effettuati.
Prima di approfondire quelle che sono le
caratteristiche della nuova architettura, ecco un
articolo, che traccia una linea (molto) generica
sulla nuova famiglia di processori Intel ® .
6.1 Elementi base della nuova architettura
Come già citato in precedenza, la nuova famiglia di CPU con microarchitettura
Nehalem presenta importanti novità. Il progetto di ingegnerizzazione Intel ® ,
mira ad ottenere il massimo delle prestazioni, in tutti i settori: Server, desktop e
notebook.
Di fatto, l’adattamento alle varie categorie, è stato reso possibile grazie alla
flessibilità di questa nuova architettura. Intel ® ha lavorato e lavorerà su tutti

208 Capitolo 6
quegli elementi specifici che, accomunano tutte le categorie sopra menzionate,
tese a migliorare le prestazioni, l’affidabilità e i consumi.
L’implementazione dei nuovi Core i7 all’interno dei sistemi notebook, mira
decisamente al contenimento dei consumi, mentre per i processori destinati
all’utilizzo nei server, saranno implementati quantitativi maggiori di cache L3.
Le principali novità introdotte in questa architettura sono:
• Architettura quad core unificata: Intel ® per la nuova famiglia di
processori quad core ha adottato un design di tipo monolitico,
posizionando tutti e quattro i core su un unico die, da alloggiare
successivamente all’interno del processore (vedi paragrafo 3.2.3).
• Memory controller DDR3 integrato: novità assoluta per i processori
Intel ® . AMD ® introdusse questa tecnologia sin dal lontano 2003 con la
famiglia Opteron, con tutti i benefici che ne conseguirono.
• Ritorno alla tecnologia HyperThreading: Soluzione adottata da Intel ®
nel lontano 2004 sui processori Pentium ® 4 (vedi paragrafo 5.4.5), poi
abbandonata con l’arrivo delle più performanti CPU Core 2 duo.
• Introduzione del bus QPI: acronimo di “Quick Path Interconnect”, in
sostituzione al classico “front side bus” o FSB. Questa tecnologia sarà
adottata già, nelle prime versioni dei processori Core i7.
• Istruzioni SSE4.1: Introdotte per la prima volta nella famiglia Penryn,
queste istruzioni sono la diretta evoluzione delle precedenti SSE4.0.

Il nuovo processore Core i7 209
6.2 Design modulare
Un’altra interessante soluzione adottata da Intel ® con le nuove CPU e,
l’introduzione di un “design modulare”. Cosa significa?
I primi Core i7 integrano 731 milioni di transistor, costruiti su un processo
produttivo di 45 nanometri. Le successive evoluzioni, fermo restando che venga
sfruttato il design modulare, integreranno nuove funzionalità, tese ad aumentare
le performance generali dell’architettura Nehalem.
Intel ® dal canto suo, ha già presentato, al IDF Fall 2008, la serie Nehalem EX,
CPU specificatamente dedicate ai sistemi server. Questa serie che, non vedrà la
luce, prima dalla fine del 2009, integrerà al suo interno 8 core fisici.
Sempre all’IDF 2008 è stata presentata l’architettura che, dovrebbe concorrere
direttamente con le soluzioni AMD ® Fusion. Vale a dire l’integrazione in alcune
soluzioni Nehalem, di una GPU, che occuperebbe la fascia bassa del mercato.
Questa soluzione vedrà la luce non prima del 2010.
6.3 Architettura dell’engine
Prima di tutto gli ingegneri hanno aggiunto il supporto Macro-ops in modalità
64 bit. Scelta giustificata per questa architettura che, non nasconde le sue
ambizioni per il mercato server. L’utilizzo continuo delle Macro-ops è reso
possibile grazie al maggior numero di istruzioni che l’architettura Nehalem è in
grado di eseguire
Le CPU della famiglia Nehalem integrano un Execution Unit a 4 vie, capace, di
eseguire 4 operazioni di Decode, Rename e Retire in un singolo ciclo di clock.

210 Capitolo 6
Questa tecnologia, già presente nella precedente generazione Core 2, non è mai
stata sfruttata a fondo a per via dal codice disponibile sul mercato. Per questo
motivo Intel ® è intervenuta in Nehalam espandendo il più possibile i Buffers
interni, allo scopo di incrementare i benefici di un’architettura basata sul
parallelismo.
Un’altra interessante soluzione introdotta dalla precedente architettura e
migliorata in Nehalem, è LSD, acronimo di “Loop Stream Director”.
LSD non è altro che un buffer che immagazzina istruzioni, prossime
all’esecuzione. Quando la CPU rileva un Loop (stessa istruzione ripetuta più
volte), grazie al Loop stream Director, non è necessario effettuare un branch
prediction o recuperare i dati dalla cache L1. In questo senso, possiamo dire
che, LSD funge da memoria cache.

Il nuovo processore Core i7 211
Figura 6.1 - Introduzione del "Loop Stream Detector"
I guadagni che ne conseguono dall’utilizzo dell’LSD sono doppi: da una parte
troviamo un minor consumo energetico, in quanto non vengono eseguite
operazioni inutili, dall’altra avremo un incremento prestazionale grazie alla
riduzione della pressione, sulla cache L1.
Ulteriori miglioramenti sono stati apportati al Branch prediction. Intel ® non
fornisce molti dati riguardanti i nuovi predictor, ma si sa che sono composti da
due livelli. Il primo è identico a quello utilizzato nei processori Core 2, mentre
il secondo, con un accesso più lento, è in grado di immagazzinare più
informazioni storiche. Intel ® tende a sottolineare come questa soluzione porti ad
un incremento prestazionale con alcune applicazioni, che utilizzano un grosso
volume di codice, come i database.

212 Capitolo 6
6.4 HyperThreading, ritorno al passato
Il debutto delle CPU Core i7, vede il ritorno della tecnologia HyperThreading
(vedi paragrafo 5.4.5). Questa soluzione introdotta nella serie Intel ® Pentium ® 4,
era stata abbandonata con l’arrivo sul mercato delle più performanti CPU Core
2 duo e Quad.
Per quale motivo Intel ® ha reintrodotto questa tecnologia solamente ora, con
l’arrivo dell’architettura Nehalem?
I motivi sono sostanzialmente due:
• In primis i nuovi processori Core i7 presentano per loro natura
un’architettura molto ampia. Questa tecnologia trae beneficio
direttamente dal Memory controller integrato.
• Come seconda cosa, i bassi costi di produzione che ne conseguono
dall’adozione di questa soluzione.
La tecnologia HyperThreading permette di avere a disposizione un numero
doppio di core logici, rispetto a quelli presenti realmente all’interno del
processore. Nel caso dei nuovi Core i7, con l’HyperThreading attivato avremo a
disposizione del sistema operativo ben otto core logici.
I benefici offerti da questa soluzione sono notevoli, soprattutto se utilizzata con
applicazioni che operano su più core contemporaneamente.
Intel ® ha fornito solamente i dati di quelle applicazioni che, per loro natura
sfruttano tutti i core presenti all’interno della CPU.
Come già scritto in precedenza, la tecnologia Simultaneous multithreading trae
beneficio direttamente dal Memory controller integrato. Il controllo della

Il nuovo processore Core i7 213
memoria integrato all’interno del processore, soprattutto nell’implementazione
triple channel, delle prime versioni delle CPU core i7, permette di avere a
disposizione quel quantitativo di banda passante (bandwidth) delle memoria, di
cui la tecnologia HyperThreading ha bisogno per operare al meglio.
È importante sottolineare come l’implementazione di più core fisici all’interno
di un processore, comporti prestazioni nettamente superiori rispetto a soluzioni
con Simultaneous multithreading integrato. In altre parole, CPU che adottano la
tecnologia HyperThreading non raggiungeranno mai le prestazioni di un
processore con otto core nativi. È però vero che, l’implementazione del
Simultaneous multithreading per Intel ® risulta essere un’operazione abbastanza
semplice e sopratutto "economica". Il numero ridotto di transistor utilizzato,
uniti alla flessibilità di questa architettura, creano il connubio ideale tra
prestazioni e costi di produzione.
6.5 Modelli
I primi modelli presentati dal produttore californiano, occuperanno la fascia
medio-alta del mercato delle CPU, spodestando dal trono le attuali soluzioni
Core 2 Duo e Quad Q9550/9770, anche se non si prevede per quest’ultimi, una
rapida uscita di scena, per via dei prezzi elevati, che presentano le nuove
soluzioni Core i7.
I modelli attualmente disponibili presentano tutte le caratteristiche analizzate,
fatta eccezione per alcuni modelli destinati al mercato server. Stiamo parlando
ovviamente dei processori della famiglia Xeon.

214 Capitolo 6
I processori destinati al segmento desktop e già disponibili sul mercato sono:
• Intel ® Core i7 920: Frequenza di clock pari a 2.66 GHz, bus QPI di 4.8
gigatransfert/secondo, Cache L3 8mbytes, memoria DDR3-1333, TDP
massimo 130 Watt, Overspeed protection abilitata.
• Intel ® Core i7 940: Frequenza di clock pari a 2.93 GHz, bus QPI di 4.8
gigatransfert/secondo, Cache L3 8 mbytes, memoria DDR3-1333, TDP
massimo 130 Watt, Overspeed protection abilitata.
• Intel ® Core i7 965 Extreme: Frequenza di clock pari a 3.2 GHz, bus
QPI di 6.4 gigatransfert/secondo, Cache L3 8 mbytes, memoria DDR3-
1333, TDP massimo 130 Watt, Overspeed protection disabilitata.
I modelli 920 e 940 presentano le stesse
caratteristiche tecniche, fatta eccezione per
la frequenza di clock. Differenze sostanziali
si notano invece con il modello top di
gamma della famiglia Nehalem, ovvero il
Core i7 945 Extreme. Quest’ultimo vede incrementata la frequenza di clok fino
a 3.2 GHz, mentre il bus QPI raggiunge i 6.4 gigatransfert/secondo. Ultimo
elemento di rielievo per il 965 Extreme, è sicuramente l’Overspeed protection
disabilitata.
A partire dal secondo trimestre 2009, i modelli 965 Extreme e 940, saranno
sostituiti dai nuovi 975 Extreme e 950.
Il primo sarà caratterizzato da una frequnza di clock pari a 3.33 GHz, contro i
3.2 GHz del modello attuale. Il secondo presenterà una frequenza operativa di

Il nuovo processore Core i7 215
circa 3.06 GHz, contro i 2.83 GHz del modello 940. Il più piccolo della
famiglia, 920, non verrà per ora sostituito.
I modelli della nuova serie, compreso il 920, saranno accomunati dell’utilizzo
dello stepping D0. Questa ottimizzazione dovrebbe consentire margini di
overclok più elevati, oltre a una probabile diminuzione delle temperature.
6.6 Architettura della cache
Intel ® ha introdotto importanti novità per quanto riguarda la struttura della
cache. Se per la generazione precedente, Penryn, veniva utilizzata una cache L1
per ciascun core e, una cache L2 suddivisa fra tutti i core, ora, con i nuovi Core
i7 troviamo un cache L3, ovvero un terzo livello unificato fra i quattro core.
Figura 6.2 - Schema a blocchi dei livelli di cache nei Core i7.

216 Capitolo 6
La cache L1 con una grandezza di 64kbytes, suddivisa in due blocchi da
32bytes, presenta tempi di latenza superiori rispetto a quanto accadeva nelle
CPU Core 2, essendo passati da tre a quattro cicli di clock.
La cache L2 invece, differisce in modo sensibile da quella implementata nelle
precedenti soluzioni. Non più unificata fra tutti i core, ma specifica per ognuno
di essi. Nel specifico, troviamo una quantitativo pari a 256kbytes, con una
latenza pari a 10 cicli di clock dal load, alla fuori uscita dei dati dalla cache.
La cache L3 introdotta per la prima volta su processori Intel ® , è di tipo
unificato; il suo quantitativo è pari a 8Mbytes. Tutta via, la cache L3 potrebbe
assomigliare alla cache L2 utilizzata nelle CPU Core 2 Quad. Analisi più
approfondite però fanno sorgere una sostanziale differenza: nell’architettura
Nehalem troviamo una cache L3 unificata tra tutti e quattro i core, mentre nei
processori Core 2 Quad la cache L2 era suddivisa in due blocchi da 6Mbytes
ciascuno, i quali venivano associati a una singola coppia di core.
Non a caso, nelle schede, che identificano le caratteristiche del processore (in
questo caso CPU Core 2 Quad) è possibile trovare la quantità di cache L2 divisa
per due (cache L2 = 6x2Mbytes).
L’architettura della cache integrata in Nehalem, è di tipo inclusivo: nel
momento in cui un dato, non è presente nella cache L3, l’architettura inclusiva,
fa si che, il suddetto dato non risieda ne nella cache L1 ne tanto meno in quella
L2. Di conseguenza la CPU andrà a recuperare quel dato mancante direttamente
nel memory controller, evitando passaggi inutili (attraverso le varie cache) che,
rallenterebbero il sistema.

Il nuovo processore Core i7 217
6.7 Memory controller integrato
L’ennesimo aspetto interessante, introdotto da Intel ® nella nuova architettura
Nehalem, è senz’altro l’implementazione del memory controller all’interno
delle CPU Core i7.
Dal canto suo, Intel ® segue quanto già effettuato dall’acerrimo rivale AMD ®
che aveva introdotto il memory controller all’interno delle CPU destinate al
mercato Server.
Il memory controller utilizato da Intel ® è di tipo DDR3 a triplo canale,
compatibile con i moduli DDR3 a 1066 MHz e DDR3 a 1333 MHz, la cui
larghezza di banda massima teorica è di 32 GB/s (gigabyte per secondo).
Le successive versioni dei processori Core i7, integreranno un memory
controller a doppio canale (dual-channel). Scelta giustificata, al fine di ridurre i
costi, considerando che questa architettura sarà destinata anche ai segmenti
value del mercato informatico.
I vantaggi del memory controller integrato non si fermano di certo qui. Intel ® ha
lavorato affinché le prestazioni migliorassero anche in ambito server.
6.8 NUMA
NUMA, acronimo di “non unifor memory acces”, permetterà di accedere al
memory controller di altri processori montati sulla stessa scheda madre. Ci
riferiamo ovviamente a piattaforme di tipo multi - socket. L’accesso ai dati nel
memory controller di un altro processore, avverrà con un impatto prestazionale
in termini di larghezza di banda e latenza. Il trade-off potrà però essere ridotto

218 Capitolo 6
grazie a future applicazioni specificatamente sviluppate per l’architettura
NUMA.
6.9 QuickPath Interconnect
Con la nuova architettura Nehalem, Intel ® introduce un nuovo bus di
collegamento tra processore, chipset e memory controller. Stiamo parlando del
nuovo “QuickPath Interconnect”, il sostituto della oramai vecchia architettura
Front Side Bus, meglio conosciuta come FSB.
Con il nuovo bus di connessione, di tipo point-to-point si raggiungono velocità
teoriche di 12.5 gbps. Il limite, sempre teorico, di trasferimento sui link
bidirezionali è attestato intorno ai 25 gbps. In futuro Intel ® potrebbe
incrementare la velocità di trasferimento dati tramite QPI, alzando le frequenze
di trasmissione di quest’ultimo.
Come accaduto per i memory controller integrato, Intel ® segue un approccio
molto simile a quello adottato da AMD ® con il suo bus di connessione
denominato HyperTransport.
Data quindi la somiglianza fra le due tipologie di connessione, il bus QPI,
rappresenterà per Intel ® un indubbio vantaggio unito alla nuova architettura
Nehalem, soprattutto in ottica server.

Il nuovo processore Core i7 219
6.10 Istruzioni SSE 4.2
All’interno dei nuovi processori Core i7, Intel ® ha introdotto un nuovo set di
istruzioni appartenenti alla famiglia SSE. In Nehalem, queste istruzioni
giungono alla versione 4.2 come anticipato nel paragrafo 5.7.2.
6.11 Turbo Mode
Turbo Mode, questo è il nome scelto da Intel ® , per identificare quello che è di
fatto un overclock dinamico della CPU.
Una simile tecnologia è già stata introdotta da Intel ® nelle CPU Core 2 Duo, per
sistemi notebook. Sussistono però, alcune importanti differenze.
Nei processori Core 2 Duo, la tecnologia Turbo Mode interviene solamente
quando, uno dei due core entra in modalità idle (carico minimo), mantenendo
un TDP massimo, entro i limiti previsti di default. In questo caso, il processore
può entrare nella modalità turbo mode solamente quando, uno dei due core si
trova in modalità risparmio energetico.
In Nehalem la suddetta tecnologia è stata rivisitata totalmente: se un core risulta
essere inattivo, viene attivata immediatamente la funzione di risparmio
energetico, incrementando la frequenza di clock dei restanti core attivi.
L’incremento della frequenza di clock avviene a seconda del carico di lavoro
richiesto e delle condizioni di funzionamento della CPU. Se il valore TDP di un
dato istante, è tale da permettere un incremento delle frequenze di clock,
automaticamente il processore opererà in questa direzione.

220 Capitolo 6
Figura 6.3 - Schema di base del funzionamento in Turbo Mode nel caso di alcuni core
disattivati.
Analizzando quindi, quanto scritto sopra, è possibile definire la tecnologia
Turbo mode come una sorta di overclock in tempo reale.
La modalità Turbo Mode, può intervenire anche quando tutti i core presenti
all’interno della CPU, sono utilizzati al 100%, sfruttando margini residui di
dissipazione termica e contando su un TDP, che in quel particolare istante è
inferiore al valore massimo definito di default, dalla casa produttrice.
Appare evidente, che utilizzare un ottimo sistema di dissipazione, non può che
giovare, incrementando sempre più i margini d’intervento della tecnologia
Turbo Mode.
Allo stato attuale, considerando i sistemi di raffreddamento odierni, la modalità
Turbo Mode, può alzare le frequenze dei singoli core di una o due volte la
frequenza di clock base del processore. Vale a dire che l’incremento delle
frequenze operative della CPU, possono essere di 133mhz o 266mhz.
La modalità Turbo Mode, è comunque disattivabile tramite bios.

Il nuovo processore Core i7 221
Figura 6.4 - Schema di base del funzionamento in Turbo Mode nel caso di tutti i core
attivi.
6.12 Consumi
Intel ® ha introdotto una gestione del risparmio energetico molto sofisticata,
controllata da una unità funzionale apposita detta PDU (Power Control Unit).
PCU
PCU acronimo di “Power Controll Unit”, è un sofisticato sistema di controllo,
integrato all’interno delle CPU Nehalem, composto da circa un milione di
transistor. PCU integra al proprio interno un firmware, che monitorizza in
tempo reale le temperature, i voltaggi e le frequenze di clock dei vari core,
presenti all’interno del processore. Inoltre questo sistema di controllo, qualora
fosse necessario, attiva o disattiva la funzione turbo memory, analizzata sopra.

222 Capitolo 6
Figura 6.5 - Power Contro Unit della CPU Core i7
Intel ® ha dotato ogni core presente all’interno della CPU, di un proprio PLL.
Questa soluzione permette un incremento della frequenza di clock individuale
per ciascun core.
Questa tecnologia fu utilizzata per la prima volta da AMD ® con i processori
della famiglia Phenom. Al pari della soluzione AMD ® , Intel ® ha deciso di far
operare tutti i core allo stesso voltaggio di alimentazione, indipendentemente
dalla potenza di calcolo richiesta ad ogni core. Per sopperire a questa mancanza,
il colosso di Santa Clara, ha utilizzato un approccio differente da quello adottato
da AMD ® e sulle sue stesse CPU Core 2 duo.
In Nehalem, ogni core può passare allo stato “C6” (ovvero, quando il voltaggio
di alimentazione viene ridotto al minimo), in modo indipendente, pur avendo un
power plain condiviso. Inoltre quando il sistema operativo, esegue l’istruzione
C6 per un core che ha ultimato il suo processo, interviene immediatamente la

Il nuovo processore Core i7 223
fase di risparmio energetico (idle), portando il voltaggio del core interessato,
prossimo allo zero, esattamente come se ci fosse un power plain specifico per
ogni core.
I benefici resi possibili grazie a questa tecnologia, saranno importanti per le
prime CPU Nehalem per notebook, attese al debutto nel corso di quest’anno,
insieme alla nuova piattaforma Centrino.
6.13 Considerazioni finali
L’attenta analisi delle nuova architettura Nehalem evidenza come Intel ® sia
riuscita ancora una volta a stupire il grande pubblico, con le prestazioni
strabilianti dei sui processori.
Anche se il divario con la precedente generazione di processori non è così netto,
Intel ® conserva il vantaggio acquisito sulla concorrenza nel lontano 2006, anno
in cui fecero il loro debutto le prime CPU Core 2, all’epoca chiamate a
raccogliere una pesante eredità lasciata dai processori della famiglia Pentium ® 4.
L’architettura Nehalem, non può essere considerata come rivoluzionaria, in
quanto molte delle tecnologie sviluppate in passato da Intel ® sono state
implementate nei nuovi processori Core i7. Inoltre il processo produttivo
utilizzato per la costruzione di CPU della famiglia Penryn, è lo stesso utilizzato
dei processori basati su architettura Nehalem.
Un altro aspetto molto interessante alla quale Intel ® tiene molto, per la
progettazione di future architetture, riguarda il “rapporto prestazioni–consumi”.

224 Capitolo 6
Durante la fase di progettazione della nuova architettura, il team di sviluppo,
poteva implementare nuove funzionalità ma solo a patto che queste ultime,
mantenessero un rapporto consumi-prestazioni di 1:2.

Capitolo 7
Le architetture del futuro
Nei precedenti capitoli abbiamo analizzato le modifiche architetturali che hanno
caratterizzato i processori dell’ultimo decennio. Ne abbiamo dato una
trattazione teorica nel Capitolo 3e abbiamo evidenziato nel Capitolo 5 come
Intel ® , una delle più importanti aziende del settore, ha effettivamente
implementato tali strategie nella produzione dei suoi processori, a partire dal
Pentium ® fino ad arrivare al nuovo processore i7 i cui primi esemplari sono
usciti sul mercato in concomitanza della stesura di questa tesi.
In questo capitolo, invece, cercheremo di dare uno sguardo al futuro, cercando
di delineare i limiti ormai raggiunti dalle correnti tecnologie ed evidenziando le
possibili alternative per superarli.
In particolare valuteremo come le leggi di Amdahl (che abbiamo già trattato al
paragrafo 2.4) e la legge di Moore possano essere lette al giorno d’oggi, nell’era
cioè del multi core.
7.1 La legge di Amdahl nell’era del multicore
La legge di Amdahl, la cui formulazione è stata riportata e descritta nel
paragrafo 2.4, viene usata per calcolare il miglioramento atteso massimo in una
architettura di calcolatori o in un sistema informatico quando vengono
migliorate solo alcune parti del sistema stesso. In un certo senso, essa pone un

226 Capitolo 7
limite al miglioramento massimo possibile, il quale è limitato dalla frazione di
tempo in cui la parte migliorata ha luogo. La legge di Amdahl può essere
ulteriormente semplificata nella pratica con una regola che tutti i progettisti di
hardware devono tenere in considerazione: "Make the common case fast"
(Rendi veloce il caso più frequente).
Una sregolata ricerca del miglioramento senza tenere in considerazione “il caso
più frequente”, ovvero il tipo e le modalità di utilizzo dell’architettura stessa è
sicuramente poco adeguata.
Oltre alla ricerca di miglioramenti architetturali per la singola unità sequenziale,
è oggigiorno indispensabile valutare i miglioramenti ottenuti mediante la
parallelizzazione delle attività, sia a livello di multiprocessore che di multicore,
di cui ci occuperemo in specifico in questa sezione.
Innanzitutto, è interessante notare che per usi interattivi degli elaboratori è
fondamentale il concetto di "velocità percepita", cioè la qualità di prestazione
fornita dal computer percepita dall'utente. In questi termini diventa
fondamentale il tempo di risposta ai comandi, il feedback fornito dal sistema,
più che l'effettivo tempo di esecuzione dei job. In questo caso il fatto di avere
più unità di calcolo potrebbe non tanto accelerare l'esecuzione di un processo
quanto piuttosto dare la possibilità all'utente di continuare a sfruttare la
macchina anche durante l'esecuzione di un compito pesante.
Inoltre, il multicore ha permesso, a differenza del caso multiprocessore, di
mantenere limitati i consumi di potenza e la dimensione, entrambi fattori non

Le architetture del futuro 227
trascurabili. Il secondo, ad esempio, permette la realizzazione di bus dati di
collegamento tra i diversi core ad una più alta velocità rispetto alle architetture
multiprocessore, sempre limitatamente al limite fisico imposto dalla velocità
della luce.
La tecnologia multicore sembra quindi aver introdotto notevoli vantaggi e
pertanto la sua diffusione dovrebbe essere scontata e condivisa. In realtà non è
così.
Ad esempio, una visione poco rosea sulla scalabilità dei sistemi multicore è
quella espressa da Hill e Marty [31]che basano le loro tesi proprio sulla legge di
Amdahl: essi affermano che la ineliminabile parte sequenziale di ogni
elaborazione prende presto il sopravvento rispetto alla parte parallelizzabile
mediante la tecnologia multicore.
La legge di Amdahl, infatti, può essere riscritta per tenere in considerazione lo
speedup ottenuto introducendo più unità di calcolo. In tal caso, la frazione f che
può essere migliorata è quella parallela, e il miglioramento ottenuto in questa
sola parte è, nel caso migliore, proporzionale al numero m di processori (core).
Per maggior precisione, si potrebbe definire una funzione del numero di core
che regola tale miglioramento.
Speedup Amdhal
=
1
( 1−
)
f +
f
m
(7.1)
Sotto questa ipotesi, l’aumento del numero di core ha sì un vantaggio che però è
progressivamente insufficiente a coprire la crescente complessità architetturale.

228 Capitolo 7
Questa visione pessimistica è probabilmente condivisa dai grandi produttori di
processori, che stanno realizzando architetture con un numero molto limitato di
core. Si vedano ad esempio l’IBM Cell[32] e il processore T2 della Sun
Microsystems [33], entrambi a 8 core, o il processore Dunningotn dell’ Intel ®
[34], annunciato l’anno scorso, a soli 6 core. Sempre Intel ® ha in progetto per il
2011 un processore a 80 core, ma il suo approccio è ancora molto conservatore
rispetto a piccole e più flessibili compagnie che stanno producendo processori a
centinaia di core [35; 36]. La storia sembra ripetersi, visto che simili
comportamenti si sono verificati alcuni decenni fa con le architetture
multiprocessore.
In contrasto con la visione pessimistica di Hill e Marty, Sun e Chen dell’Illinois
Institute of Technology hanno recentemente diffuso un report in cui riportano il
loro ottimismo nello sviluppo della tecnologia multicore [37]
La legge di Amdahl, matematicamente corretta, contiene in effetti alcune ipotesi
che non sempre vengono completamente considerate e riportate, portando ad
una spesso errata e pessimistica visione delle possibilità di speedup ottenuta col
parallelismo.
L’equazione 7.1 suppone che il carico di lavoro sia costante. Tale equazione,
infatti, prende anche il nome di “fixed-size speedup model”. In realtà, avendo a
disposizione più potenza di calcolo, le richieste dell’utente spesso aumentano.
Anche se il carico di lavoro iniziale a causa della parte sequenziale non è

Le architetture del futuro 229
ottimizzabile oltre una certa soglia, l’aumento di operazioni che possono essere
eseguite nello stesso periodo di tempo è comunque un vantaggio che
l’equazione di Amdahl non considera. A tal proposito, Gustafson ha introdotto
una variante detta “fixed-time speedup model”.
Tale speedup è calcolato come rapporto fra il carico di lavoro che si riesce a
processare nell’unità di tempo con la versione sequenziale e la rispettiva
soluzione parallelizzata.
Speedup FT
=
( 1 )
− f + mf
(7.2)
Come si può notare, in questa formulazione all’aumentare del numero m di
processori lo speedup ha un aumento proporzionale, teoricamente infinito per m
che tende all’infinito.
Purtroppo anche questa seconda formulazione non tiene conto di un collo di
bottiglia dell’intero sistema, ovvero dell’accesso alla memoria.
Sun e Chen, nel loro report, riportano una nuova formulazione che generalizza
sia la legge di Amdahl che quella di Gustafson, nota col nome di “memory-
bounded speedup”.
In questa nuova ottica, il miglioramento ottenuto con la tecnologia multicore
rimane comunque più che vantaggiosa. In Figura 7.1, Figura 7.2 e Figura 7.3
vengono mostrati gli speedup ottenuti con un numero di core crescente nelle tre
formulazioni. Tutti e tre i casi mostrano come la visione di Amdahl sia non
tanto errata, ma comunque incompleta e pessimista.

230 Capitolo 7
Figura 7.1 – Fixed-Size Speedup di una architettura multicore.[37]
Figura 7.2 - Fixed-Time Speedup di una architettura multicore [37]

Le architetture del futuro 231
Figura 7.3 - Memory-Bounded Speedup di una architettura multicore [37]
E’ quindi evidente come l’era del multicore stia rivoluzionando il modo di
pensare e gli assiomi su cui si basavano le scelte progettuali degli scorsi
decenni. Analizziamo più in dettaglio quali sono i nuovi pilastri su cui si deve
basare il futuro prossimo dell’architettura dei calcolatori.
7.2 Una rivoluzione del pensiero comune
Come suggerito nel precedente paragrafo, è fondamentale conoscere cosa si
vuole fare con una architettura per poter migliorare il caso più frequente e più
pesante.
Recentemente David Patterson, docente universitario di Informatica e in
particolare di Architettura dei calcolatori presso la University of California,

232 Capitolo 7
Berkeley sin dal 1977, ha studiato ed esposto insieme ad altri ricercatori un
report sul futuro delle architetture dei calcolatori [38]. Patterson fu uno dei
pionieri dell'architettura RISC e della tecnologia RAID, ambedue ampiamente
utilizzate nei moderni elaboratori. Presidente della Association for Computing
Machinery (ACM) dal 2004 e 2006 è sicuramente una delle voci più autorevoli
nel settore.
Il report in questione parte dall’evidente mutazione dello scenario tecnologico
attuale. In particolare, afferma che è notevolmente cambiato il pensiero comune:
le basi su cui si fondavano la progettazione e lo sviluppo di nuovi calcolatori
nello scorso secolo non sono più valide. Patterson ritiene quindi indispensabile
favorire un nuovo incontro e scambio di idee tra le varie discipline, dalla
architettura allo sviluppo dei linguaggi di programmazione, agli analisti
numerici, ai programmatori.
Le promesse del “parallelismo” hanno affascinato i ricercatori negli ultimi
trent’anni. Nonostante le architetture parallele siano in fase di studio e
produzione da svariato tempo, le architetture monoprocessore hanno sempre
prevalso, in particolare per motivi economici e per la diffuse preferenza alle
architetture “general-purpose”. Ultimamente invece, si è riscoperto un notevole
interesse per il parallelismo; non solo, ci si è mossi oserei dire senza possibilità
di ritorno verso di esso.

Le architetture del futuro 233
Ecco le ragioni di queste mutazioni, esposte in contrapposizione ai principi
validi fino a qualche anno fa, come riportate da Patterson in [4]
PASSATO PRESENTE
La potenza dissipata è gratis, quello
che costa sono i transistori
L’unica potenza da tenere in
considerazione è quella dinamica;
I processori monolitici in silicio sono
internamente affidabili; i problemi
nascono ai pin
I ricercatori dimostravano le loro
nuove architetture ed idee per mezzo
di prototipi
Nella progettazione di nuove
tecnologie bisogna dare ampio spazio
sia alla larghezza di banda che alla
latenza
Moltiplicare e dividere sono
operazioni lente; i trasferimenti sono
operazioni veloci
L’ILP può essere migliorato tramite
nuovi compilatori e modifiche
architetturali (out-of-order,
speculation, ecc).
Attualmente è il contrario. Soprattutto
con la diffusione del portatili c’è un
continuo interesse per la riduzione
della potenza dissipata, mentre le
evoluzioni tecnologiche hanno portato
ad un “esubero” di transistor a
disposizione (Power Wall)
Per desktop e server la potenza statica
raggiunge addirittura il 40% del totale
Da quando si è scesi al di sotto dei
65nm, esistono errori non nulli
[39][40]
I costi delle maschere, della
progettazione e realizzazione sono
troppo alti per produrre solamente
prototipi realistici. Servono nuove
tecniche per la progettazione
La larghezza di banda evolve in modo
quadratico rispetto alla latenza, che
necessità di maggior sforzo [41]
Le moltiplicazioni sono realizzabili in
4 cicli di clock; nuovi studi
evidenziano che anche le divisioni non
sono più un problema [42]. Le attuali
architetture richiedono intorno ai 200
cicli di clock per accedere alla
DRAM. (Memory wall [43]).
Ulteriori tecniche per migliorare l’ILP
stanno rivelandosi sempre meno
interessanti ed efficaci (ILP Wall
[44]).
Le performance dei monoprocessori In Figura 7.4 sono riportate le

234 Capitolo 7
PASSATO PRESENTE
raddoppiano ogni 18 mesi performance dei processori dal 1978
al 2006 utilizzando benchmark SPEC
[45]. L’incremento di prestazioni fino
al 1984 era intorno al 25% annuo; la
diffusione del paradigma RISC ha
permesso uno sviluppo annuo del 52%
fino al 2002; dopo tale data, invece, si
è tornati ad un incremento annuo
modesto, intorno al 20%.
Ciò è dovuto alla combinazione dei
“tre muri”:
Power Wall + Memory Wall + ILP
Wall = Brck Wall
Non ha senso sforzarsi per
parallelizzare il codice: presto nuove
architetture realizzeranno quanto
voluto ad una velocità sufficiente
L’incremento della frequenza del
clock è la via principale per migliorare
le performance
Una applicazione multiprocessore
deve avere prestazioni con crescita
lineare rispetto al numero di
processori, altrimenti è una sconfitta
L’hardware è poco flessibile, il
software invece è facilmente adattabile
Non posso sapere le applicazioni del
futuro; valuto le nuove modifiche
architetturali mediante un insieme di
vecchi programmi SPEC2006 [45]
Calcolatori più efficienti per
l’esecuzione di codice sequenziale
saranno disponibili sempre più tardi
Siamo arrivati ad un limite fisico della
velocità del clock (vedi paragrafo
2.3.2). Il parallelismo deve essere al
centro dell’attenzione
Qualunque miglioramento si ottiene è
ben accetto
Il software è più difficile da migliorare
e cambiare
E’ fondamentale prevedere le
applicazioni del futuro
Tabella 7.1 - Principi validi fino a qualche anno fa ed ora ormai sorpassati.

Le architetture del futuro 235
Performance (vs. VAX-11/780)
10000
1000
100
10
25%/year
52%/year
??%/year
1
1978 1980 1982 1984 1986 1988 1990 1992 1994 1996 1998 2000 2002 2004 2006
Figura 7.4 - L’incremento di prestazioni fino al 1984 era intorno al 25% annuo; la
diffusione del paradigma RISC ha permesso uno sviluppo annuo del 52% fino al 2002;
dopo tale data, invece, si è tornati ad un incremento annuo modesto, intorno al 20%.[4]
Il quadro che se ne evince sembra essere molto negativo; in realtà esistono
altrettanti contro aspetti positivi. Innanzitutto la legge di Moore continua a
valere. Come riportato nel titolo di questa tesi, le modifiche architetturali
devono andare ben oltre tale legge, ma la riduzione delle dimensioni dei
transistor e il conseguente aumento del numero degli stessi all’interno dello
stesso processore hanno permesso interessanti applicazioni. Ad esempio, nel
2005 è stato rilasciato dalla CISCO un chip che integrava ben 188 core di tipo
RISC [46]. La possibilità di trasmissioni a bassa latenza ed alta banda
all’interno dello stesso chip permettono una nuova modalità di progettazione di
architetture, che vedono integrare numerosi core all’interno dello stesso chip. Si
può quasi pensare al core come in nuovo elemento di base al posto del

236 Capitolo 7
transistor. La strategia multicore sembra quindi essere la soluzione più
promettente nell’ambito della progettazione delle nuove architetture.
7.3 “I sette nani”
Come già anticipato, Patterson sostiene che è necessario uno sforzo comune per
la progettazione di nuove architetture da parte di diverse discipline. In
particolare, come evidenziato dalle ultime due evoluzioni del pensiero comune
(Tabella 7.1) è fondamentale uno stretto legame tra software e hardware, o
meglio tra architetture ed applicazioni.
Figura 7.5 - “A view from Berkeley”: sette punti fondamentali per il calcolo parallelo
del 21° secolo. Figura ispirata alla vista del Goldon Gate Bridge da Berkeley
Tra i sette i punti fondamentali da tenere in considerazione c’è anche la
tipologia delle applicazioni; non più le applicazioni del passato come avveniva
mediante lo studio dei Benchmark SPEC, ma le applicazioni del futuro.

Le architetture del futuro 237
A tal proposito Phil Colella nel 2004 identificò sette algoritmi numerici che
riteneva essere alla base della scienza e dell’ingegneria almeno per le future
decadi [47].
• Algebra lineare densa
• Algebra lineare sparsa
• Metodi spettrali (es. FFT)
• Metodi a particelle
• Griglie di calcolo strutturate
• Griglie di calcolo non strutturate
• Metodi Monte Carlo
Questi sette algoritmi, detti 7 nani (seven dwarfs) sono stati studiati e
classificati in altrettante classi di equivalenza, sotto le quali numerosi algoritmi
trovano spazio. Una prova di ciò può essere ottenuta analizzando librerie
software per l’analisi numerica. I pattern di elaborazione e di scambio dei dati
che caratterizzano ciascuna classe possono essere di grandissimo interesse per la
progettazione di nuove architetture che devono rispondere a suddette esigenze.
Un approccio simile a quello di Colella è stato seguito sempre da Patterson che
ha studiato i 41 kernel di EEMBC e i 26 programmi SPEC2006.
Successivamente ha analizzato le tre discipline di enorme interesse attuale:
Machine learning, Database software e Computer Graphics and Games. Da tale
studio sono stati rintracciati 6 ulteriori “nani”:
• Logica combinatoria (crittografia)

238 Capitolo 7
• Visita dei Grafi (quicksort)
• programmazione dinamica (problemi di ottimizzazione)
• Backtrack and branch&Bound (problemi di ottimizzazione in
sottodomini)
• Modelli grafici (MRF, HMM)
• Macchine a stati finiti
7.4 Lo studio dell’ Intel ® : RMS
Anche Intel ® ha affrontato lo stesso problema. Come evidenziato da Dubey, l’
Intel ® crede che l’incremento delle richieste degli utenti sarà principalmente
legato dalla necessità di processare grandi quantità di dati (siamo entrati
nell’Era del Tera [48]). Intel ® ha quindi classificato le applicazioni di interesse
in tre categorie: Recognition, Mining e Synthesis (RMS).
• Recognition: mediante tecniche di machine learning si devono
analizzare i dati per trovare un modello matematico che li rappresenti
• Mining: ricerca nel web di tutte le istanze che verificano il modello
trovato
• Synthesis: creazione di nuovi modelli o nuove istanze.
La classificazione RMS è molto simile allo studio di Patterson sulle tecniche di
Machine Learning, database e grafica. Intel ® ritiene inoltre che il modello RMS
avrà notevoli applicazioni nei campi della medicina, della finanza, dei
videogame nonché in ambito domestico. Nello schema di Figura 7.6 sono
riportate le classi di funzioni e primitive di particolare interesse, che derivano

Le architetture del futuro 239
dalle discipline di Computer Vision (Recognition), Data Mining (Mining) e
Rendering Physical Simulation, Financial Analytics (Synthesis).
Figura 7.6 – Intel RMS. Generazione delle primitive di elaborazione (in basso) a
partire dalle 5 categorie (in alto): Computer Vision (Recognition), Data Mining
(Mining) e Rendering Physical Simulation, Financial Analytics (Synthesis) [49]
Riassumendo, le applicazioni di interesse per il futuro sono riportate in Figura
7.7.
Dwarf Embedde
d
Computin
g
1. Dense
Linear
Algebra
(e.g., BLAS
or
MATLAB)
EEMBC
Automotive:
iDCT, FIR,
IIR, Matrix
Arith;
EEMBC
Consumer:
JPEG, RGB
to CMYK,
RGB to
YIQ;
EEMBC
Digital
General
Purpose
Computin
g
SPEC
Integer:
Quantum
computer
simulation
(libquantum),
video
compression
(h264avc)
SPEC Fl. Pl.:
Hidden
Markov
models
Machine
Learning
Support
vector
machines,
princpal
componen
t analysis,
independe
nt
componen
t
analysis
Graphic
s /
Games
Databas
es
Database
hash
accesses
large
contiguous
sections of
memory
Intel ®
RMS
Body
Tracking,
media
synthesis
linear
programmin
g, K
means,
support
vector
machines,
quadratic
programmin

240 Capitolo 7
Dwarf Embedde
d
Computin
g
Entertainme
nt: RSA
MP3
Decode,
MPEG-2
Decode,
MPEG-2
Encode,
MPEG-4
Decode;
MPEG-4
Encode;
EEMBC
Networking:
IP Packet;
EEMBC
Office
Automation:
Image
Rotation;
EEMBC
Telecom:
Convolution
Encode;
EEMBC
Java: PNG
2. Sparse
Linear
Algebra
(e.g., SpMV,
OSKI, or
SuperLU)
3. Spectral
Methods
(e.g., FFT)
4. N-Body
Methods
(e.g., Barnes-
Hut, Fast
Multipole
Method)
EEMBC
Automotive:
Basic Int +
FP, Bit
Manip, CAN
Remote
Data, Table
Lookup,
Tooth to
Spark;
EEMBC
Telecom: Bit
Allocation;
EEMBC
Java: PNG
EEMBC
Automotive:
FFT, iFFT,
iDCT;
EEMBC
Consumer:
JPEG;
EEMBC
Entertainme
nt: MP3
Decode
General
Purpose
Computin
g
Machine
Learning
Graphic
s /
Games
Databas
es
Intel ®
RMS
(sphinx3) g,
PDE: Face,
PDE:
Cloth*
SPEC Fl. Pt.:
Fluid
dynamics
(bwaves),
quantum
chemistry
(gamess;
tonto), linear
program
solver
(soplex)
SPEC Fl. Pt.:
Molecular
dynamics
(gromacs, 32bit;
nAMD ® ,
64-bit)
Support
vector
machines,
principal
componen
t analysis,
independe
nt
componen
t analysis
Spectral
clustering
Reverse
kinematic
s; Spring
models
Texture
maps
Support
vector
machines,
quadratic
programmin
g, PDE:
Face, PDE:
Cloth*
PDE:
Computatio
nal fluid
dynamics
PDE:
Computatio
nal fluid
dynamics
PDE: Cloth

Le architetture del futuro 241
Dwarf Embedde
d
Computin
g
5. Structured
Grids (e.g.,
Cactus or
Lattice
Boltzmann
Magneto-
hydrodynami
cs)
6.
Unstructured
Grids (e.g.,
ABAQUS or
FIDAP)
7.
MapReduce
(e.g., Monte
Carlo)
8.
Combination
al Logic
EEMBC
Automotive:
FIR, IIR;
EEMBC
Consumer:
HP Gray-
Scale;
EEMBC
Consumer:
JPEG;
EEMBC
Digital
Entertainme
nt:
MP3
Decode,
MPEG-2
Decode,
MPEG-2
Encode,
MPEG-4
Decode;
MPEG-4
Encode;
EEMBC
Office
Automation:
Dithering;
EEMBC
Telecom:
Autocorrelat
ion
EEMBC
Digital
Entertainme
nt: AES,
DES ;
EEMBC
Networking:
IP Packet, IP
NAT, Route
Lookup;
EEMBC
Office
Automation:
Image
Rotation;
EEMBC
Telecom:
General
Purpose
Computin
g
SPEC Fl. Pt.:
Quantum
chromodyna
mics
(milc),magnet
o
hydrodynami
cs (zeusmp),
general
relativity
(cactusADM),
fluid
dynamics
(leslie3d-
AMR; lbm),
finite element
methods
(dealII-AMR;
calculix),
Maxwell’s
E&M
eqns solver
(GemsFDTD)
, quantum
crystallograph
y
(tonto),
weather
modeling
(wrf2-AMR)
SPEC Fl. Pt.:
Ray tracer
(povray)
Machine
Learning
Belief
propagatio
n
Expectatio
n
maximizati
on
Graphic
s /
Games
Smoothin
g;
interpolati
on
Databas
es
MapReduc
e
Hashing Hashing
Intel ®
RMS
Global
illumination

242 Capitolo 7
Dwarf Embedde
d
Computin
g
Convolution
Encode
9. Graph
Traversal
10. Dynamic
Programmin
g
11. Backtrack
and
Branch
+Bound
12.
Graphical
Models
13. Finite
State
Machine
EEMBC
Automotive:
Pointer
Chasing,
Tooth to
Spark;
EEMBC
Networking:
IP NAT,
OSPF,
Route
Lookup;
EEMBC
Office
Automation:
Text
Processing;
EEMBC
Java: Chess,
XML
Parsing
EEMBC
Telecom:
Viterbi
Decode
EEMBC
Telecom:
Viterbi
Decode
EEMBC
Automotive:
Angle To
Time, Cache
“Buster”,
CAN
Remote
Data, PWM,
Road Speed,
Tooth to
Spark;
EEMBC
General
Purpose
Computin
g
SPEC
Integer: Go
(gobmk)
SPEC
Integer:
Chess (sjeng),
network
simplex
algorithm
(mcf), 2D
path finding
library (astar)
SPEC
Integer:
Hidden
Markov
models
(hmmer)
SPEC
Integer: Text
processing
(perlbench),
compression
(bzip2),
compiler
(gcc), video
compression
(h264avc),
network
discrete event
Machine
Learning
Bayesian
networks,
decision
trees
Forwardbackward,insideoutside,
variable
elimination
, value
iteration
Kernel
regression
,
constraint
satisfactio
n,
satisficabili
ty
Hidden
Markov
models
Graphic
s /
Games
Reverse
kinematic
s,
collision
detection,
depth
sorting,
hidden
surface
removal
Response
to
collisions
Databas
es
Transitive
closure
Query
optimizatio
n
Intel ®
RMS
Natural
language
processing

Le architetture del futuro 243
Dwarf Embedde
d
Computin
g
Consumer:
JPEG;
EEMBC
Digital
Entertainme
nt: Huffman
Decode,
MP3
Decode,
MPEG-2
Decode,
MPEG-2
Encode,
MPEG-4
Decode;
MPEG-4
Encode;
EEMBC
Networking:
QoS, TCP;
EEMBC
Office
Automation:
Text
Processing;
EEMBC
Telecom: Bit
Allocation;
EEMBC
Java: PNG
General
Purpose
Computin
g
simulation
(omnetpp),
XML
transformatio
n
(xalancbmk)
Machine
Learning
Graphic
s /
Games
Databas
es
Intel ®
RMS
Figura 7.7 - Mapping of EEMBC, SPEC2006, Machine Learning, Graphcs/Games,
Data Base, and Intel ® ’s RMS to the 13 Dwarfs. *Note that SVM, QP, PDE:Face, and
PDE:Cloth may use either dense or sparse matrices, depending on the application.
7.5 Autotuners
La visione multidisciplinare di Figura 7.5 è confermata e rafforzata da diversi
esperimenti che hanno evidenziato la mutua dipendenza tra hardware e
software.
Ad esempio, prendiamo il caso della ricerca in matrici sparse, memorizzate
mediante tecnica a blocchi. La dimensione di ciascun blocco è una caratteristica
fondamentale su cui si basano le prestazioni dell’algoritmo di ricerca.

244 Capitolo 7
Prendendo un processore Intel ® Itanium2 a 900 MHz si è valutato che la
dimensione ottimale del blocco è 4x2 (vedi Figura 7.8), dimensione non certo
standard o prevedibile. Essendo questo problema alla base di numerosi
algoritmi (e facente parte di uno dei “nani” descritti in precedenza) trovare una
implementazione ottima è di grande interesse.
Figura 7.8 – Prestazioni dell’Itanium 2 nella ricerca in matrici sparse memorizzate
mediante tecnica a blocchi [4]
Effettuando esperimenti su altre architetture, però, si è notato che tali
dimensioni sono differenti (vedi Figura 7.9)

Le architetture del futuro 245
row block size (r)
8
4
2
1
Figura 7.9 – Dimensione dei Blocchi ottimizzate per diverse CPU nella ricerca in
matrici sparse [4]
Il compilatore non è quindi in grado senza conoscere la precisa architettura di
produrre un codice ottimizzato. Inoltre, produrre un codice ottimizzato su di una
singola architettura porta ad una cattiva portabilità della applicazione, quindi ad
un risultato tutt’altro che desiderato.
La soluzione è quella di spostare il problema dal compilatore alla architettura.
Deve essere a livello architetturale che si estraggono conoscenze sulle
performance raggiungibili e si utilizzano le stesse per ottenere un codice
ottimizzato.
IBM Power 4,
Intel/HP
Itanium
Intel
Pentium
M
Intel/HP
Itanium 2
IBM
Power 3
1 2 4 8
column block size (c)
Sun Ultra 2,
Sun Ultra 3,
AMD Opteron
Si parla quindi di Auto-tuners, ovvero codici in grado di sperimentare alla prima
esecuzione quali ottimizzazioni e quali parametri sono i migliori in base
all’architettura su cui sono in esecuzione; successivamente tali ottimizzazioni
devono essere riconosciute e mantenute. Codici autotuning richiedono però un

246 Capitolo 7
supporto hardware e quindi le architetture future dovranno supportare in pieno
tale tecnologia.
7.6 Nuove metriche di valutazione
La rivoluzione del pensiero comune descritta nel paragrafo 7.2 e la necessità di
multidisciplinarità nella progettazione delle architetture del futuro devono
portare anche ad una nuova metrica di valutazione della bontà delle nuove
architetture. Valutazioni prettamente architetturali, o che riguardano solamente
il costo di produzione del solo processore non sono più sufficienti.
Quali sono quindi le caratteristiche da tenere in considerazione?
Innanzitutto è necessario massimizzare la produttività del programmatore.
Avendo a disposizione centinaia di unità di calcolo in un unico chip portano
necessariamente ad una rivoluzione della modalità di programmazione, nonché
a nuove sfide per gli sviluppatori di software. La difficoltà nella
parallelizzazione delle applicazioni non è trascurabile.
La possibilità di aumentare la produttività dei programmatori e l’effettiva
usabilità delle modifiche architetturali implementate sono sicuramente da tenere
in considerazione nella valutazione dei nuovi processori.
Inoltre non è da sottovalutare l’ipotesi di realizzare in hardware soluzioni ai
problemi classici della programmazione attuale. Ad esempio, la realizzazione
di un garbage collector per la gestione della memoria dinamica, la gestione delle
fasi di debug, eccetera.

Le architetture del futuro 247
Certamente la produttività è difficilmente misurabile ma esistono comunque
studi come [50] e [51] che hanno cercato di valutare quantitativamente questo
aspetto.
Contemporaneamente, le nuove architetture dovranno cercare di massimizzare
le prestazioni a livello di applicazione.
Oltre a ciò, chiaramente rimangono validi i parametri misurabili quali:
minimizzazione del numero di accessi remoti
bilanciamento del carico
livello di granularità dello scambio dei dati e della sincronizzazione
Per concludere, citiamo il progetto RAMP, che mira a stabilire una piattaforma
condivisa e aperta per abilitare una rapida innovazione nel campo del software e
delle architetture parallele [52].

Capitolo 8
Conclusioni
Da quanto illustrato nei capitoli precedenti, sia da un punto di vista teorico
(ovvero nel Capitolo 2, nel Capitolo 3 e nel Capitolo 4), sia da un punto di vista
applicativo (Capitolo 5 e Capitolo 6) appare abbastanza evidente come negli
ultimi anni le modifiche sul singolo core delle CPU siano sempre meno
significative. In particolare sembrano sempre più vicini tre limiti (“Walls”, vedi
Capitolo 7):
• Limiti imposti da requisiti di potenza dissipata (Power Wall)
• Limiti di parallelizzazione dei problemi (ILP Wall)
• Limiti dovuti al “collo di bottiglia” delle memorie (Memory Wall)
Questi problemi stringenti sembrano imporre, o comunque consigliare il
passaggio alla tecnologia multicore che, si può dire, sia la “rivoluzione
architetturale” più promettente degli ultimi anni e tuttora in via di sviluppo.
Il dibattito sulla scalabilità delle architetture multicore rimane tuttavia aperto.
Si parla infatti di differenza tra multicore e manycore, per diversificare le attuali
architetture formate da pochi core (meno di 10) e quelle in cui il numero di core
cresce in modo rilevante.

250 Capitolo 8
Condividendo la visione di Berkely, si auspica ben presto di poter passare da
“tecnologie multicore” a “tecnologie manycore”, con migliaia di core per ogni
processore.
Lo sviluppo delle architetture future dovrà poi essere basato su stime valide dal
punto di vista delle applicazioni del futuro, delineando correttamente e
mantenendo aggiornata la cosiddetta lista “dei 7 nani”.
Infine realizzare architetture “autotuners”, in grado di adattarsi alla particolare
applicazione e alla complessiva struttura del sistema, sarà sicuramente una
scelta vincente.

Appendice A
Storia della Intel ® Corporation
Figura A.1 - Gordon Moore
Nel 1968 Robert Noyce e Gordon Moore
lasciano la Fairchild Semiconductor e
fondano la Intel ® . Il quarto dipendente fu
Andrew "Andy" Grove, che diresse l’azienda
dal suo arrivo negli anni Sessanta fino al suo
pensionamento, avvenuto negli anni Novanta,
facendola diventare una tra le più grandi multinazionali del mondo.
Intel ® all’inizio produceva componenti per
memorie e, durante gli anni settanta, era
divenuta leader nella produzione di memorie
DRAM, SRAM e ROM. Da quando però nel
1971 Marcian Hoff, Federico Faggin, Stanley
Mazor e Masatoshi Shima inventarono il primo
microprocessore, l’ Intel ® 4004, gradualmente
fino agli anni ottanta la produzione si spostò verso quella dei microprocessori
facendo diventare Intel ® una dei colossi in questo settore.
Figura A.2 - Robert Noyce
Nel 1983 toccò al presidente della società, Andy Grove, trasformare la
produzione, abbandonando la costruzione di memorie per passare alla

252 Appendice A
produzione di microprocessori. Lo stesso Andy Grove descrisse questa
transizione nel libro Only the Paranoid Survive. Un elemento chiave di questo
processo fu sicuramente l’8086 che nel 1982 viene scelto per i PC IBM alla
condizione (imposta da IBM) di avere una seconda fonte di produzione. La
seconda fonte sarà AMD ® , che con uno scambio di licenze diviene il secondo
fornitore di processori 8088 e 8086 per i PC IBM. Il "problema" dei secondi
fornitori sarà sempre presente fino all’avvento del Pentium.
Durante gli anni novanta la Intel ® Architecture Labs (IAL) fu la maggior
responsabile delle innovazioni hardware dei personal computer, fra cui il bus
PCI, il bus PCI Express, l’Universal Serial Bus (USB) e le prime architetture
per server multiprocessori (SMP).
Il controllo totale del mercato dei processori x86 procurò all’ Intel ® negli anni
molte cause da parte dell’Antitrust. Attualmente Intel ® controlla l’85% del
mercato dei processori 32-bit, unico suo avversario è la Advanced Micro
Devices con cui Intel ® ha un accordo dal 1976: ognuna delle due major può
usare le tecnologie brevettate dall’avversario senza dover richiederne il
consenso.
Intel ® attualmente produce microprocessori, componenti di rete, chipset per
motherboard (scheda madre), chip per schede video e molti altri circuiti
integrati.

Storia della Intel® Corporation 253
Nel settembre del 2007 la società ha acquisito Havok, sviluppatore noto in
ambito software per lo sviluppo dell’omonimo motore fisico utilizzato in più di
150 videogiochi. Nell’ottobre dello stesso anno ha raggiunto un accordo
extragiudiziario con Transmeta: la società accusava Intel ® di aver violato alcune
suo proprietà Intellettuali. Intel ® ha pagato 250 milioni di dollari per aver
accesso non esclusivo a tutti i brevetti della società. Nel febbraio del 2008 la
società è stata citata in giudizio dall’University of Wisconsin - Madison per
aver violato il brevetto statunitense 5.781.752 nei processori Core 2.
SCHEDA:
Nazione Stati Uniti
Tipologia Public company
Fondazione: 1968
Fondata da: Gordon Moore e Robert Noyce
Sede principale Santa Clara (California), USA
Persone chiave Paul Otellini, CEO e Craig Barrett,
Chairman
Fatturato: 31,5 miliardi $ (2006)
Utile netto: 5 miliardi $ (2006)
Dipendenti: 94.000
Slogan: “Leap Ahead”
Sito web www. Intel ® .com

254 Appendice A
LISTA DEI PROCESSORI INTEL ®
Famiglia 4 bit/8 bit: 4004 | 4040 | 8008 | 8080 | 8085
Famiglia 16 bit: 8086 | 8088 | 80186 | 80286
Famiglia IA-32: 80386 | 80486
Gamma Pentium: Pentium ® | Pentium ® Pro | Pentium ® II |
Celeron | Pentium ® III | Pentium ® III-
M | Pentium ® 4 | Pentium ® 4-M |
Mobile Pentium ® 4 | Pentium ® 4 EE |
Celeron D | Pentium ® D | Pentium ® EE
Processori Mobile: Pentium ® M | Celeron M | Core Duo |
Core Solo
Gamma Core: Core 2 Duo | Core 2 Quad | Core 2
Extreme
Gamma Nehalem: Core i5 | Core i7 | Core i7 Extreme
Processori per Server: Xeon
Famiglia IA-64: Itanium | Itanium 2
Non x86 compatibili: Intel ® iAPX 432 | Intel ® i860 | Intel ®
i960

Appendice B
Storia dei processori Intel ®
Cenni sulla evoluzione dei processori Intel ® precedenti al
Pentium
1971: MICROPROCESSORE 4004
Il primo microprocessore per uso generico
nasce da un’intuizione: quando la Busicom,
produttrice giapponese di calcolatrici,
ordina alla Intel ® la produzione di un set di
dodici chip di differenti tipologie,
l’ingegnere Ted Hoff pensò di incorporare
in un unico microprocessore tutte le
funzioni del set.
Nasce il primo dispositivo programmabile e
controllabile tramite un linguaggio di programmazione in grado di soddisfare le
necessità di elaborazione più disparate. Il 4004 era dotato di registri capaci di
gestire 4 bit alla volta.

256 Appendice B
1972: MICROPROCESSORE 8008
Il 4004 era in grado di operare esclusivamente con cifre numeriche, ma per
generalizzare l’uso del processore era
necessario aumentare le dimensioni dei
registri per poter trattare tutti i caratteri
alfanumerici e di punteggiatura. Con sei bit
era possibile rappresentare tutti i caratteri
alfanumerici, ma non i vari caratteri di
punteggiatura. L’emergere contemporaneo
del byte a otto bit quale standard di
codifica dei dati digitali favorì la scelta di
questo formato quale dimensione del registro del nuovo microprocessore.
L’8008 a otto bit fu protagonista dei primi tentativi di costruzione di
microcomputer: secondo la rivista Radio Electronics un hobbista di informatica,
Don Lancaster, utilizzò l’8008 per creare un predecessore del primo personal
computer, un dispositivo che Radio Electronics soprannominò "macchina per
scrivere con TV".
1974: MICROPROCESSORE 8080
Il processore 8080, versione migliorata del 8008 in grado di gestire un numero
maggiore di istruzioni, diventò il cervello del primo personal computer, l’Altair.
Gli hobbisti di informatica potevano acquistare un kit per l’Altair al prezzo di
395 dollari. In pochi mesi, ne furono vendute decine di migliaia, dando luogo ai
primi arretrati di ordinativi di PC nella storia.

Storia dei processori Intel® 257
A questo punto alcuni collaboratori
di Hoff lasciarono la Intel ® per
fondare la compagnia Zilog
Corporation, che produsse
un’ulteriore evoluzione dell’8080:
lo Z80.
Intel ® nel frattempo realizzò
l’8085, studiato per funzionare con
un’unica alimentazione a 5 volt. Si entra nella seconda generazione. La sua
architettura, ancora oggi oggetto di studio nelle università, prevedeva la
presenza di unità di input/output e la capacità di gestire le interruzioni a livello
di vettori.
1978: MICROPROCESSORE 8086
Appartiene alla terza generazione di microprocessori: la dimensione dei registri
raddoppia ulteriormente e si entra nell’era dei 16 bit. Il guadagno in termini di
prestazioni risulta essere così dieci volte maggiore rispetto a quello dell’8080.
Attraverso un bus dei dati di 20 bit è in grado di indirizzare direttamente un Mb
di memoria, una quantità pressoché infinita per quei tempi.
La novità apportata dal processore era l’utilizzo della memoria in modo
segmentato. Attraverso questo metodo si definisce la memoria in segmenti e il
processore vi accede mediante il formato seg:disp, dove il valore di seg è
collegato alla posizione di memoria fisica in cui ha inizio il segmento, mentre il
valore disp indica il displacement della suddetta posizione di memoria all’inizio

258 Appendice B
del segmento precedente. Per chiarire con un esempio, la distanza 4500 metri
può essere espressa nel valore assoluto 4500 o con la notazione 4:500, in cui 4
sarebbe la distanza in chilometri, mentre 500 sarebbero i metri a partire dal
quarto chilometro. Allo stesso modo, un indirizzo fisico può essere definito
dall’indirizzo di inizio del segmento + il relativo displacement. Questo metodo
permette di supportare la rilocazione dei programmi, ovvero la possibilità che
un programma possa essere eseguito in un qualunque segmento o zona di
memoria, senza fare altro che cambiare il valore del registro del segmento.
1979: MICROPROCESSORE 8088
Rappresenta un passo indietro
nell’evoluzione: mantiene il set di
istruzioni e le dimensioni dei
registri dell’8086, ma il bus dei
dati è ridotto a otto bit, contro i
sedici del processore precedente.
Questa operazione è stata fatta per
rendere l’8088 compatibile con
gli adattatori hardware in
commercio e per poter impiegare chip di supporto economici e facilmente
reperibili nei primi personal computer.
Il processore 8088 diventò quindi il cervello del nuovo prodotto di punta
dell’IBM: l’IBM PC. La struttura a 16 bit pose il personal di Big Blue in
posizione di vantaggio rispetto agli altri microcomputer, completamente a otto

Storia dei processori Intel® 259
bit. Più tardi l’IBM realizzerà la linea di personal PS/2, basata sul più potente
processore 8086.
Il successo del processore 8088 comportò l’inserimento di Intel ® nelle
classifiche di Fortune 500, e la rivista Fortune definì questa società uno dei
trionfi aziendali degli anni settanta.
Il passaggio dai microprocessori a 8 bit ai microprocessori a 16 bit non va
solamente visto come un’evoluzione quantitativa delle potenzialità dei
microprocessori ma come evoluzione qualitativa nel tentativo di ricreare le
potenzialità dei primi minicomputer e mainframe in un personal computer.
Le limitazioni di un processore a 8 bit erano del resto chiarissime, non potendo
questo gestire, se non con innaturali paginazioni, memorie superiori a 64 K ed
era limitato dalla dimensione dei suoi registri nell’esecuzione di operazioni su
insiemi di dati complessi, in special modo nell’ambio delle operazioni
matematiche.
1982: MICROPROCESSORE 80286
Dopo l’80186 e l’80188, venne
commercializzato nel tardo 1982 il
processore 286, che rappresentò una
vera e propria rivoluzione nel mondo
personal. Fu il primo processore
completamente a 16 bit, in grado cioè
di accedere a due byte di memoria

260 Appendice B
consecutivi in un’unica operazione.
Tra le nuove caratteristiche, cinque nuovi registri per la gestione della memoria
in modalità multitasking e la possibilità, per mantenere la compatibilità verso il
basso, di poter lavorare in modalità reale o protetta. Nella prima modalità si
comporta come l’8086 e non utilizza i nuovi registri: è compatibile con il suo
predecessore, col vantaggio di essere molto più veloce. Nella modalità protetta
consente il multitasking e la protezione tra task e memoria virtuale. La modalità
protetta non ebbe inizialmente successo: le applicazioni per 8086 esistenti non
erano compatibili e solo nel 1987 verrà sviluppato l’OS/2, un sistema operativo
in grado di operare in modalità protetta.
La frequenza di clock inizialmente era di 6 MHz, divenne presto otto, quindi
dieci e poi 12 nel 1984. Negli anni successivi, usciranno versioni a 16 e persino
a 20 MHz.
Secondo alcune stime, entro 6 anni dall’introduzione del processore 286, i
personal computer basati su questo processore erano 15 milioni in tutto il
mondo. Con il 286, il PC esce dalla categoria dei sistemi batch (sistemi che
eseguono vari lavori in sequenza) per entrare a fare parte dei sistemi
multitasking (sistemi nei quali i processi possono avanzare in parallelo).
1985: MICROPROCESSORE 80386
Con questo processore si realizza un ulteriore passo avanti: raddoppiano la
dimensione dei registri e del bus dei dati, portati a 32 bit reali. Questo fa sì che
si possano eseguire istruzioni con numeri maggiori come operandi.

Storia dei processori Intel® 261
E’ in grado di eseguire tutte le
istruzioni dei chip precedenti, ma
li sorpassa in termini di
prestazioni. I primi chip
operavano a frequenze di 12,5 e
16 MHz; nel tardo 1986 venne
commercializzata la versione a
20 MHz, seguita due anni dopo
da quella a 25 MHz. Nel 1989 arrivarono i "mostri" a 33 MHz.
L’80386 può lavorare in tre differenti modalità: reale, protetta e virtuale 86.
Nella prima modalità lavora come un 8086, ma è decisamente più veloce. In
modalità protetta lavora come l’80286, consentendo il multitasking, la
protezione e la gestione della memoria virtuale, consentendo però anche la
paginazione. Per ridurre la frammentazione in memoria e per poter allocare
processi che non potrebbero essere caricati a meno di non ricorrere alla
riconfigurazione della memoria, si suddivide la memoria centrale in pagine,
nelle quali allocare le parti logiche del processo. Le pagine sono di dimensioni
fisse, ad esempio 4 K o una qualche potenza del 2. La modalità virtuale 86
permette di inizializzare un numero indefinito di macchine virtuali in
esecuzione in modalità reale, assegnando a ciascun processo 1 Mb di memoria e
una copia del DOS, come se si trattasse di un elaboratore 8086. Ogni macchina
virtuale è in grado di gestire autonomamente un applicativo, mantenendolo
isolato dalle altre istanze. In questo modo, un programma viene eseguito come

262 Appendice B
accadrebbe con l’8086, ma senza perdere i vantaggi della modalità protetta:
anche se un processo si blocca, rimangono attivi il multitasking e i meccanismi
di protezione e non si ferma tutto l’elaboratore.
Gli analisti avevano previsto che il processore non avrebbe avuto un mercato di
largo consumo e ne prevedevano un uso limitato ad architetti e scienziati. Per
soddisfare l’utenza, non disposta a pagare l’alto prezzo del processore, che in
Italia nel 1984 costava circa 800 mila lire, l’ Intel ® commercializzerà dal 1988
la serie 80386sx, con un clock interno a 16 bit, come gli 8086.
Successivamente, la versione originale dell’80386 verrà commercializzata con
la sigla dx.
1989: MICROPROCESSORE 80486
E’ un 80386 al quale viene affiancato, in
un unico chip, il coprocessore 80387, dato
che integra al suo interno molte di quelle
parti che erano considerate moduli
aggiuntivi nei microprocessori precedenti;
moduli come il coprocessore matematico,
appunto, o come la memoria cache.
L’ Intel ® , pur tenendo in considerazione la
compatibilità con i processori precedenti,
modifica leggermente l’architettura e per
la prima volta implementa delle routine Risc nella progettazione, ottenendo una
diminuzione del tempo di esecuzione delle singole istruzioni a parità di

Storia dei processori Intel® 263
frequenza di clock. Inoltre, la nuova tecnologia costruttiva permette di
realizzare le comunicazioni verso l’esterno a 33 MHz evitando problemi di
compatibilità con circuiterie non modernissime, mentre la velocità interna di
elaborazione è di 66 MHz.
Grazie alla differente tecnologia, a parità di clock ha prestazioni da due a tre
volte superiori rispetto a quelle dell’80386 e nel coprocessore matematico c’è
un aumento delle prestazioni superiore al cinquanta per cento.
Il processore originale lavorava a 25 MHz, ma anche per il 486 venne adottata
la stessa strategia per il processore precedente: un paio di anni più tardi uscì una
versione senza coprocessore matematico (80486sx), meno potente ma meno
costosa. La versione 80486dx aveva una frequenza di 33 MHz, seguita in poco
tempo dall’80486 dx2 (con clock a 50 MHz) e dalla versione a 66 MHz. Anche
con il sopraggiungere della tecnologia Pentium ® , la Intel ® continuò la
produzione dei chip 486, giungendo nel 1995 alla versione 80486dx4 con clock
a 100 MHz, in grado di rivaleggiare con un Pentium ® a 66 MHz.
La tabella seguente riassume le caratteristiche principali dei modelli appena
trattati.
Processore
Dimensione
registri
Linee
bus
dati
Linee
bus
indirizzi
Memoria
indirizzabile
8088 16 bit 8 20 1 Mb 8087
8086 16 bit 16 20 1 Mb 8087
Coprocessore
richiesto

264 Appendice B
Processore
Dimensione
registri
Linee
bus
dati
Linee
bus
indirizzi
Memoria
indirizzabile
80286 16 bit 16 24 16 Mb 80287
80386SX 32 bit 16 24 16 Mb 80387
80386DX 32 bit 32 32 4 Gb 80387
80486SX 32 bit 32 32 4 Gb 80387
Coprocessore
richiesto
80486 32 bit 32 32 4 Gb Incorporato

Storia dei processori Intel® 265
Evoluzione dei processori Intel ® a partire dal Pentium
1993: PROCESSORE PENTIUM
Le caratteristiche principali sono rappresentate dalla presenza di registri a 64
bit, dalla capacità di eseguire più di una istruzione per clock, dalla notevole
presenza del coprocessore matematico. Il processore, cinque volte più potente di
un 486 a 25 MHz, incorpora una tecnologia che permette di miniaturizzare in un
solo chip ben 3,1 milioni di transistor, rispetto al milione utilizzato nel 486.
Il Pentium ® è dotato di due cache aggiuntive da 8 Kb, una per il codice e una
per i dati. La doppia cache incorporata rende il processore più efficiente
nell’elaborazione.
La predisposizione alle operazioni di risparmio energetico permette di
razionalizzare il consumo elettrico e di aggiungere ulteriori funzioni di
sicurezza.

266 Appendice B
Nel 1994 viene introdotto il Pentium ® a 90 MHz, che funziona a 3,3 volt
anziché a cinque tipici delle CPU 80x86. L’anno successivo escono processore
con frequenze a clock 75, 90 e 100 MHz. A distanza di poco tempo, le CPU
arrivano ad una capacità di elaborazione a 120 e 133 MHz, mentre nel 1996
escono i modelli a 150, 166 e 200 MHz. Nel 1994, un insegnante universitario
scopre che il Pentium ® genera in certe situazioni risultati errati nei calcoli in
virgola mobile.
1995: PROCESSORE PENTIUM ® PRO
Presentato nell’autunno del 1995, il processore Pentium ® Pro è stato progettato
per potenziare le applicazioni a 32 bit a livello di workstation e di server, in
quanto consente di effettuare operazioni veloci di CAD, ingegneria meccanica e
calcolo scientifico. Ogni processore Pentium ® Pro viene fornito insieme ad un
secondo chip di memoria cache per il potenziamento della velocità. Il potente

Storia dei processori Intel® 267
processore Pentium ® Pro vanta 5,5 milioni di transistor; la velocità minima dei
modelli é di 150 MHz.
1997: PROCESSORE PENTIUM ® II
Costruito con la tecnologia a 0,35 micron (la dimensione
massima di un singolo transistor nel processore), il
processore Pentium ® II conta 7,5 milioni di transistor.
Incorpora la tecnologia MMX di Intel ® , progettata
specificamente per l’elaborazione efficiente di dati video, audio e grafici. Viene
fornito con un chip di memoria cache ad alta velocità in una innovativa
cartuccia S.E.C. (Single Edge Contact), collegata
alla scheda madre tramite un connettore che presenta
una singola estremità anziché una serie di pin.
Il bus di sistema è passato dai 66 MHz, per le versioni con frequenze dai 233 ai
333 MHz, ai 100 MHz per versioni fino ai 450 MHz. Il Pentium ® II raggiunge la
velocità di 450 MHz nell’estate 1998.
Le prime versioni del processore, nome in codice Klamath, sono state prodotte
con la tecnologia a 0,35 micron. Gli ultimi modelli del Pentium ® II (con
frequenze superiori ai 333 MHz), nome in codice Deschutes, sono stati prodotti
con la tecnologia a 0,25 micron. Il Deschutes consente così, grazie alle ridotte
dimensioni, un minore consumo energetico, minore surriscaldamento e quindi
maggiore velocità. Esistono due versioni di Deschutes per portatili, a 300 e 366
MHz.

268 Appendice B
L’introduzione del Pentium ® II ha comportato però la drastica modifica della
struttura delle schede madri, che devono essere in grado di ospitare
l’alloggiamento del processore: uno slot invece del classico zoccolo, e i nuovi
moduli per la memoria RAM, da 72 contatti (Simm) ai dieci volte più veloci
moduli a 168 contatti (Dimm).
1997: PROCESSORE PENTIUM ® III
La prima versione di Pentium ® III, chiamata Katmai,
era in pratica un Pentium ® II costruito con un
processo a 250 nm, con l’aggiunta delle istruzioni
SSE ed un migliorato controllo della memoria cache
L2 da 512 KB. Fu inizialmente diffuso a velocità di
450 MHz e 500 MHz con BUS a 100 MHz. Katmai utilizzava inoltre lo stesso
involucro a slot del Pentium ® II, lo Slot 1.
La seconda versione, Coppermine, costruita a 180 nm, aveva una memoria
cache L2 ridotta a 256 KB ma integrata a piena velocità, caratteristica che
migliorò le prestazioni rispetto a Katmai. Messa sotto pressione dalla valida
concorrenza di AMD ® col suo Athlon Classic, Intel ® aveva riprogettato il chip
internamente, e rimediato agli ormai noti stalli nella pipeline. Il risultato fu un
miglioramento del 30% nell’esecuzione delle istruzioni. Le frequenze salirono
velocemente, dagli originari 733 Mhz al GHz e a metà del 2000 Intel ® lanciò
una versione a 1,13 GHz, ma un popolare sito di hardware provò in una
recensione che questa non era abbastanza stabile da far girare il kernel Linux. Il
problema fu identificato nella cache integrata, che non poteva essere cloccata a

Storia dei processori Intel® 269
velocità oltre il GHz. Intel ® impiegò sei mesi per risolvere il problema e infine
rilasciò le versioni a 1,1 e 1,13 GHz nel 2001.
2000: PROCESSORE PENTIUM ® IV
GHz e 1,5 GHz
Il Pentium ® 4 è un microprocessore x86 di settima
generazione prodotto da Intel ® , ed è il primo design
originale di quest’ultima dai tempi del Pentium ® Pro, nel
1995. Il processore originale, chiamato Willamette, fu
lanciato il 20 novembre del 2000 con frequenze di 1,4
A partire dal Pentium ® Pro, si erano succeduti processori basati sull’architettura
"P6", con marginali miglioramenti (il Pentium ® II, il Pentium ® III, ed i vari
Celeron); il Pentium ® 4 invece si basa sulla nuova architettura NetBurst. Inoltre
fu introdotto un velocissimo FSB a 400 MHz, formato in realtà da quattro bus a
100 MHz; tuttavia la larghezza di banda era pari a quattro volte quelle di un bus
a 100 MHz, e fu così considerato come un unico bus a 400 MHz (il competitore
più veloce non andava oltre i 133 MHz effettivi).
Per la sorpresa di molti tecnici del settore, il nuovo processore non migliorava il
design P6 né nel calcolo intero, né in virgola mobile, generalmente considerati i
fattori chiave nelle prestazioni di un processore. Furono sacrificate le
prestazioni nel singolo ciclo di clock per guadagnare su due fronti: nella
massima frequenza raggiungibile, e nelle prestazioni sfruttando le nuove librerie
SSE2 che andavano ad aggiungersi alle precedenti SSE ed MMX.

270 Appendice B
Il Pentium ® 4 "svolge molto meno lavoro" in ogni ciclo di clock rispetto ad altre
CPU (come ad esempio i vari AMD ® Athlon o i vecchi Pentium ® III), ma
l’obiettivo iniziale di sacrificare le prestazioni sul singolo ciclo di clock era
bilanciato dalla possibilità di aumentare molto velocemente la frequenza di
funzionamento, caratteristica che portava comunque a ottime prestazioni
paragonabili a quelle dei processori della rivale AMD ® , pur seguendo una
strategia diversa. Tutto questo è andato avanti fino a quando il processore ha
trovato problemi insolubili di eccessiva produzione di calore, poco prima di
raggiungere i 4 GHz (fermandosi effettivamente a 3.8 GHz con il core Prescott),
molto lontano dagli annunci entusiastici del lancio che parlavano di scalabilità
fino a 10 GHz.
Alla metà del 2005, resasi conto che ormai la "corsa ai GHz" era finita, la casa
produttrice ha spostato la sua attenzione sull’architettura del Pentium ® M, molto
più efficiente a parità di frequenza di funzionamento, cominciando lo sviluppo
di alcuni derivati dedicati al segmento desktop e piccoli server. Infatti
l’architettura del Pentium ® M, è ottimizzata anche dal punto di vista energetico,
ed è basata sul design del Pentium ® III. Questo significa essenzialmente che
Intel ® è tornata al Pentium ® III e che del Pentium ® 4 sopravviverà solo il sistema
del FSB, oltre ovviamente ad una serie di tecnologie collaterali come Hyper-
Threading, SSE2, SSE3, EM64T e XD-bit.
Il primo Pentium ® 4 aveva core Willamette ed operava ad una frequenza di 1,5
GHz. Inizialmente la sua architettura lo rendeva più lento dei propri antagonisti,
Pentium ® III ed Athlon, ma poi l’enorme scalabilità gli consentì di arrivare in

Storia dei processori Intel® 271
meno di una anno alla barriera "storica" dei 2 GHz, soglia a cui dovette cedere il
passo al suo successore Northwood.
Per abbattere la barriera dei 2 GHz, arrivò Northwood, i cui miglioramenti
consistevano in un ampliamento della memoria cache L2, che passava da 256
KB a 512 KB, e il passaggio ad un nuovo processo di produzione a 130 nm.
Cambiò anche il socket che divenne il 478, e col tempo arrivarono anche
aggiornamenti alla frequenza di BUS che passò dagli iniziali 400 MHz, a 533
MHz e poi addirittura a 800 MHz. Dal modello a 3,06 GHz (l’ultimo a 533
MHz di bus) venne introdotta anche la tecnologia Hyper-Threading che venne
estesa a tutta l’ultima gamma con bus a 800 MHz da 2,4 GHz fino all’ultimo
Northwood arrivato sul mercato a 3,4 GHz.
Nel settembre del 2003 fu annunciato all’ Intel ® Developer Forum il Pentium ® 4
Extreme Edition (P4EE), poco più di una settimana prima del lancio dell’Athlon
64 e dell’Athlon 64 FX (anche se la sua commercializzazione, per la verità
molto scarsa, iniziò solo il 3 novembre). Il design rimaneva pressoché invariato
rispetto al Northwood (per farlo funzionare sulle stesse schede madri), ma
possedeva ulteriori 2 MB di cache L3 ereditati dal progetto dello Xeon Gallatin.
Un anno più tardi, il 15 novembre 2004 fu aumentata la velocità di bus da 800
MHz a 1066 MHz, con un piccolo miglioramento delle prestazioni, ma fu
rilasciato solo un chip che utilizzava tale frequenza di bus, il modello a 3,46
GHz. Successivamente anche il Pentium ® 4 Extreme Edition passò al core

272 Appendice B
Prescott. Il nuovo EE a 3,73 GHz aveva le stesse caratteristiche di un Prescott
della serie 6x0, ma con un bus a 1066 MHz.
Il 2 febbraio 2004 Intel ® lanciò un nuovo core, chiamato Prescott. Questo era
prodotto con un processo a 90 nm, mai usato prima, ed era una revisione
profonda del processore, tanto che alcuni si stupirono del fatto che non fu
chiamato "Pentium ® 5". Le sue caratteristiche dovevano consentirgli di
ricominciare la "corsa ai GHz", ma non fu propriamente così; essa
effettivamente ripartì ma si arresto velocemente a 3,8 GHz senza nemmeno
raggiungere la soglia "psicologica" dei 4 GHz originariamente previsti.
Considerando che Intel ® prevedeva di poter portare il Pentium ® 4 fino a 10 GHz,
questo resta l’insuccesso più pubblicizzato, se non più grave, nella storia del
marchio. Intel ® ha rilasciato il 21 febbraio 2005 un nuovo processore Prescott,
chiamato "6xx", con tecnologie EM64T, XD-bit e SpeedStep oltre ad una cache
L2 di 2 MB. Il vantaggio di quest’ultima è tuttavia pressoché annichilito
dall’alta latenza di questa e dalla doppia dimensione delle parole in modalità
EM64T: risulta quindi un tentativo di mantenere le performance anche in
modalità 64 bit.
Ad inizio 2006 è stato rilasciato il nuovo core Cedar Mill, un Prescott costruito
con processo produttivo a 65 nm. L’architettura è la stessa di Prescott, e anche
le tecnologie implementate sono le stesse presenti nelle ultime evoluzoni del
predecessore. Monta una pipeline a 31 livelli (come Prescott) e, sempre come

Storia dei processori Intel® 273
Prescott, ha 2MiB di cache L2. La gamma di frequenze va da 2.8 GHz a 3.8
GHz. Cedar Mill risolve i problemi di temperatura del predecessore con una
tolleranza fino a 86 W e implementa le nuove tecnologie di virtualizzazione
Vanderpool.
2005: PROCESSORE PENTIUM ® D
Il Pentium ® D è il primo processore dual core prodotto da
Intel ® ed è dedicato al settore Desktop. Nella sua prima
versione era basato sul core Smithfield, che è stato poi
sostituito dalla propria evoluzione, Presler.
Il Pentium ® D inoltre, è il primo processore che supporta il
DCTP-IP, tecnologia necessaria al Digital rights management.
La sua caratteristica principale, innovativa e, senza ombra di dubbio,
rivoluzionaria, risiede nel fatto che esso è, come accennato prima, il primo
processore dual core commercializzato dalla Intel ® . Il suo lancio è stato seguito
dopo pochi giorni da quello dell’Athlon 64 X2 prodotto da AMD ® . In realtà il
Pentium ® D non è il primo microprocessore dual core arrivato sul mercato: già
IBM con i suoi PowerPC aveva raggiunto questo traguardo un paio di anni
prima, e altri produttori avevano seguito la sua strada, ma l’avvento del
Pentium ® D segna comunque un’epoca in quanto praticamente solo Intel ® e
AMD ® si contendono la grossa fetta del mercato di massa dei microprocessori.
Ma perché si è passati alle architetture a doppio core? Per un motivo molto
semplice: ormai da più di due anni le frequenze dei processori erano

274 Appendice B
praticamente ferme. Dopo anni in cui queste ultime sono cresciute
vertiginosamente, con le presentazioni di nuovi modelli ogni circa 2 mesi con
200 MHz di salto, si è arrivati velocemente ai 3 GHz e sono nati i problemi. Il
passaggio ai 90 nm non ha dato i risultati sperati, e l’avvento del core Prescott
per i Pentium ® 4 è stato molto travagliato e non privo di difficoltà e delusioni.
AMD ® aveva abbandonato la "corsa ai MHz" già da diverso tempo e Intel ® si è
trovata costretta a fare altrettanto, migliorando l’efficienza dell’architettura e
sviluppando il calcolo parallelo. In fondo è una logica conseguenza: se non si
riesce ad aumentare la velocità con cui si esegue un’operazione, per aumentare
le prestazioni bisogna aumentare il numero di operazioni che si possono
compiere nell’unità di tempo, e il continuo affinamento dei processi costruttivi e
la miniaturizzazione hanno consentito di imboccare questa nuova via.
Nel 2007 sono arrivate le architetture a 4 core e poi via via nel tempo si passerà
a quelle multi core.
Il primo Pentium ® D arrivato sul mercato è basato sul Smithfield, che
fondamentalmente è formato da due core Pentium ® 4 Prescott integrati nello
stesso package. Ha una cache L2 di 2 MB equamente suddivisa tra i 2 core, e
condivide con l’ultima evoluzione di Prescott tutte le tecnologie accessorie, tra
cui il processo costruttivo a 90 nm e le istruzioni SSE, SSE2, SSE3, EM64T,
SpeedStep. Nella versione Pentium ® Extreme Edition viene integrato anche il
supporto Hyper-Threading.
Il successore di Smithfield è Presler, arrivato sul mercato nel gennaio 2006. È
costruito a 65 nm ed è il primo processore Intel ® dual core con i due core

Storia dei processori Intel® 275
distinti sul package. Le frequenze sono leggermente più alte di Smithfield, dai
2,8 GHz ai 3,4 GHz inizialmente, ma successivamente è stata presentata una
versione a 3,6 GHz. Si tratta inoltre dell’ultimo processore Intel ® basato
sull’architettura NetBurst del Pentium ® 4.
2006: PROCESSORE CORE 2 DUO
Core 2 Duo è il nome commerciale di una serie di
microprocessori x86 di ottava generazione sviluppati da
Intel ® , presentati il 27 luglio 2006.
A differenza di quanto accaduto in passato, Intel ® ha
deciso di raggruppare sotto il nome di Core 2 Duo
diversi processori (i primi esponenti sono Merom e
Conroe) destinati a diversi settori di mercato. Per la prima volta infatti sia il
mercato dei sistemi portatili che dei sistemi desktop si basano su un unico
processore.
Nella versione desktop Core 2 Duo è il successore del Pentium ® D Presler,
mentre nell’ambito mobile è il successore del Core Duo Yonah.
La nuova architettura, comune anche al fratello maggiore Core 2 Extreme,
deriva in parte da quella del Pentium ® M e più specificatamente da quella del
suo primo successore dual core, il Core Duo Yonah. Intel ® comunque ha
dichiarato che le innovazioni apportate con Core 2 Duo sono diverse di
conseguenza l’azienda vuole proporla come un’architettura completamente
nuova denominata Intel ® Core Microarchitecture (o P8), e viene identificata
come successore della precedente architettura NetBurst (o P7).

276 Appendice B
L’introduzione del Core 2 Duo, inoltre, ha segnato nella gamma Intel ®
l’abbandono del nome storico "Pentium" per la fascia alta del mercato, per la
prima volta dal 1993, relegandolo alla fascia medio/bassa.
L’introduzione del Core 2 Duo ha segnato un punto di svolta nella politica di
mercato di Intel ® . La sua adozione in ambito desktop, infatti è coincisa con la
morte dell’architettura NetBurst che è alla base del Pentium ® 4 e dei Pentium ® D
(Smithfield e Presler) e che si è rivelata efficace in un momento in cui
aumentare la frequenza di clock non era un problema, ma straordinariamente
inefficiente dal punto di vista del rapporto prestazioni/Watt. Prendendo come
riferimento l’architettura NetBurst del Pentium ® 4 Northwood, Intel ® è arrivata
con Conroe a quintuplicare l’efficienza, e quindi le prestazioni, a parità di Watt
dissipati. È evidente inoltre, come fino a Smithfield che mantiene
fondamentalmente la stessa architettura del Pentium ® 4, tale aumento sia stato
molto marginale. Dato che ormai aumentare il clock è diventato quasi
impossibile senza l’insorgere di numerose complicazioni legate alla
dissipazione termica, quella dell’efficienza dell’architettura e la
parallelizzazione delle operazioni, sembra la strada migliore per proseguire il
processo di innovazione.
2007 CORE 2 QUAD
Core 2 Quad è il nome commerciale di un processore che
Intel ® ha presentato l’8 gennaio 2007 come variante
"economica" dei primi processori a 4 core Core 2 Extreme,
basati sull’architettura Intel ® Core Microarchitecture. Lo scopo di questo

Storia dei processori Intel® 277
prodotto era quello di diventare la "porta d’ingresso" ai processori a 4 core
indirizzati a tutto il mercato e non solo agli appassionati che storicamente sono
gli unici ad essere attratti dalla versione Extreme. Proprio per questo motivo si
inseriva nella fascia di mercato tra i Core 2 Duo, che sono processori dual core
e i Core 2 Extreme da 4 core e con clock ancora più elevati.
Essendo la prima CPU a 4 core prodotta da Intel ® (e basata sul core Kentsfield),
insieme ai Core 2 Extreme, non esiste un vero e proprio predecessore del Core 2
Quad; è possibile indicarne uno possibile nel Pentium ® D Presler che era
anch’esso un processore dual core, sebbene basato sulla vecchia architettura
NetBurst (derivata dal Pentium ® 4). Più precisamente si può indicare il
Pentium ® D come il predecessore comune sia al Core 2 Quad che al Core 2 Duo.
Tra la fine del 2007 e l’inizio del 2008, con il passaggio al nuovo processo
produttivo a 45 nm, venne rilasciata la nuova generazione del Core 2 Quad,
basata sul nuovo core Yorkfield e, successivamente, ad agosto 2008, anche una
versione mobile basata sul core Penryn; si trattava del primo processore mobile
a 4 core realizzato da Intel ® .
2008: PROCESSORE CORE I7
Core i7 è il nome commerciale di una serie di
microprocessori x86 di nona generazione sviluppati da
Intel ® e presentati il 17 novembre 2008.
Le CPU Core i7, insieme alle controparti di fascia più alta Core i7 Extreme,
sono le prime incarnazioni della nuova architettura Nehalem, successiva alla
Intel ® Core Microarchitecture, e che andrà progressivamente a sostituire in tutti

278 Appendice B
i settori di mercato, prendendo gradualmente il posto dei Core 2 Duo, Core 2
Quad e Core 2 Extreme.
Sembra che Intel ® abbia intenzione di indicare con il nome di Core i7 solo i
processori destinati alla fascia più alta del mercato desktop, mentre per la fasce
di mercato inferiori e il settore mobile, probabilmente verranno utilizzati altri
nomi commerciali, tra questi il più probabile è Core i5, atteso nel terzo trimestre
2009 per la fascia media del mercato desktop.
La nuova architettura, comune anche al fratello maggiore Core i7 Extreme,
deriva in parte dalla "Core" dei predecessori, ma Intel ® ha comunque dichiarato
che le innovazioni apportate sono talmente tante che è assolutamente doveroso
considerare il nuovo progetto come un vero e proprio salto generazionale e non
solo come un affinamento.
Intel ® inoltre ha reso noto che la scelta del nuovo nome commerciale Core i7
non ha una motivazione ben precisa, ma esprime comunque chiaramente
l’intenzione di mantenere una certa continuità con la precedente serie Core 2
grazie all’uso del suffisso "Core".
La produzione dei processori Core i7 avviene nei 3 stabilimenti che Intel ® ha
negli Stati Uniti, e in particolare in quello di Hillsboro in Oregon (dove tra
l’altro ha sede proprio il centro di sviluppo che ha progettato la nuova
architettura) e in quelli situati in Arizona e New Mexico.

Bibliografia
1. Wechsler, Ofri. Inside Intel® Core Microarchitecture: Setting New
Standards for Energy-Efficient Performance. 2006.
2. Intel® Corporation. ENERGY-EFFICIENT PERFORMANCE ON THE CLIENT: A
Proposed Measurement Methodology. 2007.
3. Saracco, Roberto. Il futuro della Legge di Moore. s.l. : Apogeo, 2002.
4. Patterson, Hennessy and. Computer Architecture: A Quantitative Approach,
4th edition. 2006.
5. Moore, Gordon E. Cramming more components onto integrated circuits.
Electronics. 1965, Vol. 38, 8.
6. Intel® Corporation. Moore's Law. Sito Web Intel Corporation. [Online] 2009.
http://www.intel.com/technology/mooreslaw/index.htm?iid=tech_silicon_mo
oreslaw+rhc_moore_law.
7. Moore, Gordon E. Progress in digital integrated electronics. Proceedings of
International Electron Devices Meeting. 1975, Vol. 21, p. 11-13.
8. Bucci, Giacomo. Architettura e organizzazione dei calcolatori elettronici. s.l. :
McGraw-Hill, 2009.
9. Amdhal, Gene M. The logical design of an inetrmediate speed digital
computer. 1951. PhD.Thesis.
10. Microprogramming and the Design of the control Circuits in an Electronic
Digital Computer. Wilkes, M.V. e Stinger, J.B. 1953, Proceedings of the
Cambridge Philosophical Society, p. 230-238.
11. Very high-speed computing systems. Flynn, Michael J. 12, Dec 1966,
Proceedings of the IEEE, Vol. 54, p. 1901 - 1909.
12. Pomerene, James H. Machine for multiple instruction execution. 4.295.193
[a cura di] International Business Machines Corporation. USA, 1981.
13. Evaluating Associativity in CPU Caches. Hill, M.D. e Smith, A.J. 12, 1989,
IEEE Transactions On Computers, Vol. 38, p. 1612-1630.

280 Bibliografia
14. Trace Cache: a Low Latency Approach to High Bandwidth Instruction
Fetching. Rotenberg, Eric, Bennett, Steve e Smith, James E. 1996. Proceedings
of the 29th Annual International Symposium on Microarchitecture.
15. Marchetti, Lorenzo. Le tecnologie dei processori: CISC vs RISC. [Online]
http://www.lithium.it/articolo.asp?code=20.
16. Intel. Intel's Tick-Tock Model. Sito Web Intel Corporation. [Online]
http://www.intel.com/technology/tick-tock/.
17. B. Wopperer, G. Wurthmann. Il processore Pentium - LA nuova
generazione dell'architettura Intel. 1993.
18. Intel 80486 ("486") Case Study. [Online]
http://www.cs.clemson.edu/~mark/330/colwell/case_486.html.
19. Intel Corporation. Intec Architecture Optimization Manual. 1997. Order
Number: 242816-003.
20. Kagan, Michael, et al. MMX Microarchitecture of Pentium® Processors
With MMX Technology and Pentium® II Microprocessors. Intel Technology
Journal. Q3, 1997.
21. Intel Corporation. Intel Architecture Optimization Reference Manual. 1999.
Order Number: 245127-001.
22. Intel Corporation. IA-32 Intel® Architecture Optimization Reference
Manual. 2005. Order Number: 248966-012.
23. Hinton, Glenn, et al. The Microarchitecture of the Pentium® 4 Processor.
Intel Technology Journal. Q1, 2001.
24. Intel Corporation. Intel® 64 and IA-32 Architectures Optimization Reference
Manual. 2008. Order Number: 248966-017.
25. Koufaty, David e Dobora, T. Marr. Hyperthreading Technology in the
netburst Microarchitecture. IEEE Computer Socciety. 2003.
26. Klauser A., Austin T., Grunwald D., Calder, B. Dynamic hammock
predication for non-predicated instruction set architectures. Parallel
Architectures and Compilation Techniques,. 1998.

Bibliografia 281
27. Ramanathan, R.M. Extending the World’s Most Popular Processor
Architecture. s.l. : Intel Corporation, 2006.
28. Benini, Luca. Ottimizzazioni microarchitetturali per high performance
computing. 2004.
29. Benini, Luca. Calcolo ad alte prestazioni su architettura ibrida CPU-GPU.
Tesi di Laurea. 2006.
30. Intel Corporation. White Paper: Extending the World’s Most Popular
Processor Architecture. New innovations that improve the performance and
energy efficiency of Intel® architecture. [Elettronico]. 2007.
31. Amdahl’s Law in the Multicore. Hill, M. and Marty, M.R. 7, 2008, IEEE
Computer, Vol. 41, pp. 33-38.
32. Chip Multiprocessing and the Cell. Gschwind, M. 2006, Computing
Frontiers.
33. Sun UltraSPARC T2 Processor. [Online]
http://www.sun.com/processors/UltraSPARC-T2/.
34. Intel Announces Dunnington Processor,. [Online]
http://www.intel.com/pressroom/archive/releases/20080317fact.htm.
35. nVIDIA Quadro FX 3700M. [Online]
http://www.nvidia.com/object/product_quadro_fx_3700_m_us.html.
36. GRAPE-DR: 2-Pflops Massively-Parallel Computer with 512-Core, 512-Gflops
Processor Chips for Scientific Computing. Makino, J., Hiraki, K. e M. Inaba.
2007. Proc. of ACM/IEEE Supercomputing’07.
37. Sun, Xian-He e Chen, Yong. Reevaluating Amdahl’s Law in the Multicore
Era. Department of Computer Science, Illinois Institute of Technology. 2008.
http://www.cs.iit.edu.
38. Asanovic, Krste, et al. The Landscape of Parallel Computing Research: A
View from Berkeley. Electrical Engineering and Computer Sciences, University
of California at Berkeley. 2006.
http://www.eecs.berkeley.edu/Pubs/TechRpts/2006/EECS-2006-183.html.

282 Bibliografia
39. Designing Reliable Systems from Unrealiable Components: The Challenges
of Transistor Variability and Degradation. Borkar, S. 2005, IEEE Micro, p. 10-16.
40. The Soft Error Problem: An Architectural Perspective,. Mukherjee, S.S.,
Emer, J. e Reinhardt, S.K. 2005. Proceedings of the 11th International
Symposium on High-Performance Computer Architecture (HPCA-11 2005). p.
243-247.
41. Latency Lags Bandwidth. Patterson, D. 10, Oct 2004, Communications of
the ACM, Vol. 47, p. 71-75.
42. Intel Makes a Big Jump in Computer Math. Moore, Samuel K. 2008, IEEE
Spectrum, p. 14-15.
43. Hitting the Memory Wall: Implications of the Obvious. Wulf, W.A. e McKee,
S.A. 1, Mar 1995, Computer Architecture News, Vol. 23, p. 20-24.
44. Hennessy, J. e Patterson, D. Computer Architecture: A Quantitative
Approach. 4th edition. s.l. : Morgan Kauffman, San Francisco, 2007.
45. Standard Performance Evaluation Corporation (SPEC). [Online]
http://www.spec.org/index.html.
46. Eatherton, W. The Push of Network Processing to the Top of the Pyramid.
Slides available at:
http://www.cesr.ncsu.edu/ancs/slides/eathertonKeynote.pdf keynote address
at Symposium on Architectures for Networking and Communications System.
26-28 Oct 2005.
47. Colella, P. Defining Software Requirements for Scientific Computing.
presentation. 2004.
48. Dubey, P. Recognition, Mining and Synthesis Moves Computers to the Era
of Tera. Technology@Intel Magazine. Feb 2005.
49. Chen, Y.K. Private Communication. 2006.
50. Comparing Network Processor Programming Environments: A Case Study.
Shah, N., Plishker, W. e Keutzer, K. 2004. Proceedings of Workshop on
Productivity and Performance in High-End Computing (P-PHEC).

Bibliografia 283
51. DARPA High Productivity Computer Systems home page. [Online] 2006.
http://www.highproductivity.org/.
52. Arvind, et al. RAMP: Research Accelerator for Multiple Processors - A
Community. U.C. Berkeley. 2005. UCB/CSD-05-1412.
53. Velardi, Daniele Oronzo. Tesi di Laurea. Analisi comparativa tra processori
Intel ad architettura IA-32 e IA-64. 2004.
54. Architettura dei calcolatori - Un approccio strutturale. Tanenbaum, A.S.
s.l. : Pearson Education Italia, 2006.