Laboratorio di Architettura degli Elaboratori

Transcript

1 Laboratorio di Architettura degli Elaboratori Dott. Massimo Tivoli Set di istruzioni del MIPS32: istruzioni aritmetiche e di trasferimento

2 Istruzioni (Alcune) Categorie di istruzioni in MIPS Istruzioni aritmetico/logiche Queste istruzioni effettuano operazioni aritmeticologiche sui registri del processore Istruzioni Load and Store Queste istruzioni spostano dati fra la memoria e i registri generali del processore Istruzioni decisionali Queste istruzioni effettuano il confronto fra i valori contenuti nei registri

3 Istruzioni Aritmetiche add a, b, c # a = b + c sub a, b, c # a = b - c TRE operandi NOTE: OPERATORE operando1, operando2, operando3 Ciascuna linea puo contenere solo una istruzione; # viene usato per commenti add a, b, c # Questa istruzione esegue la somma a=b+c

4 Istruzioni Aritmetiche Note: Tutte le istruzioni aritmetiche hannoesattamente tre operandi (numero fisso) per mantenere l Hw semplice L hardware necessario per un numero variabile di operandi è più complesso di quello richiesto per un numero fisso di operandi PRINCIPIO DI PROGETTO 1: semplicita e regolarita sono strettamente correlate Ordine fissato (destinatario per primo) OPERATORE operando1, operando2, operando3 operando1 = operando2 OPERATORE operando3

5 * Esercizio Scrivere la seguente istruzione in assembler MIPS: a = (b+c) (d f) + g add x, b, c sub y, d, f sub x, x, y add a, x, g Quante operazioni aritmetiche ci vogliono per sommare/sottrarre/etc. n numeri?

6 Registri (continua ) Data una istruzione aritmetica: Operandi = Registri MIPS32 ha 32 registri, di uso generale, a 32 bit Variabili Registro: Variabili in un LP alto livello sono infinite I registri nell Hw sono finiti In un LP alto livello le variabili posso far riferimento sia a registri che a locazioni di memoria che non sono registri (in modo trasparente al programmatore) Un numero di registri elevato aumenterebbe la durata del ciclo di clock i segnali elettrici devono coprire una distanza maggiore Maggiore è il numero dei registri e maggiore è il numero di bit necessari per indirizzarli all interno di una istruzione ricordate sempre che per la macchina add x, b, c = PRINCIPIO DI PROGETTO 2: Minori sono le dimensioni, maggiore e la velocita

7 Registri e loro uso Notazione per l assembler del MIPS32 nome costituito da due caratteri preceduti dal carattere $ $s0, $s1, per i registri che corrispondono a variabili nei programmi scritti in un LP alto livello da compilare in linguaggio assembly per MIPS32 $t0, $t1, per i registri temporanei necessari alla compilazione di programmi in istruzioni MIPS32 a = (b+c) (d f) + g add $t0, $s0, $s1 sub $t1, $s2, $s3 sub $t0, $t0, $t1 add $s5, $t0, $s4 # il reg. temp. $t0 contiene il ris. di b+c (i.e., $s0+$s1) # il reg. temp. $t1 contiene il ris. di d f (i.e., $s2 $s3) # il reg. temp. $t0 contiene il ris. di (b+c) (d f) # il reg. $s5 contiene il ris. di (b+c) (d f) + g

8 (parte della) Architettura del MIPS32 MAR Abbiamo solo 32 registri come facciamo a gestire strutture dati complesse (es. vettori)??? oppure cosa facciamo se 32 var. non mi bastano??? Memoria MBR MEMORIA R1 R2 Rn ALU R1 32 Registri, ognuno a 32 bit R32 32 bit CONTROLLO 32 registri CPU

9 Istruzioni di Trasferimento lw $s1, 10($s2) # caricain $s1 l undicesimo valore del vettore che inizia alla # locazione, in memoria, il cui indirizzo è il valore di $s2 lw = Load word (si ricordi che 1 word = 32 bit per il MIPS32) sw $s1, 100($s2) sw = Store word NOTE e delucidazioni: Memoria vista come un VETTORE Le istruzioni aritmetiche richiedono che gli operandi siano memorizzati nei registri Istruzioni di Trasferimento Indirizzo di base (e.g., $2,$3) + offset (e.g., 10,100) Memoria indirizzata a singolo byte (vedi slides succ.)

