Architetture dei sistemi di elaborazione - Appunti completi (MIPS, ARM Cortex-M3, Pipeline, Cache)

Corso di Laurea Magistrale in Informatica

Appunti di Architetture Dei Sistemi Di

Elaborazione

Anno Accademico 2024/2025

Studente: Emmanuel Messina

Politecnico Di Torino

Indice

1 Introduzione all’architettura dei calcolatori 6

1.1 Evoluzione dei calcolatori . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6

1.2 Il mercato dei calcolatori . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7

1.3 Sviluppo di un calcolatore . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7

1.4 Prestazioni dei calcolatori . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 8

1.5 Legge di Amdahl . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 10

1.6 Misurare il tempo di esecuzione di un programma . . . . . . . . . . . . . . . . . . . . 11

2 Instruction Set Architecture 13

2.1 Introduzione all’Instruction Set Architecture . . . . . . . . . . . . . . . . . . . . . . . 13

2.2 Indirizzamento in Memoria . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 15

2.2.1 Big Endian e Little Endian . . . . . . . . . . . . . . . . . . . . . . . . . . . . 15

2.2.2 Allineamento . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 15

2.3 Altri metodi di indirizzamento . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 15

2.4 Tipi di dati . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 17

2.5 Instruction Set Encoding . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 17

2.6 Problemi Contraddittori . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 18

2.7 Come l’Architetto della CPU può aiutare il Compilatore . . . . . . . . . . . . . . . . 19

3 MIPS64 20

3.1 Introduzione al MIPS64 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 20

3.2 Registri . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 20

3.3 Tipi di dati . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 20

3.4 Modi di indirizzamento . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 21

3.5 Formato delle istruzioni . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 21

3.6 Set di Istruzioni . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 21

3.6.1 Caricate e memorizzate . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 21

3.6.2 Operazioni ALU . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 22

3.6.3 Branch e Jump . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 22

3.6.4 Istruzioni in virgola mobile . . . . . . . . . . . . . . . . . . . . . . . . . . . . 22

3.7 Esempi di Programmi in Assembler . . . . . . . . . . . . . . . . . . . . . . . . . . . . 22

3.7.1 Programma semplice . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 22

3.7.2 Secondo esempio . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 23

4 Introduzione al Pipelining 24

4.1 Registri di Pipeline . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 24

4.2 Struttura di un Processore Pipelined . . . . . . . . . . . . . . . . . . . . . . . . . . . 24

4.3 Performance del Pipelining . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 28

4.3.1 Velocità di esecuzione . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 28

4.3.2 Esempio di Calcolo del Speedup . . . . . . . . . . . . . . . . . . . . . . . . . 28

4.4 Limitazioni del Pipelining . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 28

4.4.1 Strutturale . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 28

4.4.2 Data hazards . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 29

4.4.3 Control Hazards . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 32

4.4.4 Soluzione base . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 32

1

4.4.5 Pipeline modificata . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 32

4.5 Soluzioni avanzate per migliorare la pipeline . . . . . . . . . . . . . . . . . . . . . . . 32

4.5.1 Il ruolo del compilatore . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 33

4.5.2 Delayed Branch (Salti ritardati) . . . . . . . . . . . . . . . . . . . . . . . . . 33

5 Pipelining Multicycle 34

5.1 Floating Point . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 34

5.2 Latenza e intervallo di inizializzazione . . . . . . . . . . . . . . . . . . . . . . . . . . 34

5.3 Moltiplicazione e divisione . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 34

5.4 Altri hazards (RAW e WAW) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 35

5.5 Eccezioni ed Interrupts . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 35

5.6 Interrupt Protocol in 80x86 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 37

5.7 Interrupt Protocol in ARM . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 37

5.8 Precise exceptions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 37

5.9 Imprecise exceptions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 37

5.10 Eccezioni contemporanee . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 38

5.11 Instruction set complications . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 38

6 Instruction Level Parallelism 39

6.1 Basic Block . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 39

6.2 Dipendenze . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 40

6.2.1 Dipendenze di dato . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 40

6.2.2 Dipendenze di nome . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 41

6.3 Dipendenze di controllo . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 42

7 Memoria Cache 44

7.1 Introduzione alle memorie cache . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 44

7.2 Organizzazione della cache . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 44

7.3 Posizione Cache . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 46

7.4 Parametri della cache . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 46

7.4.1 Mapping . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 47

7.4.2 Direct Mapping . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 47

7.4.3 Set Associative Mapping . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 47

7.4.4 Fully Associative Mapping . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 48

7.5 Algoritmi di rimpiazzamento . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 48

7.6 Aggiornamento della memoria . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 49

8 Branch Prediction Techniques 50

8.0.1 Branch History Table . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 50

