mirror of
https://github.com/Steffo99/appunti-magistrali.git
synced 2024-11-27 20:34:18 +00:00
Importa Architettura dei calcolatori da Steffo99/appunti-universitari
This commit is contained in:
parent
a8b8ad3a87
commit
2e748ea187
GPG key ID:
5ADA3868646C3FC0
18 changed files with 684 additions and 0 deletions
|
|
@ -0,0 +1,7 @@
|
|||
#!/bin/bash
|
||||
# Assemble RISV-V assembly (.s) files
|
||||
riscv64-unknown-elf-as -g -o "$1.o" "$1.riscv"
|
||||
# Link RISC-V object (.o) files
|
||||
riscv64-unknown-elf-ld -o "$1.elf" "$1.o"
|
||||
|
||||
exit $?
|
||||
|
|
@ -0,0 +1,4 @@
|
|||
#!/bin/bash
|
||||
riscv64-unknown-elf-objdump "$1.elf"
|
||||
|
||||
exit $?
|
||||
|
|
@ -0,0 +1,5 @@
|
|||
#!/bin/bash
|
||||
# Compile using g++
|
||||
riscv64-unknown-elf-g++ -o "$1.elf" "$1.cc"
|
||||
|
||||
exit $?
|
||||
|
|
@ -0,0 +1,5 @@
|
|||
#!/bin/bash
|
||||
# Compile using g++
|
||||
riscv64-unknown-elf-gcc -o "$1.elf" "$1.cc"
|
||||
|
||||
exit $?
|
||||
|
|
@ -0,0 +1,4 @@
|
|||
#!/bin/bash
|
||||
riscv64-unknown-elf-gprof "$1.elf"
|
||||
|
||||
exit $?
|
||||
|
|
@ -0,0 +1,4 @@
|
|||
#!/bin/bash
|
||||
riscv64-unknown-elf-readelf "$1.elf" -a
|
||||
|
||||
exit $?
|
||||
17
2 - Architettura dei calcolatori/0 - Script forniti/run.sh
Normal file
17
2 - Architettura dei calcolatori/0 - Script forniti/run.sh
Normal file
|
|
@ -0,0 +1,17 @@
|
|||
#!/bin/bash
|
||||
# Sintassi: ./run.sh nomefile
|
||||
# Non mettete l'estensione!
|
||||
# Potrebbe esserci bisogno di installare xterm prima
|
||||
# Se non funziona, installatelo con
|
||||
# sudo apt install xterm
|
||||
|
||||
echo "Cleaning phase"
|
||||
rm "$1.o"
|
||||
rm "$1.elf"
|
||||
echo "Compilation phase"
|
||||
riscv64-unknown-elf-as -g -o "$1.o" "$1.riscv"
|
||||
riscv64-unknown-elf-ld -o "$1.elf" "$1.o"
|
||||
echo "Debugging phase"
|
||||
xterm -e "qemu-riscv64 -g 1234 \"$1.elf\"" &
|
||||
xterm -e "riscv64-unknown-elf-gdb --ex=\"target remote localhost:1234\" \"$1.elf\"" &
|
||||
wait
|
||||
|
|
@ -0,0 +1,24 @@
|
|||
# Architettura dei Calcolatori
|
||||
|
||||
Docente: [**Andrea Mariongiu**](mailto:andrea.mariongiu@unimore.it)
|
||||
|
||||
Crediti: **9 CFU** (72 ore di lezione)
|
||||
|
||||
### Materiale
|
||||
|
||||
Libri:
|
||||
- `ISBN9780128122761`
|
||||
- `ISBN9788871924618`
|
||||
|
||||
**[Sito web](http://algo.ing.unimo.it/people/andrea/Didattica/Architetture/index.html)**
|
||||
|
||||
[Slides 2017](http://dolly.fim.unimore.it/2017/course/view.php?id=57)
|
||||
|
||||
### Esame
|
||||
|
||||
- Prova scritta
|
||||
- Serie di domande a risposta singola, multipla e libera, simile a Programmazione 1
|
||||
- Rimane valida fino alla fine della sessione seguente
|
||||
- Prova orale
|
||||
- Può essere sostituita con lo sviluppo di un _progettino_
|
||||
|
||||
|
|
@ -0,0 +1,47 @@
|
|||
# I principi dell'architettura dei calcolatori
|
||||
|
||||
## Gli otto grandi principi
|
||||
|
||||
- Progetta per la **Legge di Moore**
|
||||
- **Astrai** per semplificare il design
|
||||
- Velocizza i **casi più comuni**
|
||||
- Sfrutta il **parallelismo**
|
||||
- Instruction level parallelism
|
||||
- In una sola CPU vengono realizzati più calcoli in parallelo
|
||||
- Sfrutta le **pipeline**
|
||||
- Pipelining
|
||||
- Separare le azioni del processore in fasi
|
||||
- Il fetch è separato dal decoding, mentre decodifico un'istruzione posso già fetchare quell'altra
|
||||
- **Prevedi** le istruzioni successive
|
||||
- **Gerarchizza** le memorie per velocità di accesso
|
||||
- La CPU cerca sempre di accedere alle memorie più veloci
|
||||
- Rendi affidabile con la **ridondanza**
|
||||
|
||||
### Parallelismo
|
||||
|
||||
> Chiedo a 100 persone di fare una moltiplicazione ciascuna invece che fare 100 moltiplicazioni io da solo
|
||||
|
||||
### Pipelining
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
### Gerarchia delle memorie
|
||||
|
||||
> Hit or miss? I hope they never miss.
|
||||
|
||||
La CPU prova sempre ad accedere alle memorie più in alto di questa lista, effettuando un **hit** se trova i dati che le servono in una data memoria ed effettuando un **miss** se invece non trova i dati necessari e deve accedere a uno strato inferiore.
|
||||
|
||||
- [Cache](https://it.wikipedia.org/wiki/Cache) (piccolissima e velocissima)
|
||||
- [Random Access Memory](https://it.wikipedia.org/wiki/RAM) (piccola e veloce)
|
||||
- [Solid State Drive]() (medio e di media velocità)
|
||||
- [Hard Disk Drive](https://it.wikipedia.org/wiki/Disco_rigido) (grosso, ma lento)
|
||||
- [Tape storage](https://en.wikipedia.org/wiki/Magnetic_tape_data_storage) (enorme, ma lentissimo)
|
||||
|
||||
I _miss_ rallentano l'esecuzione dei programmi, in quanto causano ritardi nel ritrovamento dei dati, passando da _meno di 1 µs_ per le cache a _più di 1 ms_ per gli hard disk.
|
||||
|
||||
Inoltre, esistono due tipi di cache, anch'essi gerarchizzati:
|
||||
|
||||
- [SRAM](https://it.wikipedia.org/wiki/SRAM)
|
||||
- [DRAM](https://it.wikipedia.org/wiki/DRAM)
|
||||
|
|
@ -0,0 +1,41 @@
|
|||
# Dentro il processore
|
||||
|
||||
## Come sono fatti i circuiti integrati?
|
||||
|
||||
Sono composti da un layer di silicio (semiconduttore), più delle maschere di conduttori (µfili metallici), isolanti (plastica e vetro) e transistor.
|
||||
|
||||
### Processo di produzione
|
||||
|
||||
- Lingotto di silicio
|
||||
- Tagliato in _wafer_ da 2mm
|
||||
- Creazione dei _patterned wafer_
|
||||
- Testing dei _patterned wafer_
|
||||
- Taglio i _tested wafers_
|
||||
- Creo un package con i _tested dies_
|
||||
- Testo i _packaged dies_
|
||||
- Spedisco i _tested packaged dies_ ai clienti.
|
||||
|
||||
### Lo yield
|
||||
|
||||
Lo yield è quanti _tested packaged dies_ riesco a produrre da un singolo lingotto di silicio.
|
||||
|
||||
## Come definiamo la performance di un processore?
|
||||
|
||||
Ci sono varie metriche per definirla:
|
||||
|
||||
- **Response time**: tempo impiegato a compiere un'operazione
|
||||
- **Throughput**: operazioni fatte in un'unità di tempo
|
||||
|
||||
### Il clock
|
||||
|
||||
Il clock della CPU è il timer che scandisce le operazioni della CPU.
|
||||
|
||||
Ha, ovviamente, un periodo e una frequenza costanti.
|
||||
|
||||
### Il CPU time
|
||||
|
||||
Il tempo impiegato da una CPU a compiere una determinata operazione è dato da `numero di cicli di clock richiesti * periodo di clock`, ed è detto **CPU time**.
|
||||
|
||||
### Il Cost per instruction (CPI)
|
||||
|
||||
Alcune istruzioni di una CPU potrebbero richiedere più di un ciclo di clock.
|
||||
165
2 - Architettura dei calcolatori/1 - Appunti/03 - Assembly.md
Normal file
165
2 - Architettura dei calcolatori/1 - Appunti/03 - Assembly.md
Normal file
|
|
@ -0,0 +1,165 @@
|
|||
# Assembly
|
||||
|
||||
Useremo il RISC-V.
|
||||
Esso è little-endian, ed è indirizzato a gruppi di 8 bit.
|
||||
|
||||
## Registri
|
||||
|
||||
RISC-V ha a disposizione **32** registri da 64 bit, che vanno da `x0` a `x31`.
|
||||
|
||||
Un dato a 32 bit viene chiamato **word**, uno a 64 bit viene chiamato **doubleword**.
|
||||
|
||||
- `x0`: costante
|
||||
- `x1`: indirizzo risultato
|
||||
- `x2`: indirizzo della cima dello stack
|
||||
- `x3`: indirizzo dell'area di memoria con variabili globali
|
||||
- `x4`: indirizzo dell'area di memoria specifica del thread attivo
|
||||
- `x5`: registro temporaneo
|
||||
- `x6`: registro temporaneo
|
||||
- `x7`: registro temporaneo
|
||||
- `x8`: frame pointer
|
||||
- `x9`: registro salvato, può essere copiato in memoria
|
||||
- `x10`: argomento o risultato delle funzioni
|
||||
- `x11`: argomento o risultato delle funzioni
|
||||
- `x12`: argomento delle funzioni
|
||||
- `x13`: argomento delle funzioni
|
||||
- `x14`: argomento delle funzioni
|
||||
- `x15`: argomento delle funzioni
|
||||
- `x16`: argomento delle funzioni
|
||||
- `x17`: argomento delle funzioni
|
||||
- `x18`: registro salvato, può essere copiato in memoria
|
||||
- `x19`: registro salvato, può essere copiato in memoria
|
||||
- `x20`: registro salvato, può essere copiato in memoria
|
||||
- `x21`: registro salvato, può essere copiato in memoria
|
||||
- `x22`: registro salvato, può essere copiato in memoria
|
||||
- `x23`: registro salvato, può essere copiato in memoria
|
||||
- `x24`: registro salvato, può essere copiato in memoria
|
||||
- `x25`: registro salvato, può essere copiato in memoria
|
||||
- `x26`: registro salvato, può essere copiato in memoria
|
||||
- `x27`: registro salvato, può essere copiato in memoria
|
||||
- `x28`: registro temporaneo
|
||||
- `x29`: registro temporaneo
|
||||
- `x30`: registro temporaneo
|
||||
- `x31`: registro temporaneo
|
||||
|
||||
## Operazioni
|
||||
|
||||
### Operazioni aritmetiche
|
||||
|
||||
Sono sempre formate da tre operandi: registro a cui il risultato verrà assegnato e gli argomenti dell'operazione.
|
||||
|
||||
- `add`: addizione
|
||||
- `sub`: sottrazione
|
||||
- `addi`: addizione di costanti
|
||||
|
||||
#### Esempio
|
||||
|
||||
```assembly
|
||||
add a, b, c
|
||||
```
|
||||
|
||||
##### Equivalente Python
|
||||
|
||||
```python
|
||||
a = b + c
|
||||
```
|
||||
|
||||
### Operazioni di trasferimento dati
|
||||
|
||||
Permettono di caricre / scaricare dati dalla memoria.
|
||||
|
||||
### Operazioni logiche
|
||||
|
||||
Consentono di effettuare operazioni di logica.
|
||||
|
||||
- `and`
|
||||
- `or`
|
||||
- ...
|
||||
|
||||
### Operazioni di shift
|
||||
|
||||
Consentono di spostare i bit di un registro di alcune posizioni, moltiplicando o dividendo effettivamente per potenze di 2.
|
||||
|
||||
### Operazioni condizionali
|
||||
|
||||
Consentono di saltare ad un'altra serie di istruzioni se certe condizioni si verificano.
|
||||
|
||||
- `blt`: minore di, signed
|
||||
- `bge`: maggiore di, signed
|
||||
- `bltu`: minore di, unsigned
|
||||
- `bgeu`: maggiore di, unsigned
|
||||
|
||||
### Operazioni non-condizionali
|
||||
|
||||
Consentono di saltare ad un'altra serie di istruzioni in qualunque caso.
|
||||
|
||||
#### Chiamare una procedura
|
||||
|
||||
> `jal x1, ProcedureLabel`
|
||||
|
||||
Salva l'indirizzo dell'istruzione successiva in x1, poi salta a ProcedureLabel.
|
||||
|
||||
#### Ritornare da una procedura
|
||||
|
||||
> `jalr x0, 0(x1)`
|
||||
|
||||
Ritorna all'indirizzo puntato da `x1`.
|
||||
|
||||
## Memoria
|
||||
|
||||
Per accedere a una posizione in memoria, si usa `offset(indirizzo)`.
|
||||
|
||||
##### Esempio
|
||||
|
||||
`64(x22)` accede al 64° byte dopo la posizione di memoria archiviata in `x22`.
|
||||
|
||||
## Segni
|
||||
|
||||
E' possibile usare rappresentazione standard o a complemento-a-2.
|
||||
|
||||
Possiamo usare la **sign extension** quando abbiamo un dato che vogliamo portare a un numero di bit maggiore di quello che è.
|
||||
|
||||
##### Esempio
|
||||
|
||||
```
|
||||
[0]101 0101 --> 0000 0000 [0]101 0101
|
||||
[1]100 0000 --> 1111 1111 [1]100 0000
|
||||
```
|
||||
|
||||
### Operazioni di sincronizzazione
|
||||
|
||||
- `lr`: load reserved
|
||||
- `sc`: store conditional
|
||||
|
||||
#### Load reserved
|
||||
|
||||
```
|
||||
lr rd, (rs1)
|
||||
```
|
||||
|
||||
> Non ho la minima idea di come funzioni.
|
||||
|
||||
Controlla se `rs1` è bloccato; se sì, mette un valore != 0 in `rd`...?
|
||||
|
||||
> Forse... crea un lock in `rd`?
|
||||
|
||||
#### Store conditional
|
||||
|
||||
```
|
||||
sc rd, rs2, (rs1)
|
||||
```
|
||||
|
||||
> Non ho la minima idea di come funzioni.
|
||||
|
||||
Copia il dato da `rs2` a `rs1`, se non è bloccato, e metti `x0` in `rd`...?
|
||||
|
||||
> Carica un dato... se ho ancora il lock, altrimenti, metti `x0` in `rd`.
|
||||
|
||||
#### Unlock
|
||||
|
||||
```
|
||||
sd x0, 0(x20)
|
||||
```
|
||||
|
||||
## Operazioni floating point
|
||||
|
||||
|
|
@ -0,0 +1,29 @@
|
|||
# Definisci delle costanti
|
||||
.equ _SYS_EXIT, 93 # Syscall exit
|
||||
.equ _SYS_WRITE, 64 # Syscall write
|
||||
|
||||
# Inizio del programma
|
||||
.global _start
|
||||
|
||||
# Variabili statichie inizializzate a 0
|
||||
.section .bss
|
||||
|
||||
# Dati modificabili
|
||||
.section .data
|
||||
|
||||
# Dati in sola lettura
|
||||
.section .rodata
|
||||
msg: .string "Hello mondo!\n"
|
||||
|
||||
# Testo del programma
|
||||
.section .text
|
||||
_start:
|
||||
# Chiamata a WRITE(stream, primocarattere, lunghezza)
|
||||
li a0, 0 # Print to stdout
|
||||
la a1, msg # Stampa il messaggio in msg
|
||||
li a2, 13 # Stampa 13 caratteri dopo msg
|
||||
li a7, _SYS_WRITE # Seleziona la syscall WRITE
|
||||
ecall
|
||||
|
||||
li a7, _SYS_EXIT
|
||||
ecall
|
||||
|
|
@ -0,0 +1,33 @@
|
|||
# Che bello! Adoro l'assembly!
|
||||
# Questo programma funziona, è verificato!
|
||||
.global _start
|
||||
|
||||
# La sezione .data contiene i dati del programma
|
||||
.section .data
|
||||
|
||||
# Creo una variabile con etichetta "ciao"
|
||||
ciao: .string "0\n\0"
|
||||
|
||||
# La sezione .rodata contiene i dati del programma in sola lettura
|
||||
.section .rodata
|
||||
|
||||
# La sezione .text contiene il testo del programma
|
||||
.section .text
|
||||
|
||||
# Creo una label _start che funzionerà da entrypoint
|
||||
_start:
|
||||
li t1, 10 # Voglio ripetere il ciclo 10 volte
|
||||
li a7, 64 # PRINT(stream, indirizzo, numerobytes) è la syscall 64
|
||||
li a0, 0 # stream è il primo argomento: vogliamo scrivere su stdout (0)
|
||||
la a1, ciao # indirizzo è il secondo argomento: partiamo dall'etichetta ciao
|
||||
li a2, 2 # numerobytes è il terzo argomento: vogliamo stampare 2 bytes
|
||||
print:
|
||||
ecall # PRINT(a0, a1, a2)
|
||||
lbu t0, 0(a1) # Carica il byte con il 0
|
||||
addi t0, t0, 1 # Aggiungici 1
|
||||
sb t0, 0(a1) # Ricaricalo in memoria
|
||||
addi t1, t1, -1 # Togli 1 dal numero di cicli rimasti
|
||||
bne t1, zero, print # Se rimangono dei cicli, torna indietro e falli!
|
||||
end:
|
||||
li a7, 93 # Tutti i programmi terminano chiamando la syscall 93, EXIT()
|
||||
ecall # EXIT()
|
||||
|
|
@ -0,0 +1,40 @@
|
|||
# Che bello! Adoro l'assembly!
|
||||
# Funziona!
|
||||
.global _start
|
||||
|
||||
# La sezione .data contiene i dati del programma
|
||||
.section .data
|
||||
|
||||
# La sezione .rodata contiene i dati del programma in sola lettura
|
||||
.section .rodata
|
||||
|
||||
# La sezione .text contiene il testo del programma
|
||||
.section .text
|
||||
|
||||
# Creo una label _start che funzionerà da entrypoint
|
||||
_start:
|
||||
li s0, 5 # Scrivi il numero 5
|
||||
li s3, 3 # COSTANTE: 3
|
||||
|
||||
# Pushing phase
|
||||
pushing:
|
||||
sb s0, 0(sp) # Metti nello stack s0
|
||||
addi sp, sp, 1 # Aumenta di 1 lo stack pointer
|
||||
addi s2, s2, 1 # Aumenta di 1 la dimensione dello stack
|
||||
addi s0, s0, -1 # Diminuisci di 1 il numero da fattorializzare
|
||||
bgeu s0, s3, pushing # Continua a pushare finchè non arrivi a 2
|
||||
li s1, 2
|
||||
|
||||
# Popping phase
|
||||
popping:
|
||||
addi sp, sp, -1 # Diminuisci di 1 lo stack pointer
|
||||
# Attenzione: diminuisco lo stack pointer PRIMA di caricare dallo stack, altrimenti caricarei il nulla
|
||||
lb s0, 0(sp) # Prendi dallo stack il prossimo numero
|
||||
addi s2, s2, -1 # Diminuisci di 1 la dimensione dello stack
|
||||
mul s1, s1, s0 # Effettua la moltiplicazione
|
||||
bne s2, zero, popping # Se ci sono altri valori nello stack, continua a moltiplicare
|
||||
|
||||
# Ending phase
|
||||
ending:
|
||||
li a7, 93
|
||||
ecall
|
||||
|
|
@ -0,0 +1,48 @@
|
|||
# Che bello! Adoro l'assembly!
|
||||
# Ommioddiofunzionawowimawizard
|
||||
.global _start
|
||||
|
||||
# La sezione .data contiene i dati del programma
|
||||
.section .data
|
||||
|
||||
primo: .word 1, 2, 3, 4, 5
|
||||
secondo: .word 1, 2, 3, 4, 5
|
||||
|
||||
# La sezione .rodata contiene i dati del programma in sola lettura
|
||||
.section .rodata
|
||||
|
||||
# La sezione .text contiene il testo del programma
|
||||
.section .text
|
||||
|
||||
# s0: primo[s0]
|
||||
# s1: secondo[s0]
|
||||
# s2: monomio
|
||||
# s3: indirizzo da cui prendere il valore
|
||||
# s4: indice
|
||||
# s5: dimensione array
|
||||
# a0: somma
|
||||
|
||||
_start:
|
||||
li s2, 0
|
||||
li a0, 0
|
||||
li s4, 0
|
||||
li s5, 5
|
||||
|
||||
somma:
|
||||
la s3, primo
|
||||
add s3, s3, s4
|
||||
lw s0, 0(s3)
|
||||
|
||||
la s3, secondo
|
||||
add s3, s3, s4
|
||||
lw s1, 0(s3)
|
||||
|
||||
mulw s2, s1, s0
|
||||
add a0, a0, s2
|
||||
addi s4, s4, 4
|
||||
addi s5, s5, -1
|
||||
bne zero, s5, somma
|
||||
|
||||
_end:
|
||||
li a7, 93
|
||||
ecall
|
||||
|
|
@ -0,0 +1,57 @@
|
|||
# Appunti
|
||||
|
||||
## Registri
|
||||
|
||||
I registri sono divisi in tre tipi: di **proprietà del chiamante**, di **proprietà del chiamato** (anche se in realtà è solo una convenzione) e... gli **altri**.
|
||||
|
||||
Tutti i registri sono grandi 64 bit: possono quindi contenere una _doubleword_.
|
||||
|
||||
### Proprietà del chiamante
|
||||
|
||||
Questi registri **non devono essere sovrascritti** quando viene chiamata una funzione, o se vengono sovrascritti, **devono essere ripristinati** prima che la funzione restituisca.
|
||||
|
||||
Essi sono:
|
||||
- `s1..s11`: **Saved** registers, registri generici che possono essere usati per qualsiasi cosa.
|
||||
- `sp`: **Stack Pointer**, il primo indirizzo dello stack disponibile per la scrittura. Va _decrementato_ quando si aggiunge qualcosa allo stack.
|
||||
- `fp`: **Frame Pointer**, punta all'inizio dello stack.
|
||||
|
||||
### Proprietà del chiamato
|
||||
|
||||
Questi registri **possono essere sovrascritti** quando viene chiamata una funzione: bisogna salvarli in memoria prima di chiamarla!
|
||||
|
||||
Essi sono:
|
||||
- `t0..t6`: **Temporary** registers, registri generici che possono essere usati per qualsiasi cosa.
|
||||
- `ra`: **Return Address**, l'indirizzo a cui continuare l'esecuzione del programma dopo aver terminato una funzione. _Solitamente si usa solo con `jal` e `jalr`!_
|
||||
- `a0..a7`: Function **Arguments**. Se all'interno di una funzione, contengono gli argomenti che sono stati passati. Se all'esterno di una funzione, contengono i valori restituiti dall'ultima funzione chiamata.
|
||||
|
||||
### Altri
|
||||
|
||||
- `zero`: **Zero**, registro che vale sempre 0, anche dopo essere stato sovrascritto da altro. Come `/dev/null` su Linux.
|
||||
- `gp`: **Global Pointer**, punta a un indirizzo _[(?)](https://groups.google.com/a/groups.riscv.org/forum/#!topic/sw-dev/60IdaZj27dY)_
|
||||
- `tp`: **Thread Pointer**, punta al thread-local storage _[(?)](https://groups.google.com/a/groups.riscv.org/d/msg/sw-dev/cov47bNy5gY/zLnlKkw9CQAJ)_
|
||||
- `pc`: **Program Counter**, punta all'istruzione che sta venendo eseguita.
|
||||
|
||||
## Comandi preprocessore
|
||||
|
||||
Scrivendo file assembly per RISC-V, è possibile aggiungere direttive per il preprocessore.
|
||||
|
||||
Per ora ho scoperto queste:
|
||||
|
||||
- `.global INDIRIZZO`: definisce l'indirizzo a cui inizia il programma. _(Forse setta il `gp` a quell'indirizzo?)_
|
||||
- `.equ NOME, VALORE`: definisce una costante con uno specifico nome. _Il nome delle costanti dovrebbe iniziare sempre con un underscore per convenzione._
|
||||
- `.section [.data|.rodata|.bss|.text]`: marca l'inizio di una specifica sezione del programma. Le sezioni sono:
|
||||
- `.data`: Variabili del programma
|
||||
- `.rodata`: Variabili sola lettura del programma
|
||||
- `[.bss](https://en.wikipedia.org/wiki/.bss)`: Variabili statiche non costanti non inizializzate a nessun valore. _A volte, vengono inizializzate a 0. Solo a volte. Dipende dall'OS._
|
||||
- `.text`: Il testo del programma, con le istruzioni in assembly.
|
||||
- `.TIPOVARIABILE`: crea una variabile di quel tipo e la inizializza a qualcosa.
|
||||
|
||||
# Link utili
|
||||
|
||||
- [algo.ing.unimo.it](http://algo.ing.unimo.it/people/andrea/Didattica/Architetture/index.html)
|
||||
- [wikichip.org](https://en.wikichip.org/wiki/risc-v)
|
||||
- [en.wikiversity.org](https://en.wikiversity.org/wiki/Computer_architecture)
|
||||
- [it.wikiversity.org](https://it.wikiversity.org/wiki/Materia:Architetture_degli_elaboratori)
|
||||
- [stackoverflow.com](https://stackoverflow.com/questions/tagged/riscv)
|
||||
- [softwareengineering.stackexchange.com](https://softwareengineering.stackexchange.com/questions/tagged/assembly)
|
||||
- [rv8.io](https://rv8.io/isa.html)
|
||||
133
2 - Architettura dei calcolatori/1 - Appunti/09 - Memorie.md
Normal file
133
2 - Architettura dei calcolatori/1 - Appunti/09 - Memorie.md
Normal file
|
|
@ -0,0 +1,133 @@
|
|||
# Memorie
|
||||
|
||||
La _memoria_ di un calcolatore solitamente è composta da molteplici strati, realizzati per velocizzare gli accessi.
|
||||
|
||||
Ogni strato offre lettura più veloce, ma è più costoso da realizzare e ha consumi più alti.
|
||||
|
||||
In ordine di velocità, sono:
|
||||
|
||||
- Registers
|
||||
- Cache L1
|
||||
- Cache L2
|
||||
- Cache L`X`
|
||||
- Random Access Memory
|
||||
- Solid State Drive
|
||||
- Hard Disk Drive
|
||||
|
||||
## Cache
|
||||
|
||||
### Cache L1
|
||||
|
||||
Piccola, ma miss penalty bassa
|
||||
|
||||
### Cache L2
|
||||
|
||||
Molto grande, ma miss penalty alta
|
||||
|
||||
### Direct mapping
|
||||
|
||||
Una cache _direct mapped_ associa a ogni indirizzo di RAM un **indice** uguale agli **N bit meno significativi** dell'indirizzo dell'inferiore, e un **tag** uguale agli **N bit più significativi**.
|
||||
|
||||
Se durante un accesso _il tag di un blocco è diverso dal tag dell'indirizzo a cui vogliamo accedere_, si ha un cache miss.
|
||||
|
||||
> Il dato di cui abbiamo bisogno è contenuto nell'indirizzo `0x0ABC` della RAM.
|
||||
> Il suo indice sarà `0xBC`, e il suo tag sarà `0x0A`.
|
||||
> Essendo la cache vuota all'inizio, viene immediatamente caricato.
|
||||
>
|
||||
> Voglio poi accedere all'indirizzo `0x0BBC` della RAM.
|
||||
> Controlliamo il blocco con indice `0xBC`: il suo tag è `0x0A`, ma noi stiamo cercando `0x0B`! Si ha quindi un cache miss, e devo andare a prendere dalla memoria il dato che sto cercando e scriverlo sulla RAM.
|
||||
|
||||
Inoltre, in ogni blocco di memoria della cache è presente **un bit di validità**, che rappresenta se il dato in cache è stato inizializzato o no: parte da `0` e viene impostato a `1` quando viene caricato dalla RAM un dato nel relativo blocco.
|
||||
|
||||
> Un esempio potrebbe essere un processore con blocchi di memoria da 32 bit e indirizzi a 64 bit: la cache, contenente 1024 blocchi di memoria, avrà index a 12 bit, e di conseguenza il tag sarà grande 52 bit.
|
||||
|
||||
#### Dimensione blocchi
|
||||
|
||||
Fare blocchi grandi o fare blocchi piccoli ha significative differenze sulla velocità della cache:
|
||||
|
||||
Avere blocchi più grandi significa che ci saranno meno blocchi in tutta la cache, quindi:
|
||||
|
||||
```diff
|
||||
+ Riduce il miss rate per il principio di località spaziale
|
||||
- Avendo una quantità minore di blocchi, aumenta la possibilità di conflitto
|
||||
- La miss penalty è più alta
|
||||
# La miss penalty è compensabile con tecniche come early restart o critical-word-first
|
||||
```
|
||||
|
||||
Con blocchi più piccoli, invece
|
||||
```diff
|
||||
+ Miss penalty minore
|
||||
+ Più blocchi significa meno conflitti
|
||||
- E' possibile che abbia bisogno di fare più di una richiesta alla cache, rallentandola significativamente
|
||||
```
|
||||
|
||||
#### Scrittura tramite cache
|
||||
|
||||
Quando scrivo in memoria un dato presente nella cache, l'informazione presente nella cache diventa errata.
|
||||
|
||||
Si può risolvere questo problema con una politica di riscrittura:
|
||||
- Write-through
|
||||
- Write-back
|
||||
|
||||
##### Write-through
|
||||
|
||||
_Quando **viene scritto** su dato in cache_, aggiorna tutte le memorie che lo contengono.
|
||||
|
||||
```diff
|
||||
+ Non necessita di ulteriore memoria di cache
|
||||
+ Caricare dati è veloce
|
||||
+ Se si verifica un write miss non ha per forza bisogno di portare in cache il dato da scrivere
|
||||
- I write richiedono molto più tempo, soprattutto se ripetuti
|
||||
```
|
||||
|
||||
|
||||
##### Write-back
|
||||
|
||||
Scrivi la modifica di dato solo nella cache, e _marca il blocco come **dirty**_.
|
||||
|
||||
Quando un blocco dirty viene **sovrascritto**, aggiorna le memorie che lo contengono.
|
||||
|
||||
```diff
|
||||
+ I write richiedono poco tempo, anche se ripetuti
|
||||
- Caricare dati dalla RAM è più lento
|
||||
- Necessita di memoria da dedicare al dirty bit
|
||||
- Devo fetchare obbligatoriamente i dati da sovrascrivere
|
||||
```
|
||||
|
||||
##### Miglioramenti alle policy
|
||||
|
||||
E' possibile utilizzare un **write buffer** invece che fare attendere il tempo di scrittura alla CPU. I dati saranno scritti successivamente, ma prima che questi vengano utilizzati.
|
||||
|
||||
```diff
|
||||
+ Il processore non ha bisogno di fermarsi per le write
|
||||
- Il buffer potrebbe riempirsi, neganode i vantaggi
|
||||
- Il buffer utilizza memoria che forse sarebbe stata più utile come cache
|
||||
```
|
||||
|
||||
### Fully associative
|
||||
|
||||
Ogni dato può essere messo in qualunque indirizzo della cache.
|
||||
|
||||
Richiede che l'indirizzo di origine venga salvato assieme al dato, e tanti comparatori.
|
||||
|
||||
### Set associative
|
||||
|
||||
Divido tutti i blocchi di cache in vie.
|
||||
|
||||
Ogni via può contenere `n` dati.
|
||||
|
||||
Un set è l'insieme dei dati che hanno lo stesso index ma sono in vie diverse.
|
||||
|
||||
Ogni dato può essere messo in qualunque indirizzo del set a cui appartiene.
|
||||
|
||||
Identifico il numero di set di appartenenza facendo `indirizzo % numerodiset`.
|
||||
|
||||
Una cache `1`-way Set Associative è una cache Direct Mapped, mentre una cache `numeroentries`-way Set Associative è una cache Fully Associative.
|
||||
|
||||
Quando non c'è spazio in un set, rimpiazzo un dato secondo la politica **Least Recently Used**, rimuovendo il dato usato meno recentemente. Posso usare anche la politica **Random**, se ho un'alta associatività.
|
||||
|
||||
#### Performance
|
||||
|
||||
Più una cache è associativa, più il miss rate sarà ridotto, ma l'associatività richiede un maggior numero di comparatori e potenzialmente più ritardi nella restituzione del dato.
|
||||
|
||||
Inoltre, la percentuale di miss non diminuisce linearmente con il numero di vie: dopo un certo numero di vie, i guadagni sono molto ridotti.
|
||||
|
|
@ -0,0 +1,21 @@
|
|||
# Meltdown
|
||||
|
||||
Esempio circa comprensibile:
|
||||
|
||||
```c++
|
||||
int meltdown() {
|
||||
bool array[2] = {false, true};
|
||||
|
||||
if( qualcosa_che_restituisce_false() ) {
|
||||
//Questo viene predetto
|
||||
//Durante le predizioni non ci sono segfault!
|
||||
int protetto = *(indirizzo_bersaglio);
|
||||
//Se il primo bit di protetto è 1, verrà caricato "true" in cache, altrimenti, verrà caricato "false", ANCHE SE E' SOLO UNA PREDIZIONE!
|
||||
//Dopo essere stato caricato, NON VIENE RIMOSSO, anche se la predizione è sbagliata.
|
||||
int caricato = array[protetto & 1];
|
||||
}
|
||||
|
||||
if( in_cache(true) ) cout << "Il primo bit del bersaglio è 1.\n";
|
||||
else cout << "Il primo bit del bersaglio è 0.\n";
|
||||
}
|
||||
```
|
||||
Loading…
Reference in a new issue