10 Attenzione La memoria è indirizzata al singolo byte la mem. è vista come una sequenza lineare di celle (o locazioni) da 8 bit = 1 byte (da 0x a 0xFFFFFFFF, fino a 4GB di mem. indirizzabili) mentre I registri sono indirizzati a 32 bit e un registro contiene un dato a 32 bit (= 4 byte = 4 locazioni) => l indirizzo di una word, semanticamente valida, in memoria è sempre l indirizzo, di una locazione, che è multiplo di 4 Vogliamo caricare il 3 elemento del vettore A: ovvero vogliamo prelevare il valore di A[2] (iniziamo a numerare gli elementi di un vettore da 0, cioè A[0] è il primo elemento del vettore) Cosa vuol dire?? Word i+3 Word i+2 Word i+1 Word i MEM 1 byte (8 bit) 0x F 0x E 0x D 0x C 0x B 0x A 0x x x x x x x x x x

11 Attenzione Vogliamo caricare il 3 elemento (ovvero la 3 word) del vettore A: ovverovogliamoprelevareilvaloredia[2] dove A è memorizzato a partire dalla locazione 0x supponiamo che $s2 contenga proprio il numero 0x A lw $s1, 2($s2) lw $s1, 8($s2) Indirizzo di base (a 32 bit) + offset (a 16 bit) Big end e Little end Word i Che succede quando il numero di variabili nel LP alto livello supera il numero di registri? Spilling dei registri Word i+3 Word i+2 Word i+1 MEM perchè 16 bit sarà chiaro più avanti nel corso A[2] 1 byte (8 bit) 0x F 0x E 0x D 0x C 0x B 0x A 0x x x x x x x x x x

12 Little Endian e Big Endian (continua ) Come viene rappresentata una word del MIPS32 (quindi un numero a 32 bit) in 4 byte di memoria? = 0x Esistono due schemi: Little Endian: memorizza a partire dalla "little end" (ovvero a partire dai bit meno significativi) della word cioe, registro: 0x12 byte 3 0x34 byte 2 0x56 byte 1 0x78 byte 0 Big Endian: memorizza a partire dalla "big end" (ovvero dai bit più significativi) della word cioe, registro: 0x78 0x56 0x34 0x12 MIPS lavora in Big Endian byte 3 byte 2 byte 1 byte 0 Infatti, l indirizzo di base 0x , in memoria, viene specificato tramite il contenuto di un registro a 32 bit, $s2 nell esempio precedente, che contiene proprio il numero 0x che però è memorizzato come byte3: 00 byte2: 00 byte1: 00 byte0: 10

13 Little Endian e Big Endian Nell esempio precedente avevamo: indirizzo di base + offset ovvero: 8($s2) = $s2 + 8 = 0x x0008 = 0x x = 0x ovvero (in formato Big Endian): $s2: 0x00 0x00 0x00 0x10 + 8: 0x08 0x00 0x00 0x00 = byte 3 byte 2 byte 1 byte 0 byte 3 byte 2 byte 1 byte 0 0x08 0x00 0x00 0x10 byte 3 byte 2 byte 1 byte 0

14 Spilling In memoria si mettono le variabili meno usate Ricorda: gli operandi aritmetici sono registri, non celle di memoria tempo accesso ai registri e minore 1 ciclo di clock: lettura due registri, esecuzione operazione scrittura risultato

15 * Organizzazione della memoria Global pointer offset a 16bit (4 cifre hex) permette di prelevare dati con un sola lw (0x = 0x8020($gp)) Dati statici Static Data Text Codice del programma ( text )

16 Esempio Scrivere in assembly la seguente assegnazione A[14] = b + A[6] con b $s1, base(a) $s0 lw $t0, 24($s0) add $t0, $s1, $t0 sw $t0, 56($s0)

17 Consideriamo Vettori con indici variabili $s1 $s4 ricordate che a = b + A[i] Informalmente: Carica A[2] = lw $t0, 8($s3) Carica A[i] = 4*$s4 + $s3 = $s4+$s4+$s4+$s4+$s3 b+a[i] = $s2+$s4+$s4+$s4+$s4+$s3 Formalmente: add $t1, $s4, $s4 add $t1, $t1, $t1 add $t1, $t1, $s3 lw $t0, 0($t1) add $s1, $s2, $t0 $s2 $s3 per esprimere l offset si hanno a disposizione solo 16 bit

18 Esercizio Scrivere in assembly la seguente istruzione: A[4] = b + A[i] Base A $s1 b $s2 i $s3 Scrivere in pseudo C il seguente codice Assembly: add $t1, $s2, $s2 add $t1, $t1, $t1 add $t1, $t1, $s1 lw $t0, 0($t1) lw $t1, 16($s1) add $t1, $t1, $t0 sw $t1, 12($s1)

19 Esercizio Cominceremo la prossima lezione realizzando insieme (voi!) gli esercizi precedenti