8.1 Predittore a due bit . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 51

8.2 Branch-Target Buffer . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 52

8.3 Gselect . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 53

8.4 Gshare . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 54

2

9 Dynamic Scheduling Techniques 55

9.1 Esecuzione fuori ordine . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 55

9.2 Splitting ID-Stage . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 55

9.3 EX Stage . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 55

9.4 Schemi Hardware per il Dynamic Scheduling . . . . . . . . . . . . . . . . . . . . . . 56

9.4.1 Tomasulo’s Algorithm . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 56

9.5 Instruction Identifiers . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 59

10 Hardware-Based Speculation 60

10.1 Introduzione alla speculazione basata sull’hardware . . . . . . . . . . . . . . . . . . . 60

10.2 Componenti principali della speculazione basata sull’hardware . . . . . . . . . . . . . 60

10.3 Esempi di processori con speculazione basata sull’hardware . . . . . . . . . . . . . . 60

10.4 Architettura di base . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 61

10.5 ReOrder Buffer (ROB) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 61

10.6 ROB e file di registri . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 61

10.7 Campi del ROB . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 62

10.8 Passaggi dell’Esecuzione delle Istruzioni . . . . . . . . . . . . . . . . . . . . . . . . . 62

10.8.1 Gestione dei Hazard . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 64

10.8.2 Esempio di Codice . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 64

10.9 Buffer di Riorganizzazione e Status . . . . . . . . . . . . . . . . . . . . . . . . . . . . 65

10.10Istruzioni di Store e Gestione Eccezioni . . . . . . . . . . . . . . . . . . . . . . . . . 65

10.11Speculazione di Eventi Costosi . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 65

11 Introduzione ai Processori a Emissione Multipla 66

11.1 Schedulazione Statica in Processori a Emissione Multipla . . . . . . . . . . . . . . . 66

11.2 Esempio di Processore Superscalare MIPS a Schedulazione Statica . . . . . . . . . . 66

11.3 Ordine delle Istruzioni nel Pacchetto di Emissione . . . . . . . . . . . . . . . . . . . 66

11.4 Situazione Ideale nelle Operazioni in Virgola Mobile (FP) . . . . . . . . . . . . . . . 66

11.5 Prelievo delle Istruzioni dalla Memoria . . . . . . . . . . . . . . . . . . . . . . . . . . 66

11.6 Unità in Virgola Mobile (FP Units) . . . . . . . . . . . . . . . . . . . . . . . . . . . . 67

11.7 Contesa sui Registri FP . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 67

11.8 Esempio: Esecuzione con e senza Speculazione . . . . . . . . . . . . . . . . . . . . . 67

12 ARM 69

12.1 Introduzione ad ARM . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 69

12.2 Architettura ARM . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 70

12.3 ARM Contex M3 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 72

12.4 ARM Instruction Set . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 75

12.4.1 Program Status Registers (PSR) . . . . . . . . . . . . . . . . . . . . . . . . . 77

12.5 Conditional Execution . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 78

12.6 Direttive . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 79

12.6.1 Registri ARM . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 80

12.6.2 Dichiarazione di Costanti . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 80

12.6.3 Rappresentazione dei Numeri . . . . . . . . . . . . . . . . . . . . . . . . . . . 80

12.6.4 Allocazione di Costanti nella Memoria di Codice . . . . . . . . . . . . . . . . 80

12.6.5 Allineamento della Memoria . . . . . . . . . . . . . . . . . . . . . . . . . . . . 81

12.6.6 Riservare Blocchi di Memoria . . . . . . . . . . . . . . . . . . . . . . . . . . . 81

3

12.7 ALU e Operazioni Svolte . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 81

12.7.1 Flag e Suffisso S . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 82

12.7.2 Struttura Interna della ALU e Operandi . . . . . . . . . . . . . . . . . . . . . 82

12.7.3 Istruzioni Aritmetiche . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 82

12.7.4 Istruzioni Logiche . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 84

12.7.5 Shift e Rotazioni . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 84

12.8 Branch . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 84

12.8.1 Branch Incondizionato . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 84

12.8.2 Loop Infinito . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 85

12.8.3 Differenza tra e con . . . . . . . . . . . . . . . . . . . . . . . . . . 85

LDR ADR BX

12.8.4 Gamma del Branch . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 86

12.8.5 MOV per Jump Incondizionato . . . . . . . . . . . . . . . . . . . . . . . . . . 86

12.8.6 Branch Condizionale: Istruzioni e . . . . . . . . . . . . . . . . . . . 86

B?? BX??

12.8.7 Compare and Branch If Zero/Nonzero (CBZ, CBNZ) . . . . . . . . . . . . . . 87

12.8.8 Cicli (Loop) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 87

