Calcolatori Elettronici (Biasi - Narracci - Albano)
-
Upload
vittorio-troise -
Category
Documents
-
view
275 -
download
3
Transcript of Calcolatori Elettronici (Biasi - Narracci - Albano)
-
7/23/2019 Calcolatori Elettronici (Biasi - Narracci - Albano)
1/216
-
7/23/2019 Calcolatori Elettronici (Biasi - Narracci - Albano)
2/216
i
Autori:
Albano Teodoro, Luigi Biasi, Giuseppe Narracci
Titolo Originale:
Calcolatori Elettronici, 1a edizione 2012
opyrightC 2012Tutti i diritti sono riservati a norma di legge e a norma delle convenzioni
internazionali. Nessuna parte di questo libro pu essere riprodotta consistemi elettronici, meccanici o altri, senza lautorizzazione degli autori.
-
7/23/2019 Calcolatori Elettronici (Biasi - Narracci - Albano)
3/216
ii
Nessun calcolatore 9000 ha mai commesso un errore o alterato uninformazione.
Noi siamo, senza possibili eccezioni di sorta, a prova di errore, e incapaci
di sbagliare. (CALCOLATORE HAL 9000)
2001: Odissea nello spazio
-
7/23/2019 Calcolatori Elettronici (Biasi - Narracci - Albano)
4/216
iii
-
7/23/2019 Calcolatori Elettronici (Biasi - Narracci - Albano)
5/216
iv
Sommario
CAPITOLO 1
LA VALUTAZIONE DELLE PRESTAZIONI DI UN PROCESSORE .............................................................................. 1
1. Filosofia Risc E Cisc................................................................................................................................ 2
2. La Legge Di Amdahl............................................................................................................................... 3
CAPITOLO 2
CARATTERISTICHE DELLE ISTRUZIONI DI UN CALCOLATORE ............................................................................. 7
1. Ciclo Istruzione...................................................................................................................................... 7
2. Categorie Di Formati Istruzione............................................................................................................ 8
3. Struttura Dell'istruzione....................................................................................................................... 8
CAPITOLO 3
CLASSIFICAZIONE DEI PROCESSORI ................................................................................................................... 9
1. Classificazione per istruzione............................................................................................................... 9
2. Classificazione per parola..................................................................................................................... 9
3. Classificazione per la gestione della memoria interna...................................................................... 10
4. Classificazione per modi di indirizzamento........................................................................................ 16
CAPITOLO 4
MODI DI INDIRIZZAMENTO ............................................................................................................................. 17
1. Indirizzamento Diretto........................................................................................................................ 172. Indirizzamento con Immediato.......................................................................................................... 17
3. Indirizzamento con Scostamento (displaycement)........................................................................... 18
4. Indirizzamento con registro auto-incrementato o auto-decrementato........................................... 19
5. Indirizzamento per le operazioni di salto........................................................................................... 22
6. Operazioni Nellinsieme Di Istruzioni................................................................................................. 26
CAPITOLO 5
ISTRUZIONI DEL PROCESSORE MIPS ................................................................................................................ 29
1. Istruzioni di tipo J................................................................................................................................ 29
2. Istruzioni di tipo R............................................................................................................................... 30
3. Istruzioni di tipo I................................................................................................................................ 30
4. Le istruzioni del calcolatore MIPS...................................................................................................... 31
4.1. Istruzioni di trasferimento dati.................................................................................................. 31
4.2. Istruzioni per operazioni logico-aritmetiche.............................................................................. 33
4.3. Istruzioni di controllo.................................................................................................................. 36
Esercizi ......................................................................................................................................................... 39
-
7/23/2019 Calcolatori Elettronici (Biasi - Narracci - Albano)
6/216
v
CAPITOLO 6
ARCHITETTURA CALCOLATORE PER LE OPERAZIONI CON DATI INTERI ........................................................... 41
1. Fasi Di Una Istruzione......................................................................................................................... 41
2. Architettura Calcolatore Per La Gestione Di Dati Interi.................................................................... 42
2.1. Istruzione Di Tipo R..................................................................................................................... 45
2.2. Istruzione di tipo I....................................................................................................................... 45
3. Meccanismo Di Funzionamento Interno Dell'ALU:............................................................................ 50
CAPITOLO 7
LA PIPELINE ...................................................................................................................................................... 53
1. Introduzione alla Pipeline................................................................................................................... 53
2. Architettura Pipeline........................................................................................................................... 57
2.1. La Tipica Vita Di Unistruzione In Pipeline.............................................................................. 60
3. Microcodice o Microistruzioni............................................................................................................ 61
3.1. IF (ISTRUCTION FETCH)............................................................................................................... 62
3.2. ID (ISTRUCTION DECODE)........................................................................................................... 63
3.3. EX (EXECUTE)............................................................................................................................... 64
3.4. MEM............................................................................................................................................ 65
3.5. WB............................................................................................................................................... 65
CAPITOLO 8
PRESTAZIONI PROCESSORE PIPELINE .............................................................................................................. 67
1. Miglioramento prestazioni: super pipeline........................................................................................ 67
2. Miglioramento prestazioni: parallelismo........................................................................................... 68
CAPITOLO 9
CONFLITTI NELLA PIPELINE .............................................................................................................................. 71
1. Conflitti di Dato................................................................................................................................... 72
2. Conflitti sulle Diramazioni.................................................................................................................. 79
Esercizi ......................................................................................................................................................... 87
CAPITOLO 10
IL COSTO DI UN CIRCUITO INTEGRATO ........................................................................................................... 95
1. La progettazione................................................................................................................................. 95
2. La produzione...................................................................................................................................... 96
CAPITOLO 11
IL PROCESSORE FLOATING POINT
1. Operazioni Floating Point................................................................................................................... 99
-
7/23/2019 Calcolatori Elettronici (Biasi - Narracci - Albano)
7/216
vi
1.1. Addizione................................................................................................................................... 100
1.2. Moltiplicazione.......................................................................................................................... 101
2. Architettura Processore Floating Point............................................................................................ 101
CAPITOLO 12
GERARCHIA DI MEMORIA .............................................................................................................................. 109
1. Panoramica sulle memorie............................................................................................................... 109
2. Principi generali................................................................................................................................ 111
CAPITOLO 13
MEMORIA CACHE
1. Cenni storici sulle memorie cache.................................................................................................... 115
2. Strategie di allocazione dei blocchi.................................................................................................. 115
2.1. Memoria Completamente Associativa..................................................................................... 116
2.2. Indirizzamento Diretto.............................................................................................................. 116
2.3. Set Associativa.......................................................................................................................... 116
3. Strategia di ricerca e identificazione del blocco.............................................................................. 116
4. Sostituzione di un blocco.................................................................................................................. 117
5. Scrittura e lettura di un blocco......................................................................................................... 118
CAPITOLO 14
PRESTAZIONI DELLA CACHE ........................................................................................................................... 123
1. Analisi delle prestazioni della cache................................................................................................ 123
2. Cache dal punto di vista tecnologico................................................................................................ 125
2.1. Memoria statica SRAM............................................................................................................. 125
2.2. Memoria dinamica DRAM........................................................................................................ 125
3. Dimensionamento della memoria dal punto di vista del tempo.................................................... 125
CAPITOLO 15
STRUTTURA ELETTRONICA DELLA CACHE ...................................................................................................... 127
1. Analisi elettronica della cache.......................................................................................................... 128
2. Struttura delle memorie................................................................................................................... 132
Esercizi ....................................................................................................................................................... 133
CAPITOLO 16
DIVERSE ARCHITETTURE DI MEMORIE .......................................................................................................... 135
1. Aumentare la banda aumentando i dati letti o scritti: banchi paralleli......................................... 136
2. Aumentare la banda diminuendo il tempo: banchi interlacciati.................................................... 137
CAPITOLO 17
-
7/23/2019 Calcolatori Elettronici (Biasi - Narracci - Albano)
8/216
vii
POLITICHE DI GESTIONE DELLE MEMORIE .................................................................................................... 141
1. Interazione con i dispositivi di I/O................................................................................................... 141
2. Interazione con pi processori......................................................................................................... 144
CAPITOLO 18
TECNICHE DI COMPILAZIONE EFFICIENTI ...................................................................................................... 147
1. Srotolamento del loop...................................................................................................................... 147
2. Pipeline da programma.................................................................................................................... 149
CAPITOLO 19
PARALLELISMO A LIVELLO DI ISTRUZIONI ..................................................................................................... 153
1. Processore VLIW............................................................................................................................... 153
2. Processore superscalare................................................................................................................... 157
CAPITOLO 20
PROCESSORE VETTORIALE ............................................................................................................................. 159
1. Architettura processore vettoriale cray-1........................................................................................ 160
2. Modello di programmazione vettoriale........................................................................................... 162
3. Vantaggi del processore vettoriale.................................................................................................. 163
4. Processori a registri vettoriali vs processori memory-memory...................................................... 166
5. Vettorializzazione del codice............................................................................................................ 167
6. Vector Stripmining............................................................................................................................ 168
7. Parallelismo delle istruzioni vettoriali............................................................................................. 170
8. Alcune tipiche operazioni con i vettori............................................................................................ 173
9. Riduzione a scalare dei vettori......................................................................................................... 174
10. Set istruzioni del processore VMIPS............................................................................................. 175
CAPITOLO 21
TASSONOMIA DI FLYNN ................................................................................................................................. 185
1. Classificazione dei processore secondo Flynn................................................................................. 185
2. Concetti base..................................................................................................................................... 185
CAPITOLO 22
INFRASTRUTTURE DI COMUNICAZIONE ........................................................................................................ 187
1. Bus..................................................................................................................................................... 187
2. Rete punto-punto............................................................................................................................. 187
3. Rete ad anello................................................................................................................................... 188
4. Rete a centro stella........................................................................................................................... 189
5. Reti ibride.......................................................................................................................................... 189
-
7/23/2019 Calcolatori Elettronici (Biasi - Narracci - Albano)
9/216
viii
6. Ipercubo............................................................................................................................................ 189
6.1. Trasferimento dei dati allinterno dellipercubo..................................................................... 190
CAPITOLO 23
PREDIZIONE DINAMICA ................................................................................................................................. 195
1. Predittore a un bit............................................................................................................................. 197
2. Predittore a due bit........................................................................................................................... 197
CAPITOLO 24
ALGORITMO DI TOMASULO .......................................................................................................................... 201
1. Buffer di Riordino.............................................................................................................................. 201
2. Fasi dellistruzione............................................................................................................................ 203
3. Esecuzione fuori ordine.................................................................................................................... 206
-
7/23/2019 Calcolatori Elettronici (Biasi - Narracci - Albano)
10/216
ix
-
7/23/2019 Calcolatori Elettronici (Biasi - Narracci - Albano)
11/216
1
CAPITOLO 1LA VALUTAZIONEDELLE PRESTAZIONI DI UN PROCESSORE
Le prestazioni di un processore sono state storicamente valutate da una serie di parametri che nel temposono stati sostituiti da altri. Per esempio un modo stato il numero di colpi di clock per unit di tempo, cio
la frequenza di clock. Prendiamo come esempio un processore da 60 MHz: il clock nel processore, emette
un impulso ogni 60milionesimo di secondo. In un secondo ci sono quindi 60 milioni di colpi di clock. Magari
questo processore viene considerato migliore di un altro che ne emette 45 milioni al secondo. Questa
distinzione per non ha senso se non indichiamo cosa avviene in un colpo di clock.
Il colpo di clock come il colpo di tamburo che il capo vogatore dava sulle galee romane. Gli schiavi
remavano e a ogni colpo di tamburo dovevano dare un certo numero di vogate. Se la vogata legata alla
battuta, una vogata per battuta, e chiaro che con 50 battute al minuto, ci sono 50 vogate al minuto. Ma si
pu benissimo pensare di legare una vogata ogni 5 battute, ogni 5 battute bisogna dare quindi una vogata.Per cui lasciando da parte il singolo colpo di clock, ci si pu concentrare sul CONTO ISTRUZIONI. Mi
interessa sapere, in 1 secondo quante istruzioni processa un processore? E anche con il contro istruzioni
non avr molto senso se non mettiamo dei paletti. Questo viene ricavato da un altro parametro che si
chiama CLOCK PER INSTRUCTIONS (CPI). Se io so i colpi di clock e il clock per instruction allora ho il conto
istruzioni. Ad esempio sapendo che un processore con una frequenza pari ad 1 GHz e che esegue un
istruzione per colpo di clock(CPI = 1), ottengo che in 1 secondo eseguir 1 miliardo di istruzioni. Un altro
processore da 1 GHz che invece ha bisogno di 1,3 clock per istruzione, cio ha bisogno di 1,3 colpi di clock
per eseguire una istruzione, allora in 1 secondo il processore eseguir 1 miliardo/1,3 istruzioni.
Sapere che un processore esegue N istruzioni/sec e un altro ne esegue M istruzioni/sec ci aiuta a definirequale tra questi due processori migliore? Solitamente saremmo portati a dire che quello che ne esegue di
pi dovrebbe essere migliore. Ma in realt questo non ci aiuta molto o meglio ci sarebbe di aiuto solo
nellipotesi in cui entrambi i processori abbiamo lo stesso SET DI ISTRUZIONI (INSTRUCTION SET).
Ora vediamo con accuratezza di cosa si tratta. Quando un processore effettua una operazione, esegue e
traduce tale compito in una sequenza di istruzioni macchina. Ad esempio quando bisogna eseguire un
operazione come A*B*C e scrivere il risultato in memoria allallocazione D il processore attraverso una
serie di istruzioni del SET DI ISTRUZIONI realizza questo compito:
MULT3 A, B, C, D (1)
Con questa istruzione del processore vengono presi i valori dagli indirizzi di A, di B e di C, vengono
moltiplicati e il risultato salvato nellindirizzo D. Il processore prende il dato allindirizzo di ognuno , fa il
prodotto tra questi e scrive il risultato in D, con una sola istruzione.
Un secondo processore diverso dal primo per eseguire la stessa operazione magari dovr utilizzare pi
istruzioni del suo SET DI ISTRUZIONI(diverso dallaltro processore), e quindi avr bisogno di fare:
- A (istruzione per prelevare A dalla memoria)
-
B (istruzione per prelevare B dalla memoria)
-
C (istruzione per prelevare C dalla memoria)- D1 = A*B ( istruzione per fare il prodotto tra A e B e salvarlo in D1)
-
7/23/2019 Calcolatori Elettronici (Biasi - Narracci - Albano)
12/216
2
-
D=D1*C ( istruzione per fare il prodotto tra D1 e C e salvarlo in D)
-
D (istruzione per scrivere D in memoria)
Sapendo che entrambi i processori eseguono 1 istruzione/sec mi da un idea per confrontare i due
processori. Il primo processore che compie loperazione con una sola is truzione necessiter di 1 secondo a
differenza del secondo processore, che ha bisogno di 6 istruzioni e quindi di 6 secondi. E chiaro che inqueste ipotesi il primo processore migliore.
Lultimo processore analizzato non ha nel suo SET DI ISTRUZIONI ,istruzioni cos potenti come MULT3
dellaltro processore . Questo processore ha bisogno di 6 istruzioni per eseguire quelloperazione.
Allora il CONTO ISTRUZIONI pi significativo del colpo di clock che un parametro che descrive
veramente poco e ci indica solamente la frequenza del treno di impulsi trenodi impulsi. Allora pu avere
pi senso sapere effettivamente quante sono le istruzioni che vengono eseguite in un istante di tempo, e
comparare in questo modo due macchine a patto che esse abbiano lo stesso SET DI ISTRUZIONI. Quello che
realmente interessa allutente il tempo che deve aspettare affinch un problema venga risolto. Ora il
problema nella valutazione comparativa dei processori che un problema risolto da un sistema di calcolo
in un unit di tempo , mi porta a dare una valutazione estremamente orientata a quel problema (PROBLEM
ORIENTED) perch nessuno mi garantisce che cambiando il problema la macchina A resti pi veloce della
macchina B. Nella risoluzione di un algoritmo vengono messi in evidenza aspetti che sono differenti dalla
risoluzione di un altro algoritmo.
Quindi fare una valutazione comparativa tra due processori, e quindi sapere quali aspetti andare a
migliorare su un progetto, diventa un compito non banale.
1. Filosofia Risc E Cisc
Si presentano due filosofie di architettura di un processore per quanto riguarda il SET Di ISTRUZIONI: RISCe
CISC.
Un set di istruzioni RISC (Reduced Instruction Set Computing, calcolatore con insieme ridotto di istruzioni)
un tipo di architettura di microprocessore che si concentra sull'elaborazione rapida ed efficiente di una
serie relativamente piccola di istruzioni che comprende la maggior parte delle istruzioni che un calcolatore
codifica ed esegue. L'architettura RISC ottimizza le istruzioni di modo che possano venire seguite molto
rapidamente, in genere in un solo ciclo di clock. I chip RISC eseguono cos le istruzioni semplici pi
velocemente dei microprocessori CISC(Complex Instruction Set Computing) progettati per gestire una serie
pi vasta di istruzioni. Sono tuttavia pi lenti dei chip CISC quando si tratta di seguire istruzioni complesse
che, per poter essere eseguite da microprocessori RISC, devono essere suddivise in molte istruzioni
macchina.
Allora scegliere il tipo di filosofia assumer un senso quando si utilizzer un processore che prevede che
tutte le istruzioni siano molto simili tra di loro in modo da semplificare una parte non trascurabile di un
processore: lUNITA DI CONTROLLO. Progettare ununit di controllo che piloti ogni transistor del
processore per lesecuzione di ogni singola istruzione ha una certa complessit. Questa complessit pu
-
7/23/2019 Calcolatori Elettronici (Biasi - Narracci - Albano)
13/216
3
essere ridotta se le istruzioni sono molto simili tra di loro(RISC). Al contrario pilotare ogni transistor del
processore per eseguire tante diverse istruzioni(CISC), comporta un unit di controllo un po pi
complicata. Venuto meno il problema della memoria costruita con nuclei di ferrite, da tanti anni i
calcolatori CISC non esistono pi.
Tornando al discorso sulla valutazione delle prestazioni, quello che interessa vedere il tempo in cui un
problema viene svolto. Come abbiamo gi detto, se una macchina risolve un problema in un tempo minore
di un'altra macchina non vuole che con problemi diversi ha sempre caratteristiche di performance che la
portano a prevalere sullaltra macchina. Esistono dei programmi che hanno lo scopo di valutare le
prestazioni di un sistema. Questi programmi si chiamano BENCHMARK (banco di prova). Per mettere in
evidenza vari aspetti si crea un paniere di benchmark in cui c un programma che testa come quel sistema
gestisce gli accessi in memoria, un altro che testa come quel sistema fa i calcoli in virgola mobile, un altro
ancora che testa come quel sistema gestisce laccesso a grandi quantit di dati e cos via. Quindi in base a
questo paniere di benchmark, si riescono a valutare le prestazione di una macchina.
In fase di progettazione quando si ottengono delle prestazioni dal sistema e si individuano dei punti critici,
si pone il problema se ha senso o meno migliorare il sistema riguardo quel punto critico.
Tornando allesempio di (1), ammettiamo che il progettista del secondo processore (RISC) non abbia
problemi a inserire istruzioni di tipo CISC, ad esempio come MULT3. Questo ampliamento del set di
istruzioni avr un certo costo, bisogna fare in modo che lunit di controllo sappia gestire anche quella
istruzione, e supponiamo di aver quantificato questo costo, es. 2 transistor. Bisogna per tenere in
considerazione il beneficio che si trae rispetto al costo. Quindi scoprire che questa istruzione dopo averla
inserita mi consente di eseguire questo obiettivo in un secondo piuttosto che in 1,2 secondi quindi con unaumento delle mie prestazioni del 20% pu essere utile a fronte del fatto che ho dovuto inserire 2
transistor su un unit di controllo che ne prevedeva 1000 con un costo dello 0,2 %. Questo per deve va in
relazione con il numero di volte in cui verr utilizzata nella vita di questo calcolatore listruzione , ad
esempio MULT3. Perch se questa istruzione viene utilizzata spesso allora effettivamente si
guadagnato, ma se quel calcolatore lavora con questa istruzione una volta su mille, questo 20% che mi ho
guadagnato non stato guadagnato in assoluto ma una volta su mille e quindi diventato 0,02%.
2. La Legge Di Amdahl
In questo discorso assume molta importanza la LEGGE DI AMDAHL.
Usando la legge di Amdahl si pu calcolare il guadagno in termini di prestazioni che si pu ottenere
migliorando una parte di un calcolatore. Questa legge afferma che il miglioramento di prestazioni che pu
essere ottenuto usando qualche modalit di esecuzione pi veloce limitato dalla percentuale di tempo in
cui pu essere utilizzata tale modalit. La legge di Amdahl definisce laumento di velocit (speedup) che si
pu ottenere usando una particolare caratteristica. Cos laumento di velocit? Immaginiamo di poter
apportare un miglioramento a un calcolatore in modo che le sue prestazioni migliorino. Laumento di
velocit il rapporto
-
7/23/2019 Calcolatori Elettronici (Biasi - Narracci - Albano)
14/216
4
Oppure equivalentemente
Speedup =( Tempo di esecuzione complessivo senza usare il miglioramento) /( Tempo di esecuzione
complessivo usando il miglioramento).
Il valore di Speedup ci dice quanto pi velocemente verr eseguito un programma usando il calcolatore
migliorato, rispetto al calcolatore originale. La legge di Amdhal fornisce un mezzo rapido per misurare lo
Speedup conseguente a un determinato miglioramento, che dipende da due fattori:
1.
La frazione del tempo di esecuzione sul calcolatore originale che pu trarre vantaggio dal
miglioramento. Per esempio, se il miglioramento pu essere usato in 20 dei 60 secondi totali
richiesti per l'esecuzione di un programma, la frazione di cui parliamo 20 /60. Questo valore, che
chiameremofrazione migliorata, sempre inferiore al pi uguale a 1.
2.
Il miglioramento di prestazioni che si ottiene nel modo di esecuzione migliorato, cio quanto
verrebbe seguito pi velocemente il programma se il modo di esecuzione migliorato potesse essere
utilizzato per l'intero programma. Questo valore uguale al tempo di esecuzione nella modalit
originaria diviso il tempo di esecuzione nella modalit migliorata. Se nella modalit migliorata
occorrono, per esempio, due secondi per eseguire una parte del programma che richiede invece 5secondi nella modalit originaria, il miglioramento 5/2. Chiamiamo speedup miglioratoquesto valore,
che sempre maggiore di 1.
Il tempo di esecuzione con il calcolatore originario a cui viene apportato il miglioramento sar pari al tempo
impiegato dalla porzione non soggetta a miglioramento sommato al tempo della porzione che si
avvantaggia del miglioramento:
-
7/23/2019 Calcolatori Elettronici (Biasi - Narracci - Albano)
15/216
5
Lo Speedup complessivo il rapporto tra i tempi di esecuzione:
-
7/23/2019 Calcolatori Elettronici (Biasi - Narracci - Albano)
16/216
6
-
7/23/2019 Calcolatori Elettronici (Biasi - Narracci - Albano)
17/216
7
CAPITOLO 2CARATTERISTICHEDELLE ISTRUZIONI DI UN CALCOLATORE
I linguaggi con cui noi riusciamo a dialogare con il processore sono stratificati. Esistono una serie di livellistratificati. Nello strato pi interno, quello pi vicino al processore, il linguaggio incomprensibile da un
essere umano(linguaggio macchina), invece man mano che ci si avvicina agli strati pi esterni,il linguaggio
diventa sempre pi comprensibile per l'essere umano(linguaggi di alto livello).
I linguaggi ad alto livello sono stati introdotti per codificare gli algoritmi in un modo pi semplice e intuibile
da parte dell'essere umano. Ci che viene realmente eseguito da una CPU sono le istruzioni del programma
tradotte in un linguaggio pi intuibile da parte del processore costituito da stringhe di 1 e 0(linguaggio
macchina).
Il linguaggio "appena superiore" al linguaggio macchina il linguaggio ASSEMBLER. Questo linguaggio una
traduzione 1:1 di ogni istruzione del linguaggio macchina con una sintassi pi comprensibile per luomo.
I livelli d'istruzione che operano sulla CPU fondamentalmente sono di 3 tipi:
- Istruzioni aritmetico-logiche(somma, and logico, ecc..)
-
Istruzioni per accedere alla memoria(istruzioni per scrivere e leggere dalla memoria)
Lettura(LOAD)
Scrittura(STORE)
-
Istruzioni di controllo (o di diramazione)
Salti incondizionati(JUMP)
Salti condizionati(BRANCH)
I JUMP ad esempio possono essere confrontati con le chiamate di funzioni di qualsiasi linguaggio ad alto
livello, visto che, in questo caso, avviene un salto incondizionato da una istruzione ad un altra. Alla fine si fa
ritornare l'esecuzione all'istruzione successiva a quella chiamante.
1. Ciclo Istruzione
L'istruzione una sequenza di bit che il processore legge caricando dalla memoria. Una volta lette le
istruzioni verranno eseguite sempre una dopo l'altra. Lesecuzione di una istruzione avviene grazie ad un
ciclo, chiamato CICLO D'ISTRUZIONE.
Il Ciclo di Istruzione composto da:
- FETCH dellistruzione:e' la fase di prelievo dell'istruzione. Questa fase avviene grazie al PROGRAM
COUNTER che contiene l'indirizzo dell'istruzione da eseguire. Questa viene prelevata e poi caricata
nel processore pronta per essere decodificata ed eseguita.
- DECODE dellistruzione:' la fase di riconoscimento dell'istruzione che avviene grazie all'unit di
controllo che legge listruzione e riconosce quale operazione bisogna eseguire. Ovviamente queste
-
7/23/2019 Calcolatori Elettronici (Biasi - Narracci - Albano)
18/216
8
operazioni sono state definite secondo rigide convenzioni. Ogni famiglia di processori ha delle
proprie convenzioni.
- EXECUTE dell'istruzione: la fase di esecuzione dell'istruzione.
Queste fasi sono sequenziali e sono arbitrate dal clock.
2. Categorie Di Formati Istruzione
Le istruzioni si distinguono per il numero di bit di cui sono composte, inoltre possono esserci due categorie
di formato istruzione:
- Formato a lunghezza fissa (numero di bit fisso)
-
Formato a lunghezza variabile (numero di bit variabile)
Il formato a lunghezza variabile prevista maggiormente nelle macchine di tipo CISC. Le macchine di questo
tipo quindi hanno bisogno di un' unit di controllo molto complessa per poter leggere ogni tipo di
lunghezza delle istruzioni. Invece le macchine di tipo RISC che hanno l'obbiettivo di semplificare l'unit di
controllo, prevedono un formato d'istruzione a lunghezza fissa.
3. Struttura Dell'istruzione
Un istruzione costituita essenzialmente dal codice operativo (OPCODE): tra i bit che compongono
l'istruzione ce ne saranno un certo numero che servono a specificare l'operazione dell'istruzione corrente. Il
codice operativo formato da log2n bit, arrotondato per eccesso, dove n il numero delle istruzioni
possibili. Ad esempio se ho bisogno di implementare un processore che necessita di 100 tipi di istruzioni,
servirebbero per eccesso 7 bit per codificare il codice operativo di ogni istruzione, che pu definire fino a
128 istruzioni (27). In genere i 28 tipi di istruzione rimanenti non vengono implementate proprio per non
incorrere in complicanze dell'unit di controllo. Per queste istruzioni rimanenti, in futuro, potrebbero
essere utilizzate per delle nuove frontiere tecnologiche, in modo tale da poter effettuare un semplice
upgrade invece di riprogettare tutta l'unit di controllo da zero.
Oltre ai bit del codice operativo ci sono inoltre delle sequenze di bit che identificano gli operandi su cuilistruzione effettua le operazioni.
-
7/23/2019 Calcolatori Elettronici (Biasi - Narracci - Albano)
19/216
9
CAPITOLO 3CLASSIFICAZIONEDEI PROCESSORI
Si possono caratterizzare i processori in base a diversi aspetti.
1. Classificazione per istruzione
Un aspetto la tipologia di lunghezza fissa o variabile delle istruzioni affrontata nel capitolo precedente: le
istruzioni a lunghezza fissa tipiche di una architettura con filosofia RISC e istruzioni con lunghezza variabile
tipiche di una architettura con filosofia CISC. Inoltre le istruzioni fondamentalmente si dividono in tre
famiglie:
o istruzioni di accesso a memoria
o
istruzioni che modificano il flusso del programma
o istruzioni che codificano operazioni logico-aritmetico
2. Classificazione per parola
Un altro aspetto con cui possibile caratterizzare i processori attraverso il tipo di dati che essi trattano. Ci
sono una serie di dati che si differenziano sia per il formato(numero bit) e sia per il tipo di dati che questo
formato va a interpretare. Ad esempio i dati di tipo numerico si codificano con o senza la virgola(interi o
reali) e questo presuppone una codifica in binario puro con o senza segno o con una codifica che tieneconto di potenze di due sia positive e sia negative in modo da poter compattare i numeri in diversi formati
come anche la virgola fissa o mobile. Standard pi efficienti prevedono luso della virgola mobile( vedi
floating point). Bisogna precisare quindi se il processore elabora dati in floating point o in virgola fissa. Anni
fa non tutti i processori elaboravano dati floating point poich non prevedevano al loro interno hardware
sufficiente per effettuare queste operazioni, e quando era necessario fare calcoli in virgola mobile questi
venivano eseguiti da un software. Se cera bisogno di fare molti di questi calcoli si comprava il co -
processore matematico che implementava al suo interno in hardware questo tipo di calcoli. Ora possibile
integrare nello stesso chip degli hardware per effettuare calcoli matematici in floating point, infatti la
maggior parte dei processori del giorno doggi gestiscono dati in floating point, contengono al loro interno
un set istruzioni che permette la gestione di questi. Per anni questo non stato possibile poich iprocessori, avendo un hardware limitato, avevano a disposizione quindi un set di istruzioni che prevedeva
la gestione dei soli numeri interi.
Una volta scelta la possibilit di utilizzare dati piuttosto che altri(floating point piuttosto che numeri interi)
bisogno stabilire la grandezza di questi dati, di quanti bit devo essere questi dati. I processori dunque si
differenziano per i tipi di dati che possono gestire e la loro dimensione, dati da 4 byte intero, 8 byte intero,
16 byte intero oppure 32bit floating point(singola precisione) o 64bit floating point e cos via.
Un ulteriore aspetto che differenzia i processori rappresentato anche della profondit della parola.
Lunit il bit che viene elevato a byte(1byte = 8bit) con 1 byte posso esprimere informazioni in un rangetra 0 e 255(28). Se linformazione che voglio descrivere rappresentabile con un singolo byte sufficiente la
-
7/23/2019 Calcolatori Elettronici (Biasi - Narracci - Albano)
20/216
10
parola di un byte, ad esempio le lettere dellalfabeto, 26 lettere entrano in un byte(256 lettere) posso
ancora codificare le lettere maiuscole e minuscole, numeri, simboli di punteggiatura. Con un byte si
possono benissimo rappresentare caratteri alfanumerici e attraverso una codifica(in questo caso la codifica
ASCII) a associa ad un numero tra 0 e 255 un simbolo. Quel byte invece non pi sufficiente per indicare
quanti sono gli spettatori al concerto di Vasco Rossi. Non pi sufficiente perch non riesco a esprimere
con un byte questa informazione. Bisogna quindi definire una quantit che verr usata come riferimento
standard dellarchitettura: la parola(WORD). La parola diviene lunit. Un architettura definisce una parola
con un certo numero di byte che tratta come nucleo del dato pi frequentemente adoperato. Le parole
solitamente sono di 4byte, tutto il traffico nel processore avviene usando dati di 4 byte. I dati sono nel
formato definito dalla WORD.
3. Classificazione per la gestione della memoria interna
Possiamo differenziare i processori anche in base a come i dati allinterno di questo vengono gestiti. Lamacchina secondo Von Neumann strutturata con una cpu, una memoria centrale, periferiche di
input/output e i canali di comunicazione tra questi. Si pu immaginare ad un modello in cui il processore
quando ha bisogno di un dato in una istruzione lo va a reperire ogni volta direttamente dalla memoria
centrale e il risultato lo scrive sempre in memoria. Ma si pu pensare ad un processore che abbia al suo
interno unarea di memoria in cui i dati quando servono vengono letti dalla memoria centrale scritti in
questa area e ogni volta che servono vengono letti da questa e non dalla memoria centrale, purch al
termine di tutto questi dati vengano scritti in memoria centrale.
Sono stati sviluppati tre modelli per la gestione per questa memoria intima del processore.
-
7/23/2019 Calcolatori Elettronici (Biasi - Narracci - Albano)
21/216
11
i
1. Una soluzione semplice era il processore ad accumulatore, che prevedeva al suo interno una sola
area di memoria, laccumulatore,utile a contenere un solo dato.
Nellaccumulatore veniva caricato un operando dalla memoria e quando il processore doveva
effettuare delle operazioni, che di solito necessitano di due operandi sorgente, ad esempio la
-
7/23/2019 Calcolatori Elettronici (Biasi - Narracci - Albano)
22/216
12
somma (SUM), listruzione intendeva fare la somma di due operandi, uno letto dalla memoria e
laltro quello che risiede nellaccumulatore. Il risultato andava scritto sempre nellaccumulatore.
Le istruzioni nella loro strutturazione sono semplici in quanto sono costituiti dal codice operativo e
un indirizzo di memoria.
SUM 2730
Loperando nellaccumulatore veniva sommato alloperando che si trovava nellindirizzo di memoria
2730, e il risultato veniva scritto nellaccumulatore. Dopo loperazione quello che cera prima
nellaccumulatore veniva perso, cera il risultato della somma.
Per scrivere il risultato nella memoria centrale ad un certo indirizzo:
STORE 3256
Il valore nellaccumulatore veniva scritto in memoria allindirizzo 3256.
Esercizio:
Supponiamo di avere degli indirizzi di memoria A B C D e di voler mettere nellindirizzo di memoria
E la somma di quello che c nellindirizzo A e nellindirizzo B: E=A+B; e invece in F: F = A*C+D
Istruzione Valori nell
accumulatore
LOAD A A
SUM B A+B
STORE E A+BLOAD A A
MULT C A*C
SUM D A*C+D
STORE F A*C+D
2.
Un'altra tipologia di processore era quella a stack, processori a stack. In questi non cuna sola
area di memoria, ma una struttura di memoria con pi locazioni a cui non si pu accedere in
maniera casuale, ma si pu aver accesso solo a chi in testa allo stack(come una pila LIFO LastInput First Output), lultimo dato inserito il primo adessere prelevato. C un meccanismo che
prevede uno STACK POINTER (SP) che mi indica larea dello stack a cui posso accedere, e che
contiene quindi il dato in questione. Nelle operazioni aritmetico logiche non bisogna specificare
nellistruzione lindirizzo degli operandi, perch questi sono i primi due che si trovano al top dello
stack e sono questi che verranno utilizzati nelle operazioni. Le operazioni di tipo LOAD vengono
chiamate in questo contesto push, mentrequelle di STORE pop
-
7/23/2019 Calcolatori Elettronici (Biasi - Narracci - Albano)
23/216
13
Bisogna per stabilire delle convenzioni sullo stack pointer: lo stack pointer punta alla prima vuota
o allultima piena. Lo stack pointer pu puntare alla prima area dello stack vuota o allultima piena.
Ipotizzando che SP punti alla prima vuota.
LOAD (push):
M[indirizzo] ->S[SP]
SP+1->SP
Letto il dato dalla memoria(indirizzo) viene memorizzo nello stack, nellarea di questo puntata dallo
stack pointer(questa area dello stack vuota visto che SP indica proprio larea vuota per la
convenzione adottata). Bisogna per incrementare SP per farlo puntare nuovamente alla prima
vuota.
STORE (pop):
SP-1->SP
S[SP]->M[indirizzo]
SP punta alla prima vuota(garbage, valore dellultimo dato scritto e non ha nessun valore utile),
bisogna farlo puntare allultima piena e poi scrivere ci che puntato dallo stack pointer in
memoria(nellindirizzo di memoria).
Utilizzando invece la convenzione in cui SP punta allultima piena.
-
7/23/2019 Calcolatori Elettronici (Biasi - Narracci - Albano)
24/216
14
LOAD (push):
SP+1->SP
M[indirizzo] -> S[SP]
Bisogna far puntare prima SP alla prima vuota(altrimenti perdo il dato che avevo in precedenza), e
caricare poi il dato dalla memoria.
STORE (pop):
S[SP]->M[indirizzo]
SP-1->SP
Lultimo pieno (quello puntato da SP) proprio il dato da salvare in memoria. Per ades so bisogna
decrementare lo stack pointer.
E essenziale stabilire la convenzione. Nella strutturazione pipeline(che vedremo successivamente
nel corso) si prevede che prima si eseguono dei calcoli e poi si accede a memoria. Potrebbe essere
utile questa scelta per stabilire quale convenzione usare per lo stack pointer, per le dueconvenzioni non vanno comunque bene(perch nella LOAD di una convenzione si eseguono prima
le operazioni e poi si accede a memoria ma nella STORE il contrario, e viceversa con laltra
convenzione), allora si pu ipotizzare di fare una ibridazione e scegliere di eseguire le load secondo
una convenzione e le store secondo un'altra, ma non va bene comunque. Bisogna scegliere una di
queste due convenzioni in base a quale operazione faccio pi frequentemente load o store.
Intuitivamente si portati a dire che le load e le store sono effettuate lo stesso numero di volte,
per le load sono pi numerose, perch si sale lungo lo stack con le load e si scende con le store ma
anche con le operazioni che prevedono la memorizzazione di un operando nella memoria.
3.
Un'altra famiglia di processori quella dei processori a registri, che utilizzano un certo numero dilocazioni (come lo stack) a cui per si pu accedere a piacere, si pu accedere a qualsiasi locazione
senza vincoli. Queste celle assumono tutte la stessa dignit.C un area di memoria costituita da
dei registri che si indirizzano autonomamente. Non si legati alla cima della pila. Per questa
comodit si paga sia un hardware pi complesso per gestire questo sistema, e soprattutto si paga
un discorso che obbliga a inserire nellistruzione la specifica degli indirizzi degli operandi.
-
7/23/2019 Calcolatori Elettronici (Biasi - Narracci - Albano)
25/216
15
Nel caso del processore ad accumulatore un operando era sempre laccumulatore quindi
nellistruzione si indicava un solo indirizzo per loperando da prelevare dalla memoria; nel
processore a stack gli operandi erano sempre i primi due dello stack e nelle istruzioni non si
specificava nessun indirizzo. Nei processori a registri invece necessario specificare il primo
operando(che si trova in un determinato registro), il secondo operando(che si trova in un altroregistro), il terzo operando(che si trova in unaltro registro ancora). Quindi listruzione oltre al
codice operativo prevede tre campi per gli operandi, e questi campi contengono un numero di bit
pari al log2(num. registri). Si pu sempre pensare di dare una ulteriore flessibilit e oltre a prelevare
gli operandi dai registri si vuole dare la possibilit di prendere operandi dalla memoria, ad esempio
si vuole effettuare la somma di due dati in cui uno si trova in un registro, mentre il secondo si trova
in una certa locazione della memoria centrale(indirizzo di memoria). Oppure la locazione dellarea
di memoria di un operando scritta addirittura in un registro. In questi casi il formato si complica
perch il numero dei bit dei campi per la specifica degli operandi deve poter contenere anche gli
indirizzi di memoria, bisogna prevedere la gestione di questi meccanismi.
La maggior parte dei processore di oggi sono della tipologia a registri. Tipicamente le macchine a registro si
suddividono in LOAD/STORE piuttosto che no. Una macchina a registro si dice che una macchina
LOAD/STORE nel momento in cui le uniche istruzioni di questa macchina che fanno riferimento alla
memoria sono solo le istruzioni LOAD e STORE, significa che nellesecuzione di una istruzione aritmetica, la
somma per esempio, il processore non pu accedere alla memoria, gli operandi devono essere stati gi tutti
preventivamente caricati nei registri. Non possibile con questa tipologia di macchina prendere un
operando dalla memoria direttamente con la istruzione aritmetico logica, SUM per esempio, passando
lindirizzo della locazione di memoria, ma tutti gli operandi sono stati gi tutti preventivamente caricati nei
registri, e il risultato di questa operazione deve essere ancora scritto in un registro, non pu essere scritto
in una locazione di memoria. Nelle macchine di tipo LOAD/STORE le uniche operazioni che permettono di
caricare o scrivere da/in memoria sono solo e soltanto le operazioni di LOAD e di STORE. Osserviamo nella
figura che quando c da usare lALU la memoria scollegata
-
7/23/2019 Calcolatori Elettronici (Biasi - Narracci - Albano)
26/216
16
4. Classificazione per modi di indirizzamento
Un altro modo di caratterizzare i processori il modo con cui questi gestiscono laccesso a memoria, cio il
modo con cui lindirizzo, dove andare a leggere o scrivere, pu essere fornito al processore. Il modo pi
semplice scrivere un indirizzo nellistruzione stessa(modalit con indirizzo immediato); un altro modo
quello conindirizzo direttodove lindirizzo dellarea di memoria scritto in un registro. Lindirizzo dellareadi memoria va prelevato da un registro.
-
7/23/2019 Calcolatori Elettronici (Biasi - Narracci - Albano)
27/216
17
CAPITOLO 4MODI DI INDIRIZZAMENTO
Nel capitolo precedente abbiamo distinto le macchine a registri in due categorie:
1. Larchitettura Load-Storeche consente di fare operazioni di tipo aritmetico logico solo fra operandi
che sono nei registri, quindi non si pu fare la somma fra un dato che in un registro e un dato che
in memoria, o ancor peggio la somma di due dati che sono in memoria. Bisogna solo fare
operazioni aritmetico logiche che riguardano due operandi che sono gi presenti nei registri. In
sostanza si acceder alla memoria solo attraverso operazioni tipiche della memoria. Quindi questo
tipo di macchina sar una macchina a registri LOAD-STORE per significare che la memoria sar
usata solo con istruzioni di tipo LOAD STORE. Quindi per fare un operazione aritmetica fra due dati
che sono in memoria prima bisogna eseguire la LOAD di questi due dati , per esempio prendere il
primo dato e inserirlo nel registro R1 , leggere un secondo dato e inserirlo nel registro R2 e solo ora possibile fare le operazioni fra R1 ed R2; il risultato andr in un altro registro che pu anche
essere uno dei due che si appena usato, ma non si pu scrivere il dato in memoria se non
attraverso loperazione di STORE
2. Larchitettura Registro-Memoriainvece prevede di usare lALU per fare calcoli ma nellambito della
stessa istruzione anche di accedere a memoria. Questo tipo di struttura per preveder un codice
operativo che dovr contenere sia la specifica di un registro (per loperando) sia la specifica di un
registro del risultato e sia un indirizzo. Quindi siccome per indirizzare un registro tipicamente
bastano pochi bit, con 32 registri sufficiente un insieme di 5 bit. Con 5 bit infatti si possono
codificare numeri compresi tra 0 e 31; scrivendo il numero 7 si intende il registro R7. Per specificareun indirizzo non bastano 5 bit, attraverso 5 bit si indirizza solo una porzione della memoria.
Tipicamente per specificare un indirizzo si necessitano di pi bit, almeno che per specificare un
indirizzo non si utilizza un artefatto: scrivere lindirizzo di memoria in un registro. Quindi
nellistruzione si andr solamente a specificare lindirizzo del registro, che contiene lindirizzo di
memoria, attraverso i 5 bit.
1. Indirizzamento Diretto
La modalit di indirizzamento appena mostrata si chiama INDIRIZZAMENTO DIRETTO. C un registro che
direttamente contiene lindirizzo dellarea di memoria. Nellistruzione si andr a specificare solamente
lindirizzo del registro che contiene lindirizzo di memoria a cui accedere.
2. Indirizzamento con Immediato
possibile scrivere lindirizzo direttamente nellistruzionestessa. Quindi listruzione dovr contenere oltre
anche varie altre informazioni fra cui una di queste lindirizzo.
-
7/23/2019 Calcolatori Elettronici (Biasi - Narracci - Albano)
28/216
18
3. Indirizzamento con Scostamento (displaycement)
Lindirizzo con displaycement viene calcolato sommando al contenuto di un registro un numero (INDIRIZZO
BASE) codificato nellistruzionestessa. Nellistruzione verr specificato quindi un registro per esempio R9 e
un immediato(indirizzo base), e lindirizzo di memoria verr calcolato sommando questo indirizzo base che
e il contenuto di R9. Ci si pu chiedere, ma non era meglio inserire tutto limmediato di per s? Si per sequesta istruzione va eseguita allinterno di un loop e ad ogni ciclo si ha la necessit di accedere a un dato
diverso bisogna avere un indirizzo diverso. Con lindirizzamento con scostamento listruzione contiene una
un immediato e un registro da sommare cos che nel loop ogni volta verr cambiato il valore dellimmediato
Ci sono anche altre modalit che sono usate nellambito deiprogrammi in maniera diversa. Cio quando un
programma usa una modalit di indirizzamento si pu vedere se questa modalit frequente perch in tal
caso si pu pensare di potenziare lesecuzione di un istruzione che usa quel tipo di modalit di
indirizzamento.
Questo diagramma prende in considerazione 5 modalit diverse di indirizzamento:
1. Indiretto in memoria
2.
Scalato
3.
Indiretto con registro
4. Immediato
5. Scostamento
e per ciascuna di queste usando 3 programmi standard che vengono considerati come benchmark, si pu
vedere, quando si esegue una compilazione, come funziona luso di tali indirizzamenti. Dopodich se si
vuole provvedere a come potenziare larchitettura di un sistema che dovrebbe essere usato
prevalentemente per fare calcolo scientifico si studia il comportamento di quello che fa il sistema quando
usa un programma di tipo scientifico come SPICE, e si scopre che oltre la met degli accessi in memoria
avvengono attraverso uno SCOSTAMENTO (displaycement). Questo il tipico modo con cui si accede ai dati
dei vettori. Quindi capiamo bene come in SPICE questo il modo pi frequente perch quando si fa una
-
7/23/2019 Calcolatori Elettronici (Biasi - Narracci - Albano)
29/216
19
simulazione di una rete elettrica si risolvono sistemi che fanno uso di calcolo vettoriale e per questo per
accedere a elementi di un vettore si ha bisogno di accedere con indirizzamenti codificati in questo modo.
Per cui se si vuole migliorare qualcosa di questo processore, relativamente agli accessi in memoria
converr migliorare il modo con cui il processore accede a memoria dopo aver calcolato lindirizzo in
maniera di spiazzamento.
Se invece si vuole realizzare un sistema che fa tipicamente editoria, (TeX) ci si accorge che quando il
compilatore accede a memoria utilizza indirizzi immediati cio nella esecuzione si fa riferimento a un
indirizzo codificato in maniera diretta nellistruzione stessa.
Invece lindirizzamento che prende il nome di REGISTRO INDIRETTO un indirizzamento secondo il quale il
registro contiene un indirizzo che non lindirizzo del dato di destinazione ma ancora un altro indirizzo e
quindi si va due volte in memoria.
4. Indirizzamento con registro auto-incrementato o auto-decrementato
In questo diagramma non presente un altro modo abbastanza frequente di accedere alla memoria che
quello con auto-incremento o auto-decremento del registro, in cui listruzione di accesso a memoria
ingloba in s anche loperazione di aggiungere o togliere una quantit al registro usato per conoscere
lindirizzo. Ad esempio in R8 c un certo indirizzo, si pu avere o meno limmediato da sommare al registro
per avere lindirizzo di memoria; si effettua la somma nel caso sia necessario fra limmediato e il registro, e
si ottiene lindirizzo di memoria. Oltre a questo il registro viene aumentato o diminuito di 4 o comunque di
una quantit che rappresenta il numero di byte letti dalla memoria in maniera tale che questo registro in
automatico adesso punter al prossimo dato. C la operazione con indirizzamento auto incrementanteo
auto decrementante prefisso a significare che prima verr incrementato o decrementato il registro e poi
verr usato per accedere in memoria.
Questo meccanismo utile per la gestione di uno stack, non si intende lo stack interno al processore, la
macchina sempre a registri, ma si intende uno stack come un area di memoria che il processore gestisce.
Valgono le due convenzioni su SP che punta alla prima vuota o allultima piena.
Ad esempio vediamo la gestione dello stack. D la dimensione della cella dello stack, ed R6 il registro su
cui avvengono le operazioni.
Consideriamo il caso in cui SP punti allultima piena (1).
POP (1):
M[SP] R6
SP D SP
PUSH (1):
SP + D SP
R6M[SP]
-
7/23/2019 Calcolatori Elettronici (Biasi - Narracci - Albano)
30/216
20
Consideriamo il caso in cui SP punti allultima vuota (2).
POP (2):
SP D SP
M[SP] R6
PUSH (2):
R6 M[SP]
SP + D SP
Supponiamo che R31 il registro che contiene lo stack pointer che un indirizzo di memoria. Posso fare
uso dellindirizzamento con auto-incremento o auto-decremento, si scrive un +( o un -) a destra o a
sinistra del registro per indicare rispettivamente un incremento( o decremento) postfisso o prefisso.
Le istruzioni scritte prima diventano:
POP (1):
LOAD R6 R31-
Scrivo in R6 il dato letto dalla memoria puntata da R31. Il segno indica che dopo aver scritto nel registro
R6, R31 viene decrementato: R31 = R31 D
PUSH (1)
STORE R6 +R31
R1 viene prima incrementato, e poi viene scritto nellarea di memoria puntata il valore di R6.
Con laltra convenzione
POP (2):
LOAD R6 -R31
PUSH (2):
STORE R6 R31+
E importante precisare che quando si accede a uno stack con le operazioni di PUSH e POP, bisogna prima
verificare che lo stack non sia pieno, altrimenti si scrive su una zona di memoria che magari stata riservata
per contenere altri dati; e che non sia vuoto.
Ipotizziamo che R30 e R29 sono due registri che contengono rispettivamente R30 il TOP(ultima locazione
accessibile) ed R29 il BOTTOM(la prima cella accessibile).
-
7/23/2019 Calcolatori Elettronici (Biasi - Narracci - Albano)
31/216
21
Con la convenzione dellultima piena, per effettuare una push bisogna verificare che:
SP < TOP
Invece per effettuare una pop bisogna verificare che:
SP >= BOTTOM
Con la convenzione dellultima vuotainvece, per effettuare una push deve essere verificato che:
SP BOTTOM
Tipicamente lindirizzamento con spiazzamento (pi usato nel calcolo scientifico) ha questa struttura:
Il codice operativo ad indicare un operazione di LOAD o STORE, e un registro destinazione o sorgente: nel
caso di una LOAD il registro di destinazione, nel registro verr scritto il risultato; altrimenti nel caso di una
STORE il registro sorgente, contiene un dato che verr scritto in memoria. Infine ci c un altro registro
che contiene lo spiazzamento e un indirizzo per limmediato, questi ultimi sommati vanno a formare
lindirizzo di memoria. Questo immediato da prendere come indirizzo a cui sommare il contenuto del
registro di spiazzamento per ottenere lindirizzo finito. E normale che questo immediato ha un numero di
bit che minore del numero di bit del listruzione. Se considero un processore con N istruzioni, sono
necessari almeno Log2N bit per il codice operativo. Ad esempio 6 bit per il codice operativo. Considerando
inoltre un processore con 32 registri, sono necessari 5 bit per specificare un registro. Nella struttura fornita
prima dellistruzione in cui compaiono oltre al codice operativo due registri e considerando ancora che leistruzioni sono di 32 bit rimangono per limmediato solamente 16 bit. Tipicamente uno spazio di
indirizzamento nella memoria, ha la dimensione del BUS del processore. Quindi se il processore traffica con
dati da 32 bit anche gli indirizzi saranno di 32 bit perch allinterno del processore gli indirizzi che si
possono gestire (per esempio somma tra immediato e registro di spiazzamento) sono indirizzi scritti in un
registro. Quindi non si vincolati ad avere una memoria solo di 232 byte = 4 gigabyte, significa per che in
un momento storico della vita di quel programma ci sar una memoria di 4 gigabyte. Molto probabilmente
la memoria sar effettivamente di diversi terabyte, per si sta facendo riferimento a uno spazio di
indirizzamento che una fetta(4 gigabyte) di questa memoria. Per cui quando si accede a memoria, questo
indirizzo sar un indirizzo che andr a consultare un SUBSETdella memoria di 4 gigabyte.
Allora questo immediato di 16 bit (ad esempio) ipotizzando 32 bit per questa istruzione, va utilizzato come
se fosse di 32. Quindi questi immediati vengono tipicamente espansi a 32 bit. A partire da questo numero
di 16 bit verr creato un numero di 32 bit facendo un espansione in segno, perch questo numero pu
essere positivo o negativo ad indicare uno spostamento in avanti o indietro rispetto al registro di
spiazzamento. Se positivo o negativo lespansione in segno preveder la replica dei bit pi significativi.
Dato un numero di N bit e lo si vuole espandere a N+K bit, si andranno ad aggiungere K bit alla sua sinistra.
-
7/23/2019 Calcolatori Elettronici (Biasi - Narracci - Albano)
32/216
22
Esempio: consideriamo il numero 18 e lo si vuole scrivere con 4 cifre. Bisogner scrivere 0018, poich
questo un numero positivo si andranno ad aggiungere gli zeri a sinistra.
Se il numero invece binario con segno in complemento a 2: i numeri negativi avranno il primo bit uguale a
1. Per scrivere -7 usando 5 bit binari, si pu scrivere -7 in complemento a 2.
00111 (7) in 5 bit
11000 C.A. 1
11001 C.A. 2 (-7)
Se si vogliono usare 8 bit per rappresentare -7:
00000111 (7) in 8 bit
11111000 C.A.1
11111001 C.A. 2 (-7)
Per leggere questi risultati dovr verificare il primo bit se esso uguale a zero allora il numero in binario
puro e lo si pu leggere normalmente. Se invece il primo bit uguale a 1 non si pu legge il numero in
binario e bisogner fare un operazione che di nuovo in complemento a 2. Si scriver il segno meno e si
effettua il complemento a 2 sul numero:
11111001 -
00000110 C.A. 1
00000111 C.A. 2 (7)
Il risultato 7, con il segno negativo poich il primo bit era 1: -7.
Bisogna chiedersi per se questi 16 bit (per esempio) sono sufficienti piuttosto che no a indirizzare la
memoria. In realt con 16 bit, rispetto un valore scritto in un registro, ci si pu spostare 215locazioni prima
o 215locazioni dopo. Per cui se si sta spaziando su una memoria a partire dal valore puntato dal registro di
spiazzamento, sommando questo immediato positivo o negativo ci si pu muovere su 215locazioni sopra o
215locazioni sotto rispetto a questo registro. Questi 16 bit sono sufficienti o sono pochi?. Se per esempio
questi sono pochi ci sono dei problemi, perch bisognerebbe pensare a un istruzione che sia pi lunga di 32
bit. Allora prima di capire se questi bit sono pochi o molti, si pu fare uno studio statistico e vedere quandosi effettua un accesso a memoria questo displaycement , di solito, quanto grande? Di solito lo quanto
lungo lo spostamento richiesto? E lo stesso, a maggior ragione, quando si dovranno eseguire delle istruzioni
di salto di tipo JUMP e di tipo BRANCH i quali prevedranno un codice operativo diverso.
5. Indirizzamento per le operazioni di salto
Un istruzioneJUMP effettua un salto ad un nuovo indirizzo di memoria senza nessuna condizione, non si
dovr codificare altro. Si avr a disposizione oltre al codice operativo una serie di bit per scrivere il valore di
quanto saltare.
-
7/23/2019 Calcolatori Elettronici (Biasi - Narracci - Albano)
33/216
23
Un istruzione BRANCHinvece necessita di una serie di bit oltre al codice operativo per codificare i termini
delloperazione logica da fare. Ad esempio se si vuole codificare un istruzione, un branch se R2 > R6,
bisogner mettere da parte tanti bit per scrivere R2 e tanti per scrivere R6. Quindi nei branch, solitamente i
bit che restano per specificare di quanto saltare sono di meno a differenza del JUMP dove si ha a
disposizione praticamente tutta listruzione a meno del codice operativo per codificare la lunghezza del
salto. Nei branch, invece, parte dellistruzione , oltre al codice operativo, deve essere sacrificata per
codificare su quali registri si sta facendo il test se saltare o meno.
E quindi anche qui avrebbe senso studiare quanto sono lunghi solitamente i salti di un istruzione JUMP o di
una istruzione BRANCH quando si usano software come SPICE, GCC o altri. Se per esempio ci si accorge di
avere salti di 266 locazioni bisogna trovare una soluzione! Una potrebbe essere quella di utilizzare un
istruzione di 71 bit, 5 per il codice operativo e 66 per fare il salto, per poi questi 71 bit sono uno spreco
quando le istruzioni rientrano in un numero pi ridotto. Per cui uno studio senzaltro utile quello che
viene in mente nel verificare questi numeri di bit di spiazzamento.
Un istruzione CALL effettua un salto incondizionato come la Jump, per a differenza della Jump che saltasemplicemente le istruzioni, la Call effettua un salto ma con un meccanismo di salvataggio della posizione
da dove si effettuato il salto. Viene memorizzato lindirizzo da dove viene eseguito il salto. Questo il
meccanismo per gestire le procedure, le subroutine. Quando si esegue una Call, viene chiamata una
procedura, vengono eseguite le istruzioni di questa, e quando termina lesecuzione del programma ritorna
allistruzione successiva alla Call.
Pu capitare che in un codice si possono avere pi chiamate a quella subroutine, bisogna prevedere una
istruzione di Call che funziona come una Jump, ma non si limita al semplice salto, dev e salvare lindirizzo
successivo dellistruzione di Call eseguita prima e che dovr essere gestito al termine della procedura
dallistruzione return. Lultima istruzione di una procedura la return che anchessa effettua un saltoincondizionato, salta allindirizzo che salvato quando stata eseguita la Call. Bisogna scrivere in un certo
registro speciale lindirizzo successivo allistruzione di Call.
Il problema di questo meccanismo nasce quando anche nella subroutine avviene un'altra chiamata ad
un'altra subroutine o quella subroutine stessa(ricorsione). Nella subroutine c una nuova Call ad un'altra
procedura che va a modificare nel registro lindirizzo di ritorno, quindi ora nel registro viene scritta la nuova
posizione dove ritornare dopo questa Call ma si perde la posizione precedente. Bisogna quindi, per ovviare
a questo problema, vincolare la subroutine a non fare altre chiamate a subroutine.
Un metodo migliore per gestire le Call/return scrivere i diversi indirizzi di ritorno in un area di memoria,
questarea di memoria, lo stack, deve essere organizzata con tipologia LIFO. Quando viene chiamata una
subroutine nello stack si va a memorizzare lindirizzo di ritorno, quando nella subroutine avviene un'altra
chiamata ad un'altra procedura viene salvato lindirizzo di ritorno nella cima dello stack, e cos via se ci sono
-
7/23/2019 Calcolatori Elettronici (Biasi - Narracci - Albano)
34/216
24
altre chiamate. Nelle operazioni di return, viene effettuato il salto allindirizzo in cima allo stack(lultimo
inserito) e cos via nelle return delle subroutine.
Possiamo avere anche 1000 registri in un processore, ma di questi se ne visualizzano 32 o 64 e gli altri
servono per gestire un meccanismo che viene chiamato Finestra di Registri. Per individuare un singolo
registro, tra 1000, avrei bisogno di 10 bit, e un istruzione che fa uso di 3 registri, avrebbe bisogno di soli 30bit per specificare 1000 registri. Non se ne utilizzano mai 1000 registri, di solito il valore di un registro viene
sovraccaricato dopo una operazione. Accedere a 1000 registri pi lento, bisogna connettere per esempio
un dato registro allALU(con un selettore multiplexer). Il cammino critico , il percorso che deve fare un
segnale in un circuito, dalla sorgente alla destinazione in un colpo di clock, se bisogna attraversare un
numero di gate di un selettore che ha molti ingressi molto pi lungo e si impiega pi tempo rispetto ad
uno che ne ha di meno. Si possono spezzettare i cammini critici in pi tappe e avere un clock che pu
andare pi velocemente, ma la latenza quella di attraversare un sistema: cercare una cosa tra poche cose
pi veloce che cercarla tra molte.
La Jump come la Call o come la return sono salti incondizionati. I branch sono invece salti condizionati chevengono effettuati quando sono verificate delle condizioni. Condizioni logiche su cui vengono impostati in
BRANCH. Queste condizioni da codificare sono istruzioni che possono essere calcolate molto velocemente.
Bisogna capire subito se si deve saltare una istruzione o meno. Le istruzioni di salto vanno gestite in
maniera molto pi veloce rispetto allesecuzione di un calcolo . Normalmente le istruzioni devono essere
eseguite uno dopo laltra, al termine di una viene eseguita la successiva. Per si pu pensare ad un
meccanismo in cui non si necessariamente vincolati a eseguire una istruzione dopo aver terminato la
precedente(parallelizzazione delle operazioni, pipeline). Istruzioni di questo genere possono essere iniziate
non necessariamente al termine dellistruzione precedente. Quando viene decodificata listruzione di
calcolo, questa pu durare del tempo intanto viene eseguita la successiva e nella peggiore delle ipotesi si
pu avere una dipendenza di questa istruzione con loperazione precedente. Nellistruzione di salto questo
calcolo sulla condizione deve essere fatto velocemente, perch finch non si deciso se saltare o meno non
possono essere eseguite le istruzione successive o quella nella posizione da saltare. Bisogna verificare le
condizioni nel modo pi velocemente possibile.
Set di istruzioni che codificano condizioni logiche:
EQUAL TO ==
NOT EQUAL TO !=
LESS THAN =
Una politica potrebbe essere quella di non implementare Greather Than perch questa operazione
effettuata da Less Than Or Equal To. Si possono implementare diverse situazioni per semplificare le
istruzioni.
-
7/23/2019 Calcolatori Elettronici (Biasi - Narracci - Albano)
35/216
25
Osservando la figura pag. 507, stata tracciata la frequenza dove certi bit di spiazzamento sono richiesti.
Per esempio 5 bit di spiazzamento nel 10 % dei casi e via dicendo. Il grafico arriva fino a 16 perch i
programmi alla fine considerano le istruzioni di salto realmente implementate solo con 16 bit. Questo non
significa che si possono fare dei salti da una locazione a N locazioni pi in l dove log 2N superiore a 16.
Una volta affidato al campo immediato un numero di bit , 16 come abbiamo detto, come si risolve il
problema di saltare invece che di 215locazioni in avanti (16 significa 215locazioni pi avanti e 215locazioni
indietro) ma di 228locazioni pi in l ad esempio? Servirebbero altri 13 bit che non possono essere inseriti
perch non si posso fare istruzioni pi lunghe. Per risolvere questo problema possiamo pensare a llatletica!
Se si vogliono saltare pi di 8 metri e mezzo bisogna fare un salto triplo! Quindi qualora serve realmente
spostarsi di 228locazioni pi in l, bisogna fare un salto di 215locazioni, e inserire nellistruzione 215 un'altra
istruzione di salto fino alla locazione di destinazione. Questultima istruzione di salto non condizionata.
Perch la condizione stata verificata, se era necessaria, nella prima istruzione di salto(quella di 215).
Essendo una jump questultima istruzione di salto potrebbe avere uno spiazzamento per indicare il salto ad
esempio di 26 bit. Quindi sufficiente nellistruzione di salto che vuole saltare di 228 locazionipi in l, fare
un salto di 2
15
e scrivere in questultima locazione un istruzione di salto anche incondizionato che ci proiettain un altro punto dellesecuzione. Nasce un secondo problema con questa soluzione, a seconda istruzione
di salto che inserita (dopo le 215 locazioni) viene raggiunta non solo dal primo salto ma potrebbe essere
raggiunta anche con il normale corso delle istruzioni (passo passo). Prima o poi verr raggiunta listruzione
questa istruzione di salto che effettuer un salto pi avanti senza volerlo. Si dovr inserire un altro jump,
esattamente prima dellistruzione di salto in questione , che salti questultima e quindi evitandola e che ci
riporti esattamente allistruzione successiva in modo da permettere la regolare esecuzione delle istruzioni.
Questo un altro studio che invece prende in considerazione le istruzioni, le divide in due categorie: le
LOAD e le operazioni della ALU. Verifica pi o meno com landamento relativamente a un programma che
fa uso sia di numeri floating point che ad aritmetica intera perch quando studieremo il processore
ampliando lorizzonte alla parte del processore che opera sui dati floating point ci accorgeremo che il
processore pu essere diviso in due moduli:
- Uno che opera sulle istruzioni che fanno riferimento a dati interi
-
Uno che opera sulle istruzioni che fanno riferimento a dati floating point
Le parti di logica che fanno i calcoli sono diverse, lhardware che permette di eseguire la somma di due
interi non la stessa che permette la somma di due floating point. La somma floating point prevede un
confronto fra le mantisse, lallineamento ecc. ecc. . Per cui lhardware fisicamente distinto allora
prendendo in esame le istruzioni che hanno a che fare con le operazioni floating point e le istruzioni che
hanno a che fare con i dati ad aritmetica fissa vediamo questo tipo di statistica di un benchmark che fa uso
-
7/23/2019 Calcolatori Elettronici (Biasi - Narracci - Albano)
36/216
26
di floating point. Se si osserva la figura, e ci si focalizza sulle operazioni che hanno a che fare con i dati ad
aritmetica intera, un quarto sono operazioni aritmetico logico.
Quando si effettua una LOAD, il 23% di queste usano un dato immediato che per esempio l indirizzo.
Nelle operazioni ALU, il 25% usano un dato immediato, quindi loperazione che prevede due operandi: un
operando un registro, laltro non in un registro ma in un immediato. Il compilatore quando ha tradottoquellistruzione gi sapeva qualera un operando, non doveva prenderlo da un registro. Ad esempio
tipicamente in un contatore di un loop ,i++, non ha senso mettere 1 in un registro, ad esempio R6, mettere
i in un altro registro, ad esempio R7, e ogni volta fare R7+R6 cos occupo un registro R6. Sapendo invece
che a R7 va sommato sempre 1, il compilatore nello scrivere quellistruzione scriver unistruzione di
somma con immediato, quindi scriver nellistruzione stessa il numero 1 come operando immediato ed R6.
Quindi scriver unistruzione che fatta da un codice operativo che non significa somma ma significa
somma con immediato. E poi ci sar per esempio R6, e poi limmediato 1, a significare che R6 va sommato
al numero 1 e il risultato va sempre in R6.
6. Operazioni Nellinsieme Di Istruzioni
Abbiamo accennato che i dati sono anchessi nel loro formato una caratteristica che diversifica il
processore. Quindi per esempio abbiamo dati che a partire dal singolo byte possono essere raggruppati in
categorie che comprendono le wordda 4 byte e le doppie wordda 8 byte. Esiste anche una via di mezzo le
half wordda 16 byte. Questi dati vengono effettivamente usati. Osservando la figura pag. 510, per quanto
riguarda i dati floating point, la gran parte delle operazioni riguarda dati floating point di tipo doppia word
per una certa applicazione. Questo studio serve a definire se importante considerare un ALU a 64 bit
perch per esempio se si fa in modo di trattare i dati da 64 bit come dati da 32 bit si pu pensare ad unaALU da 32 bit(prima fa il calcolo su 32 della parola e poi sugli altri 32 bit). Se invece si deve fare la somma di
due dati da 64 bit ma lALU da 32 bit si pu decidere che tutte le volte bisogna fare somme di dati da 64
bit si divide il dato in due parti da 32 e 32, e si esegue la somma di una parte e poi dellaltra e precisamente
si far la somma ovviamente prima delle due parti meno significative. Questa somma eventualmente
generer un riporto che si aggiunger alla somma delle due parti pi significative. Avendo un ALU di 32 bit
necessario eseguire in pratica due calcoli. Questa soluzione ottima fintantoch mi accorgo che dati da 64
bit con cui fare i calcoli non sono molti. Purtroppo si nota dalla figura che nel 60 % dei casi bisogna fare
calcoli con dati da 64 bit, allora ci si pone la domanda se ha senso progettare un ALU da 64 bit per fare in un
colpo solo quello che si effettuava in due colpi. Si ha senso.
Le stesse considerazioni fatte per lALU si possono fare per i registri: devono essere di 32 bit o 64 bit? Se si
pensa a una aritmetica(ALU) di 32 bit che alloccorrenza fa anche calcoli da 64 bit, i registri saranno di 32 bit
e quando si ha bisogno di dati da 64 bit verranno utilizzati due registri contigui. Ma questa coppia di registri
pu essere R7 e R17 per esempio? Teoricamente si, per comporta dei problemi;
Nellistruzione bisogner specificare R7 e R17, che contengono le due parti di un dato, poi si avr bisogno di
specificare altri due registri che contengono le parti del secondo dato, esempio R5 ed R19, ed infine si
bisogner specificare i due registri per contenere le due parti del risultato, R8 e R21 ad esempio. Sono
necessari 6 slot per indicare gli operandi. Se i registri sono contigui invece baster specificare R7, perch il
secondo pezzo sar R8; baster specificare R9, perch la seconda parte si trova in R10; ed infine per ilrisultato baster specificare R2 perch la seconda parte sar R3.
-
7/23/2019 Calcolatori Elettronici (Biasi - Narracci - Albano)
37/216
27
Un altro problema che si verifica utilizzando registri non contigui nasce quando bisogna connettere alla
parte che fa i calcoli, i due registri. Lunit di controllo diviene molto complessa.
Quindi a fronte di una massima flessibilit, che porterebbe a desiderare la libert di mettere quei 64 bit in
due registri a piacere, le cose si complicano sia dal punto di vista delle connessioni verso le unit di calcolo
e soprattutto nella strutturazione di un istruzione che dovr prevedere 6 specifiche.
-
7/23/2019 Calcolatori Elettronici (Biasi - Narracci - Albano)
38/216
28
-
7/23/2019 Calcolatori Elettronici (Biasi - Narracci - Albano)
39/216
29
CAPITOLO 5ISTRUZIONI DEL PROCESSORE MIPS
Il processore di riferimento il processore MIPS. sviluppato con filosofia RISC, ha un numero ridotto diistruzioni ma che hanno tutte una struttura molto simile tra di loro. Inoltre un processore di tipo Load-
Store, le uniche operazioni che possono accedere a memoria sono le istruzioni LOAD e STORE.
Il processore MIPS costituito da 32 registri interi da 64bit di utilizzo generale ( GPR, general-purpos
register), denominati R0, R1,, R31. Ci sono inoltre registri per numeri in virgola mobile (FPR, floating-point
register), denominati F0,F1,,F31.E infine c anche un piccolo numerodi registri speciali.
I tipi di dati presenti sono: byte(8bit), half word(16bit), word(32bit) e double word (64bit).
Esistono solo due modalit di indirizzamento, immediato e con scostamento.
Le istruzioni di questo processore sono di 32 bit e presentano tutte un codice operativo costituito da 6 bit.
Le istruzioni sono fondamentalmente di tre tipi: tipo R, tipo Ie tipo J.
1. Istruzioni di tipo J
Le istruzioni di tipoJprevedono una struttura semplice, oltre ai 6 bit del codice operativo, i rimanenti 26 bit
codificano un immediato, lindirizzo dove saltare. Larchitettura prevede indirizzi di 32 bit, quei 26 bit non
sono un indirizzo assoluto, ma sono un offset ovvero uno spiazzamento che va sommato al Program
Counter(PC).
Oltre ai comuni registri di un processore, ne esistono degli altri, chiamati registri speciali o dedicati perchnon contengono dati generici, ma dati che hanno un determinato significato. Uno di questi il PROGRAM
COUNTER (PC). Il PC un registro che contiene lindirizzo dellistruzione da eseguire. Quando viene eseguita
una istruzione serve sapere lindirizzo di questa per prelevarla e il processore conosce questo indirizzo
attraverso il PC. Quando termina una istruzione e se ne deve prelevare un'altra, il PC contiene listruzione
successiva a quella eseguita grazie a un aggiornamento che viene fatto durante lesecuzione di una
istruzione. Se PC=16byte, viene eseguita listruzione al byte 16, e considerando istruzioni istruzione di 4
byte (32bit), al termine di questa istruzione, viene incrementato il PC, PC=PC+4=16+4 = 20byte, verr
eseguita listruzione al byte 20. Durante lesecuzione di una istruzione oltre a fare quello che listruzione
richiede bisogna aggiornare il Program Counter. Necessariamente ogni volta che verr eseguita una
istruzione oltre a essere compiuto quello che listruzione richiede bisogna aggiornare il PC. Se le istruzioni
hanno tutte la stessa lunghezza, lunghezza fissa, loperazione facilitata. Un conto aggiornare il PC senza
sapere dove listruzione successiva, perch quella in corso ora ad esempio di 8 byte, e quindi bisogna
aggiornare di 8byte questa volta il PC, mentre listruzione successiva magari di 15 byte e quindi bisogner
aggiornare di 12 byte il PC.
Ritornando allistruzione di salto, questa scrive un nuovo valore nel PC, scrive il valore del nuovo indirizzo
dove saltare nel PC. Listruzione non pu contenere tutti i 32 bit dellindirizzo dove saltare perch se ne
hanno a disposizione al massimo 26 di bit nel caso di una jump. I 26 bit contengono uno spiazzamento di
quanto bisogna spostarsi dallistruzione attuale, dal PC. Ad esempio se listruzione corrente si trova
allindirizzo 90 e bisogna saltare allistruzione 150, bisogner scrivere nei 26 bit il valore 60, scopriremo chebisogner scrivere 56 perch si dar per scontato che il PC si gi incrementato di 4 byte. I salti che
-
7/23/2019 Calcolatori Elettronici (Biasi - Narracci - Albano)
40/216
30
vengono effettuati sono tutti multipli di 4 gli indirizzi si spostano di 4 in 4, visto che le istruzioni sono di 4
byte. I multipli di 4 in binario terminano con 2 zeri, gli ultimi due bit valgono zero. Si pu pensare che quei
26 bit contengono lindirizzo privato dei due zeri finali(risparmio 2 bit): 12 = 1100 => 11 = 3, scrivendo 3 (11)
ci si sta riferendo a 12(1100). Si hanno a disposizione quindi 28bit. Inoltre se il valore positivo il salto
avviene in avanti, altrimenti indietro.
2. Istruzioni di tipo R
Le istruzioni di tipo Rsono istruzioni che prevedono luso di 3 operandi di tipo registro, due operandi sono
di input e 1 operando di output: due sorgenti e una destinazione. Ricordiamo che questa una macchina
Load-Store in cui le uniche operazioni che accedono a memoria sono le Load e le Store, mentre le
operazioni aritmetiche non accedono a memoria. Larchitettura ha un certo numero di registri, ma la
visibilit solo su 32 registri, gli altri servono per la Finestra di Registro. Sono necessari allora 5 bit per
codificare un registro, poich listruzione specifica 3 registri, servono 15 bit per i registri, in sostanza 6 + 3*5= 21, gli altri 11 bit sono utilizzati per altre informazioni, se i dati sono con segno senza segno.
3. Istruzioni di tipo I
Il tipo Iprevede una struttura in cui un operando un immediato e gli altri due sono registri: 6 + 2*5 = 16bit
i restanti 16bit sono utilizzati per limmediato. Uno scenario quello in cui degli operandi sono noti.
Essendo la macchina Load-Store non si pu prelevare un operando dalla memoria attraverso un operazione
aritmetico logica, quindi gli operandi o sono tutti nei registri o qualcuno un termine noto. Solo un
operando per deve essere un termine un noto(due operandi termini noti non ha senso). Deve esisterequindi un solo immediato come sorgente non come destinazione(altrimenti si sta risolvendo una
equazione!). Il codice operativo della somma con immediato diverso dallistruzione somma senza
immediato. E il codice operativo che indica se listruzione di tipo R o di tipo I