12.8.9 Ottimizzazione del For Loop . . . . . . . . . . . . . . . . . . . . . . . . . . . 87

12.8.10 Esecuzione Condizionale con IT . . . . . . . . . . . . . . . . . . . . . . . . . . 87

12.9 Costanti e literal pools . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 88

12.10Literal Pool e Direttiva LTORG . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 90

12.11Caricamento di Indirizzi nei Registri . . . . . . . . . . . . . . . . . . . . . . . . . . . 91

12.12Confronto tra LDR, ADR e ADRL . . . . . . . . . . . . . . . . . . . . . . . . . . . . 91

12.13Accesso in memoria . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 92

12.14Stack . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 95

12.14.1 Esempio di PUSH e POP . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 95

12.14.2 Istruzioni per Gestire Più Dati: LDM e STM . . . . . . . . . . . . . . . . . . 96

12.14.3 Modalità di Indirizzamento . . . . . . . . . . . . . . . . . . . . . . . . . . . . 96

12.14.4 PUSH e POP nel Contesto ARM . . . . . . . . . . . . . . . . . . . . . . . . . 96

12.14.5 Subroutine in ARM . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 97

12.14.6 Chiamate Nidificate . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 97

12.14.7 Passaggio di Parametri alle Subroutine . . . . . . . . . . . . . . . . . . . . . . 98

12.14.8 ABI (Application Binary Interface) e ARM . . . . . . . . . . . . . . . . . . . 99

13 Eccezioni e Interruzioni nelle Architetture ARM 100

13.1 La Interrupt Vector Table (IVT) in ARM Cortex-M . . . . . . . . . . . . . . . . . . 100

13.2 Supervisor Calls (SVC) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 101

13.3 Configurazione Specifica del Processore e Modalità Operative . . . . . . . . . . . . . 103

13.3.1 Registro CONTROL . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 104

14 Programmazione C+Assembly 106

15 Landtiger 108

15.1 Introduzione alla scheda . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 108

15.2 Sample project . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 109

15.3 LED e configurazione dei PIN . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 117

15.4 Pulsanti . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 119

15.5 Interrupt controller . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 121

4

Emmanuel Messina - Architetture dei Sistemi Elettronici 2024/2025

16 Clocking e power managing 125

16.1 PCON e PCONP . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 126

17 Timer 128

17.1 Introduzione ai timer . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 128

17.2 Altri moduli . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 129

17.3 Registri coinvolti . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 130

17.4 Bouncing and debouncing . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 141

18 Polling 145

18.1 Polling Vs Interrupt . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 145

18.2 Caso di Studio: Il Joystick . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 145

18.3 Conclusioni e Recensione Finale . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 147

19 Convertitori A/D e D/A 148

19.1 ADC . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 148

19.2 DAC . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 150

Prima di iniziare a studiare da questi appunti è necessario che tu sappia che, nonostante

Premessa

si sia cercato di fare gli appunti nel miglior modo possibile sia per ripassare al meglio e sia per poter

creare un materiale utile per altri studenti, che ci potrebbero ugualmente essere imprecisioni, errori

di scrittura o altro. In caso di problemi si prega di contattarmi via mail: s333951@studenti.polito.it,

su instagram: oppure sul canale telegram: Se vuoi

@emmanuelmessina00 CLICCA QUI.

sostenere il lavoro svolto, puoi offrirmi un caffè (1 euro) qui: CLICCA QUI.

5

Emmanuel Messina - Architetture dei Sistemi Elettronici 2024/2025

1 Introduzione all’architettura dei calcolatori

1.1 Evoluzione dei calcolatori

L’evoluzione dei calcolatori è stata resa possibile grazie a nuove tecniche di fabbricazione dei tran-

sistor (molto più piccoli), a delle novità nell’architettura dell’hardware e del software. Il primo

computer a uso generale è stato creato alla fine degli anni ’40. Questi primi computer erano enor-

mi, costosi e limitati nelle loro capacità rispetto agli standard odierni. Oggi, un computer personale

che può essere acquistato per circa 500 dollari ha prestazioni e memoria equivalenti a quelle di un

computer che nel 1985 costava circa 1 milione di dollari. Questo dimostra quanto rapidamente e

drasticamente la tecnologia dei computer sia avanzata.

Dalla metà degli anni ’80 c’è stato un aumento delle prestazioni, sono stati introdotti i processori

RISC che hanno permesso di velocizzare l’esecuzione dei programmi. Negli anni 2000 sono iniziati

problemi riguardanti la potenza, il parallelismo e la latenza con i sistemi di memoria. Compaiono

i multicore, non si punta più al processore più grande ma a sistemi con più processori. Nel 2004

si è fermato l&r