Livello di micro-architettura

Microarchitettura
Giacomo Fiumara
[email protected]
Anno Accademico 2014-2015
1 / 101
Introduzione
2 / 101
Introduzione
Il livello di micro-architettura implementa le funzioni del livello
sovrastante ISA (Instruction Set Architecture)
La progettazione del livello di micro-architettura dipende
pertanto dall'ISA che si vuole implementare (tenendo in
considerazione costi e prestazioni)
Alcuni livelli ISA (in particolare le piattaforme RISC) hanno
istruzioni semplici che possono essere eseguite in un solo ciclo
di clock
Altri livelli ISA, come quello del Core i7, possono richiedere più
cicli per l'esecuzione di una singola istruzione
L'esecuzione di un'istruzione può richiedere (di norma)
l'identicazione degli operandi in memoria, la loro lettura,
l'esecuzione vera e propria, la memorizzazione dei risultati in
memoria
3 / 101
Introduzione
Il livello ISA è caratterizzato dall'assenza di uno schema
generale applicabile a tutte le piattaforme
Pertanto è necessario trattare un esempio particolare
A tale scopo è stato scelto un sottoinsieme della Java Virtual
Machine, in particolare quella preposta alla manipolazione dei
numeri interi
Questo sottoinsieme prende il nome di IJVM (Integer Java
Virtual Machine)
4 / 101
Introduzione
La micro-architettura in esame conterrà un microprogramma il
cui compito consiste nell'eseguire le operazioni di
decode
ed
execute
fetch,
delle operazioni IJVM
Il microprogramma presenta un insieme di variabili, che
denisce lo
stato
del computer, che possono essere accedute
da tutte le funzioni: ogni funzione modica almeno una di
queste variabili
Per esempio, il Program Counter (PC) fa parte dello stato:
indica la locazione di memoria contenente la prossima funzione
(istruzione ISA) da eseguire
5 / 101
Datapath
6 / 101
ALU
7 / 101
Shifter
8 / 101
Sommatore
9 / 101
Registro
10 / 101
Datapath
11 / 101
Datapath
Il
datapath
è quella parte della CPU che contiene la ALU, i
suoi input e i suoi output
Il datapath dell'architettura in studio è abbastanza simile a
quello utilizzato nella maggior parte delle architetture
Contiene alcuni registri a 32 bit
Alcuni di essi possono inviare i loro contenuti sul bus B, altri
ricevono dati dal bus C
I dati presenti sul bus C possono essere scritti su più registri
contemporaneamente
12 / 101
Datapath
13 / 101
Datapath: segnali di controllo
Segnali di controllo della ALU
F0
F1
ENA
ENB
INVA
INC
Segnali di controllo dello
shifter
SLL8
SRA1
14 / 101
Datapath
Input della ALU
Contenuto del registro H
Segnale proveniente dal
registro B
Incremento di SP:
Valore di SP sul bus B
Disattivare l'input sinistro
della ALU
Attivare il segnale INC
memorizzare il risultato in
SP
15 / 101
Datapath: temporizzazione
16 / 101
Datapath: temporizzazione
Impostazione dei segnali per guidare il datapath (∆
w)
x
Impostazione del registro H e del bus B (∆ )
y
Esecuzione delle operazioni nella ALU e nello shifter (∆ )
z
Propagazione dei segnali dallo shifter ai registri (∆ )
17 / 101
Datapath: operazioni della memoria
Porte di comunicazione con la
memoria
Porta a 32 bit (controllata
dai registri MAR e MDR)
Porta a 8 bit (controllata
dal registro PC che legge
il byte meno signicativo
di MBR)
18 / 101
Datapath: operazioni della memoria
Registri MAR/MDR:
lettura/scrittura parole di
dati
Registri PC/MBR: lettura
programma eseguibile
Il registro MBR può contenere
istruzioni o dati (da estendere
da 8 a 32 bit, con segno o
meno)
19 / 101
Datapath: operazioni della memoria
Il registro MAR contiene
indirizzi espressi in parole
(i valori 0, 1, 2,
...
si
riferiscono a parole
consecutive)
il registro PC contiene
indirizzi espressi in byte (i
valori 0, 1, 2,
...
si
riferiscono a byte
consecutivi)
20 / 101
Datapath: operazioni della memoria
Assegnare il valore 2 al
registro MAR e avviare una
lettura in memoria signica
leggere i byte 811 (la parola
2) e scriverli sul registro MDR
Assegnare il valore 2 al
registro PC e avviare una
lettura in memoria signica
leggere il byte 2 dalla memoria
e scriverlo sugli 8 bit meno
signicativi di MBR
21 / 101
Datapath: operazioni della memoria
Questa dierenza di
comportamento è dovuta al fatto
che MAR e PC accedono a parti
(semanticamente) dierenti della
memoria
La combinazione MAR/MDR
viene usata per leggere/scrivere
parole di dati del livello ISA
La combinazione PC/MBR
viene usata per leggere il
programma eseguibile al livello
ISA, che consiste di un usso di
byte
Tutti gli altri registri che
contengono indirizzi si
comportano come MAR
22 / 101
Datapath: operazioni della memoria
Nelle implementazioni reali esiste un solo tipo di memoria
(orientata al byte)
Per consentire al registro MAR di contare in parole si opera come
in gura:
Si scartano i due bit più signicativi di MAR
Si eettua uno shift verso sinistra di due bit
Si inseriscono due zeri nei bit meno signicativi di MAR
23 / 101
Datapath: operazioni della memoria
I dati letti dalla memoria mediante la port di memoria a 8 bit
vengono scritti sul registro MBR
Il contenuto di MBR può essere copiato sul registro B con
segno o senza segno
Con segno: gli 8 bit di MBR possono essere considerati come
un numero compreso tra -128 e +127. Il segno (bit più
signicativo tra gli 8 di MBR) viene
esteso duplicandolo 24
volte
Senza segno: i 32 bit scritti sul bus B si compongono degli 8
bit letti da MBR (meno signicativi) e di zeri nei restanti bit
più signicativi
La scelta se convertire gli 8 bit di MBR in un valore a 32 bit
con o senza segno viene determinato da quale dei due segnali
di controllo viene settato
24 / 101
Microistruzioni
Il controllo del datapath
richiede 29 segnali:
9 per controllare la scrittura
dei dati dal bus C ai registri
9 per controllare la scrittura
dei dati sul bus B dai registri
8 per il controllo delle
funzioni di ALU e shifter
2 per indicare gli accessi alla
memoria (R/W) mediante i
registri MAR/MDR
1 per indicare il fetch dalla
memoria mediante i registri
PC/MBR
25 / 101
Microistruzioni
Il valore di questi 29 segnali di controllo specica le operazioni di
un ciclo del datapath
Un ciclo consiste nel:
Copiare i valori dai registri sul bus B
Propagare i segnali lungo la ALU e lo shifter
Dirigerli sul bus C
Scrivere i risultati sul/i registro/i appropriato/i
26 / 101
Microistruzioni
Inoltre, se viene asserito un segnale di lettura dati dalla memoria,
l'operazione di lettura viene avviata soltanto al termine del ciclo del
datapath, quando l'indirizzo è stato caricato sul registro MAR
I dati della memoria sono disponibili al termine del ciclo
successivo
nel registro MBR o MDR e possono essere usati nel
ciclo ancora successivo
Questo signica che una lettura dalla memoria avviata al termine
del ciclo
k +2
k
produce dati che saranno disponibili soltanto nel ciclo
27 / 101
Microistruzioni
28 / 101
Microistruzioni
Addr
JAM
ALU
C
Mem
B
Contiene l'indirizzo di una potenziale prossima
istruzione
Modalità di selezione della prossima istruzione
Selezione della funzione della ALU e dello shifter
Selezione dei registri sui quali copiare il contenuto del
bus C
Selezione della funzione della memoria
Selezione del registro dal quale scrivere sul bus B
29 / 101
Mic-1
30 / 101
Controllo delle microistruzioni
Quali segnali di controllo debbano essere abilitati ad ogni ciclo
viene stabilito da un
sequencer
Si tratta di un dispositivo incaricato di far avanzare passo-passo la
sequenza di istruzioni per l'esecuzione di ogni singola istruzione ISA
Il sequencer deve produrre due tipi di informazione ad ogni ciclo:
Lo stato di ogni segnale di controllo nel sistema
L'indirizzo della prossima microistruzione da eseguire
31 / 101
Memoria di controllo
La
memoria di controllo
contiene l'intero microprogramma
Si tratta di un dispositivo che contiene 512 parole, ognuna
consistenti di una microistruzione di 36 bit, aventi la struttura:
32 / 101
Memoria di controllo
La
memoria di controllo
ha bisogno di un registro di indirizzo e
di un registro dei dati
MPC (MicroProgram Counter), anche se non si tratta di un
contatore perché le microistruzioni non possono essere
disposte in modo sequenziale
MIR (MicroInstruction Register), che contiene la
microistruzione corrente i cui bit determinano i segnali di
controllo che pilotano il datapath
33 / 101
Mic-1
34 / 101
Memoria di controllo
Ciclo delle operazioni
All'inizio di ogni ciclo di clock (sul fronte di discesa), MIR
viene caricato dalla parola nella memoria di controllo puntata
da MPC (tempo
∆w )
Una volta che la microistruzione viene caricata in MIR, i vari
segnali si propagano lungo il datapath: il contenuto di un
registro viene copiato sul bus B, la ALU sa quale operazione
deve essere eseguita
35 / 101
Memoria di controllo
Ciclo delle operazioni /2
Il tempo necessario ad eseguire queste operazioni è indicato da
∆x ;
dopo un tempo
Dopo un intervallo
∆w + ∆ x
∆y
gli input della ALU sono stabili
sono stabili gli output della ALU, dello
shifter e dei valori di N e Z
36 / 101
Memoria di controllo
Ciclo delle operazioni /3
I valori di N e Z vengono memorizzati in due memorie ad un
bit (una coppia di ip-op)
Dopo un intervallo
∆z
l'output dello shifter raggiunge i registri
lungo il bus C
37 / 101
Memoria di controllo
Ciclo delle operazioni /4
Parallelamente alla guida del datapath, il microprogramma
deve determinare la microistruzione successiva da eseguire (che
non è necessariamente quella che segue la microistruzione
corrente nella memoria di controllo)
Il calcolo dell'indirizzo della microistruzione successiva avviene
dopo che MIR è stato caricato ed è stabile
Dapprima il campo NEXT_ADDRESS viene copiato in MPC
Successivamente viene esaminato il campo JAM: se contiene il
valore 0 non è richiesto alcun intervento perché la
microistruzione successiva sarà quella che segue la
microistruzione corrente
38 / 101
Memoria di controllo
Ciclo delle operazioni /5
Se invece uno o più dei bit di JAM sono settati a 1 si possono
vericare diverse azioni
Se
N
JAMN
è settato, viene calcolato l'OR logico con il ip-op
Analogamente, se
con il ip-op
Z
JAMZ
è settato, viene calcolato l'OR logico
Se risultano settati entrambi, si calcola l'OR rispetto ad
entrambi
39 / 101
Memoria di controllo
Ciclo delle operazioni /6
40 / 101
Memoria di controllo
Ciclo delle operazioni /7
F = ( JAMZ AND Z ) OR ( JAMN AND N ) OR NEXT_ADDRESS
[8]
MPC può assumere uno solo dei due possibili valori:
NEXT_ADDRESS
NEXT_ADDRESS con il bit più signicativo in OR con 1
41 / 101
Memoria di controllo
Ciclo delle operazioni /8
Quando tutti i bit di JAM valgono zero, l'indirizzo della
microistruzione successiva è semplicemente il numero a 9 bit
nel campo NEXT_ADDRESS
Quando invece JAMN o JAMZ valgono 1, ci sono due
potenziali microistruzioni successive: NEXT_ADDRESS
x
oppure NEXT_ADDRESS in OR con 0 100
42 / 101
Memoria di controllo
Ciclo delle operazioni /9
Il terzo bit del campo JAM è JMPC
Se è settato, gli 8 bit di MBR vengono posti in OR (bit a bit)
con gli 8 bit meno signicativi di NEXT_ADDRESS prelevati
dalla microistruzione corrente; il risultato viene inviato a MPC
Il dispositivo indicato con O eettua un OR di MBR con
NEXT_ADDRESS se JMPC vale 1, ma invia
NEXT_ADDRESS a MPC se JMPC vale zero
Questo permette di implementare una diramazione,
specicando uno dei 256 possibili indirizzi
43 / 101
Ciclo delle operazioni /10
44 / 101
Stack
Praticamente tutti i linguaggi di programmazione supportano il
concetto di procedura (con un insieme di variabili locali)
Queste variabili possono essere accedute soltanto dalla
procedura in cui sono denite e cessano di esistere al termine
della procedura
La gestione di queste variabili viene eettuata mediante
un'area di memoria chiamata
stack
riservata alle variabili
Vi si accede mediante un registro chiamato LV che punta alla
base delle variabili locali della procedura corrente, mentre il
registro SP punta alla parola in cima allo stack (in eetti
contiene l'indirizzo di memoria della variabile il cui contenuto è
stato copiato nello stack)
45 / 101
Stack /2
46 / 101
Stack /3
In Figura (a) viene invocata una procedura, chiamata A, che
istanzia tre variabili locali,
a1 , a2 e a3
Successivamente (Figura (b)), all'interno della procedura A è
presente l'invocazione alla procedura B, che istanzia quattro
variabili locali,
b1 , b2 , b3 e b4
47 / 101
Stack /4
In Figura (c), all'interno della procedura B viene invocata la
procedura C che provvede ad istanziare due variabili locali,
c2
c1
e
Inne (Figura (d)), le procedure C e B hanno completato la
loro esecuzione, le loro variabili locali sono state distrutte e
all'interno della procedura A è stata invocata una nuova
procedura, chiamata D, che ha provveduto ad istanziare le
variabili locali
d1 , d2 , d3 , d4 e d5
48 / 101
Stack /5
Stack degli operandi
Oltre ad ospitare le variabili locali, lo stack contiene gli
operandi delle espressioni aritmetiche
Si consideri ad esempio l'operazione
a1 = a2 + a3
49 / 101
Modello di memoria
La memoria della macchina IJVM (4 GB) può essere considerata
come un array di 4.294.967.296 byte oppure come un array di
1.073.741.824 parole di 4 byte
Al livello ISA, la JVM non rende disponibile alcun indirizzo di
memoria assoluto, soltanto degli indirizzi impliciti che forniscono il
punto di partenza per dei puntatori: è il caso, per esempio dei
puntatori PC (Program Counter), il registro che contiene l'indirizzo
dell'istruzione successiva da eseguire
50 / 101
Modello di memoria /2
Sono denite le seguenti aree di memoria:
Constant pool (porzione costante): contiene costanti, stringhe,
puntatori e non è modicabile (vi si può accedere soltanto in
lettura)
Local variable frame (blocco delle variabili locali): contiene le
variabili locali allocate al momento dell'invocazione di una
procedura. Contiene anche i parametri con cui il metodo è
stato invocato
Operand stack (stack degli operandi)
Method area (area dei metodi): contiene il programma. Il
registro PC contiene l'indirizzo dell'istruzione successiva da
prelevare
51 / 101
Modello di memoria /3
52 / 101
Insieme delle istruzioni IJVM
53 / 101
Insieme delle istruzioni IJVM /2
Esempio applicativo
54 / 101
Insieme delle istruzioni IJVM /3
Inserimento nello stack di una parola proveniente da:
porzione costante di memoria (LDC_W)
blocco variabili locali (ILOAD)
istruzione stessa (BIPUSH)
Inserimento nel blocco delle variabili locali di una parola
proveniente da:
stack (ISTORE)
55 / 101
Insieme delle istruzioni IJVM /4
Operazioni logiche e aritmetiche:
IADD, ISUB
IAND, IOR
sugli operandi che si trovano in cima allo stack (il risultato viene
posto in cima allo stack, al posto della penultima parola)
Operazioni per i salti:
GOTO (salto incondizionato)
IFEQ, IFLT, IF_ICMPEQ
modicano il valore di PC in base al valore di
oset
56 / 101
Insieme delle istruzioni IJVM /5
Operazioni sugli operandi in cima allo stack:
scambio di due parole (SWAP)
duplicazione di una parola (DUP)
rimozione di una parola (POP)
Invocazione di un altro metodo:
oset]
INVOKEVIRTUAL [
Terminazione di un metodo:
IRETURN
57 / 101
Insieme delle istruzioni IJVM
Invocazione di una procedura
La procedura chiamante carica sulla stack un riferimento alla
procedura chiamata (OBJREF)
Successivamente, carica i parametri della procedura
A questo punto viene eseguita INVOKEVIRTUAL
58 / 101
Insieme delle istruzioni IJVM
Invocazione di una procedura /2
INVOKEVIRTUAL richiede un argomento,
disp (displacement)
che indica la posizione nel constant pool che contiene
l'indirizzo di inizio nell'area dei metodi per la procedura
chiamata
In eetti l'indirizzo iniziale nell'area dei metodi non coincide
con l'indirizzo del primo opcode della procedura
I primi due byte (interpretati come un intero a 16 bit) indicano
il numero di parametri della procedura
Altri due byte indicano la dimensione dell'area delle variabili
locali della procedura chiamata (necessaria per il
dimensionamento dello stack della procedura chiamata)
Il quinto byte dell'area dei metodi contiene il primo opcode da
eseguire
59 / 101
Insieme delle istruzioni IJVM
Invocazione di una procedura /3
60 / 101
Insieme delle istruzioni IJVM
Invocazione di una procedura /4
Due informazioni fondamentali per il corretto funzionamento
di una procedura (chiamante o chiamata) sono contenute nei
registri PC e LV
E' necessario salvare lo stato di questi registri allo scopo di
ripristinare l'esecuzione della procedura chiamante (al termine
della procedura chiamata) e avere i corretti riferimenti nello
stack
I primi quattro byte prelevati dall'area dei metodi della
procedura chiamata servono a calcolare la prima parola di
memoria libera dello stack può essere usata
A partire dalla prima parola libera dello stack vengono salvati i
contenuti dei registri PC e LV della procedura chiamante (in
quest'ordine)
61 / 101
Insieme delle istruzioni IJVM
Invocazione di una procedura /5
La parola precedentemente utilizzata per allocare OBJREF
viene utilizzata per salvare un puntatore (link) alla parola che
contiene il PC della procedura chiamante, e il suo indirizzo
viene salvato nel registro LV
A partire da adesso indica l'indirizzo iniziale dello stack della
62 / 101
Insieme delle istruzioni IJVM
Invocazione di una procedura /6
Il valore di SP viene aggiornato alla parola dello stack che
contiene il registro LV della procedura chiamante
Il valore di PC viene aggiornato al quinto byte dell'area dei
metodi (prima vera istruzione della procedura chiamata)
63 / 101
Insieme delle istruzioni IJVM
Ritorno da una procedura
64 / 101
Insieme delle istruzioni IJVM
Ritorno da una procedura /2
L'istruzione IRETURN inverte le operazioni di
INVOKEVIRTUAL
Dealloca lo spazio utilizzato dalla procedura in rientro
Ripristina lo stack allo stato precedente l'invocazione della
procedura
65 / 101
Insieme delle istruzioni IJVM
Ritorno da una procedura /3
IRETURN deve ripristinare i puntatori PC e LV al loro valore
originario
Questo viene eettuato accedendo al puntatore link
Il valore di ritorno (solitamente il risultato del calcolo eseguito
nella procedura) viene copiato dalla cima dello stack al
puntatore link
Il registro SP viene aggiornato a puntare a questa locazione
Una volta ripristinato il valore originario di PC, l'esecuzione
prosegue con la prima istruzione successiva a
INVOKEVIRTUAL
66 / 101
Microistruzioni
Dopo la descrizione della microarchitettura e della
macroarchitettura è la volta dell'implementazione
Ovvero, bisogna descrivere il programma che viene eseguito
sulla microarchitettura e che interpreta la macroarchitettura
Le istruzioni potrebbero essere scritte in binario, 36 bit per
parola
E' decisamente vantaggioso introdurre una notazione sintetica
In altre parole: l'elenco dei segnali che devono essere attivati
ad ogni ciclo di clock viene sostituito con una istruzione
sintetica che illustra l'operazione in corso
67 / 101
Microistruzioni
Le microistruzioni vengono descritte mediante un linguaggio di
alto livello, MAL (Micro Assembly Language), seguendo le
convenzioni:
Una riga di codice indica tutte le attività che hanno luogo
durante un ciclo di clock
Durante ogni ciclo:
Un registro è collegato al bus B
Il registro H è collegato ad uno dei due ingressi della ALU
possono essere scritti uno o più registri ad opera del bus C
L'operazione da eseguire viene indicata con il simbolo di
assegnazione (=)
68 / 101
Microistruzioni
Per esempio, in un ciclo si desidera incrementare il valore di SP e
iniziare una lettura
L'istruzione corrispondente può essere scritta come:
SP = SP + 1; rd
69 / 101
Microistruzioni
Operazioni fondamentali di MAL:
Assegnazione
Inizio lettura/scrittura da/in memoria
Istruzioni di salto
70 / 101
Microistruzioni
71 / 101
Microistruzioni
SOURCE può essere uno
qualsiasi dei registri MDR, PC,
MBR, MBRU, SP, LV, CPP,
TOS, OPC
DEST può essere uno qualsiasi
dei registri MAR, MDR, PC,
SP, LV, CPP, OPC, H
72 / 101
Microistruzioni
Operazioni tipiche
MDR = SP (copia del contenuto di SP in MDR)
MDR = H + SP (addizione del contenuto di H e SP, scrittura
della somma in MDR)
Sono lecite soltanto le operazioni che possono essere realizzate
tramite il percorso dati
MDR = SP + MDR
non
è valida perché uno dei due operandi
deve essere contenuto nel registro H
73 / 101
Microistruzioni
Operazioni tipiche
H = H MDR
non
è valida perché H può contenere soltanto
il sottraendo
H = MDR H è valida
Il risultato di un'operazione logica o aritmetica può essere
assegnato a più registri:
SP = MDR = SP + 1
74 / 101
Microistruzioni
Operazioni tipiche
L'inizio di un'operazione di lettura/scrittura si indica con
rd/wr
Il prelievo di un byte si indica con
fetch
Le due operazioni possono avveenire in modo simultaneo, ma
lo stesso registro non può contenere dati provenienti dalla
memoria e dal datapath nello stesso ciclo
Assegnazioni e operazioni in memoria possono svolgersi
durante lo stesso ciclo, basta indicarle sulla stessa linea di
codice (per esempio, MAR = SP; rd)
Ogni istruzione contiene esplicitamente l'indirizzo
dell'istruzione seguente: di norma istruzioni consecutive
vengono eseguite in sequenza (tranne che per le diramazioni)
75 / 101
Microistruzioni
Operazioni tipiche
I salti incondizionati vengono indicati con la notazione
label
goto
I salti condizionati richiedono invece una notazione dierente
perché dipendono dallo stato dei bit Z e/o N:
se Z = 1, l'output della ALU è zero
se N = 1, l'output della ALU è negativo
I salti condizionati vengono eettuati se la parola in cima allo
stack è negativa oppure nulla. La verica di ciò viene fatta
facendo passare la parola dalla ALU: se negativa il bit N
risulterà settato, così come verrà settato il bit Z se la parola è
nulla
L'istruzione che verica se una parola è zero è:
Z = TOS
76 / 101
Microistruzioni
Operazioni tipiche
Un salto condizionato al valore di un generico registro R viene
eettuato come:
Z = R; if ( Z) goto label1 else goto label2
N = R , if ( N) goto label1 else goto label2
Il risultato consiste nell'impostazione dei bit JAMZ oppure JAMN
77 / 101
Microistruzioni
78 / 101
Implementazione di IJVM con Mic-1
IADD
Sostituisce le due parole in cima allo stack con la loro somma
Main1
iadd1
iadd2
iadd3
PC = PC + 1; fetch ; goto ( MBR )
MAR = SP = SP - 1; rd
H = TOS
MDR = TOS = MDR + H; wr ; goto Main1
79 / 101
Implementazione di IJVM con Mic-1
ISUB
Sostituisce le due parole in cima allo stack con la loro dierenza
Main1
isub1
isub2
isub3
PC = PC + 1; fetch ; goto ( MBR )
MAR = SP = SP - 1; rd
H = TOS
MDR = TOS = MDR - H; wr ; goto Main1
80 / 101
Implementazione di IJVM con Mic-1
IAND
Sostituisce le due parole in cima allo stack con il loro AND logico
Main1
iand1
iand2
iand3
PC = PC + 1; fetch ; goto ( MBR )
MAR = SP = SP - 1; rd
H = TOS
MDR = TOS = MDR and H ; wr ; goto Main1
81 / 101
Implementazione di IJVM con Mic-1
IOR
Sostituisce le due parole in cima allo stack con il loro OR logico
Main1
ior1
ior2
ior3
PC = PC + 1; fetch ; goto ( MBR )
MAR = SP = SP - 1; rd
H = TOS
MDR = TOS = MDR or H ; wr ; goto Main1
82 / 101
Implementazione di IJVM con Mic-1
DUP
Duplica la parola in cima allo stack
Main1
idup1
idup2
PC = PC + 1; fetch ; goto ( MBR )
MAR = SP = SP + 1
MDR = TOS ; wr ; goto Main1
83 / 101
Implementazione di IJVM con Mic-1
BIPUSH
BIPUSH byte
Main1
bipush1
bipush2
bipush3
scrive
byte in cima allo stack
PC = PC + 1; fetch ; goto ( MBR )
SP = MAR = SP + 1
PC = PC + 1; fetch
MDR = TOS = MBR ; wr ; goto Main1
84 / 101
Implementazione di IJVM con Mic-1
ILOAD
ILOAD oset
scrive in cima allo stack una variabile locale
memorizzata in
Main1
iload1
iload2
iload3
iload4
iload5
oset
PC = PC + 1; fetch ; goto ( MBR )
H = LV
MAR = MBRU + H; rd
MAR = SP = SP + 1
PC = PC + 1; fetch ; wr
TOS = MDR ; goto Main1
85 / 101
Implementazione di IJVM con Mic-1
ISTORE
ISTORE oset
rimuove dalla cima dello stack una parola e la
memorizza nella locazione di memoria assegnata alla variabile locale
indicata con
oset
Main1
istore1
istore2
istore3
istore4
istore5
istore6
PC = PC + 1; fetch ; goto ( MBR )
H = LV
MAR = MBRU + H
MDR = TOS ; wr
SP = MAR = SP - 1; rd
PC = PC + 1; fetch
TOS = MDR ; goto Main1
86 / 101
Implementazione di IJVM con Mic-1
POP
POP
rimuove la parola in cima allo stack
Main1
pop1
pop2
pop3
PC = PC + 1; fetch ; goto ( MBR )
MAR = SP = SP - 1; rd
TOS = MDR ; goto Main1
87 / 101
Implementazione di IJVM con Mic-1
SWAP
SWAP
scambia tra loro le due parole in cima allo stack
Main1
swap1
swap2
swap3
swap4
swap5
swap6
PC = PC + 1; fetch ; goto ( MBR )
MAR = SP - 1; rd
MAR = SP
H = MDR ; wr
MDR = TOS
MAR = SP - 1; wr
TOS = H; goto Main1
88 / 101
Implementazione di IJVM con Mic-1
IINC
IINC varnum const
incrementa di una quantità
della variabile di numero
Main1
iinc1
iinc2
iinc3
iinc4
iinc5
iinc6
varnum
const il valore
PC = PC + 1; fetch ; goto ( MBR )
H = LV
MAR = MBRU + H; rd
PC = PC + 1; fetch
H = MDR
PC = PC + 1; fetch
MDR = MBR + H ; wr , goto Main1
89 / 101
Implementazione di IJVM con Mic-1
GOTO
GOTO oset
eettua un salto incondizionato. Si noti che
oset è
una parola di 16 bit che viene prelevata in due operazioni successive
di fetch
Main1
goto1
goto2
goto3
goto4
goto5
goto6
PC = PC + 1; fetch ; goto ( MBR )
OPC = PC - 1
PC = PC + 1; fetch
H = MBR << 8
H = MBRU OR H
PC = OPC + H; fetch
goto Main1
90 / 101
Implementazione di IJVM con Mic-1
GOTO
91 / 101
Implementazione di IJVM con Mic-1
IFLT
IFLT oset
eettua un salto a
oset se e solo se la parola in cima
allo stack risulta minore di zero
Main1
iflt1
iflt2
iflt3
iflt4
PC = PC + 1; fetch ; goto ( MBR )
MAR = SP = SP - 1; rd
OPC = TOS
TOS = MDR
N = OPC ; if ( N) goto T; else goto F
T
F
F1
F2
OPC = PC - 1; goto goto2
PC = PC + 1
PC = PC + 1; fetch
goto Main1
92 / 101
Implementazione di IJVM con Mic-1
IFEQ
IFEQ oset
eettua un salto a
oset se e solo se la parola in cima
allo stack risulta uguale a zero
Main1
ifeq1
ifeq2
ifeq3
ifeq4
PC = PC + 1; fetch ; goto ( MBR )
MAR = SP = SP - 1; rd
OPC = TOS
TOS = MDR
Z = OPC ; if ( Z) goto T; else goto F
T
F
F1
F2
OPC = PC - 1; goto goto2
PC = PC + 1
PC = PC + 1; fetch
goto Main1
93 / 101
Implementazione di IJVM con Mic-1
IF_ICMPEQ
IF_ICMPEQ oset
eettua un salto a
oset se e solo se le due
parole in cima allo stack risultano uguali
Main1 PC =
if_icmpeq1
if_icmpeq2
if_icmpeq3
if_icmpeq4
if_icmpeq5
if_icmpeq6
goto F
T
F
F1
F2
PC + 1; fetch ; goto ( MBR )
MAR = SP = SP - 1; rd
MAR = SP = SP - 1
H = MDR ; rd
OPC = TOS
TOS = MDR
Z = OPC - H ; if (Z ) goto T ; else
OPC = PC - 1; goto goto2
PC = PC + 1
PC = PC + 1; fetch
goto Main1
94 / 101
Progettazione del livello di microarchitettura /1
La progettazione di un livello di microarchitettura richiede lo studio
di molti aspetti:
Velocità
Costi
Adabilità
Facilità di utilizzo
Consumi energetici
Dimensioni siche
Alcuni di questi aspetti sono conittuali fra loro. La soluzione
migliore richiede pertanto l'adozione di soluzioni di compromesso,
per esempio scegliendo un punto di equilibrio tra velocità e costi
95 / 101
Progettazione del livello di microarchitettura /2
L'incremento della velocità di esecuzione può essere raggiunto
mediante varie soluzioni:
Riduzione il numero di cicli di clock necessari per l'esecuzione
di un'istruzione
Semplicazione dell'organizzazione per ottenere un ciclo di
clock più breve
Sovrapposizione dell'esecuzione di più istruzioni (pipelining)
96 / 101
Progettazione del livello di microarchitettura /3
Il numero di cicli di clock necessari per l'esecuzione di un insieme
di operazioni è noto come
path length
e può essere ridotto
mediante l'impiego di hardware specializzato
Una possibilità consiste, per esempio, nell'adozione di un
incrementatore (tecnicamente un sommatore con un operando sso
a 1) che opera su PC, in modo da evitare che la ALU debba
provvedere all'incremento di PC
Il costo dovuto all'adozione di un nuovo sommatore non ripaga
però in termini di riduzione dei cicli di clock, in quanto in molte
istruzioni insieme all'incremento di PC vengono eseguite operazioni
di lettura
97 / 101
Progettazione del livello di microarchitettura /4
La riduzione dei cicli necessari per il fetch delle istruzioni richiede
la sovrapposizione dell'esecuzione di più istruzioni
La separazione dei circuiti predisposti al fetch delle istruzioni
(porta verso la memoria e registri PC/MBR) è molto più ecace se
quest'unità viene resa indipendente dal datapath principale
In questo modo il fetch del prossimo opcode (oppure
dell'operando) può essere eseguito separatamente dal resto delle
microistruzioni, eventualmente in modo asincrono rispetto al resto
della CPU. In questo modo potrebbe essere possibile eseguire il
fetch di più operazioni in anticipo alla loro esecuzione
98 / 101
Progettazione del livello di microarchitettura /5
Una delle fasi più dispendiosa in molte istruzioni consiste ad
esempio nel fetch di un oset a 16 bit, nella sua estensione e nella
memorizzazione nel registro H
Una possibile soluzione consiste nell'aumentare la dimensione
della porta della memoria per portarla a 16 bit. Ma questo non
risolve i problemi, in quanto la memoria è composta di parole di 32
bit
La soluzione più ecace resta in conclusione la sovrapposizione
dell'esecuzione delle istruzioni, che può consentire aumenti
signicativi della velocità
99 / 101
Progettazione del livello di microarchitettura /7
Riduzione della lunghezza del percorso di esecuzione
In Mic-1 il ciclo principale consiste in una microistruzione da
eseguire all'inizio di ogni istruzione IJVM. In alcuni casi è possibile
sovrapporla all'istruzione precedente
Infatti, quando
Main1
viene eseguito il codice operativo da
interpretare è già presente nel registro MBR (prelevato dal
precedente ciclo principale oppure durante l'esecuzione
dell'istruzione precedente)
In alcuni casi è possibile ridurre la microistruzione
Main1
può
essere inserita nelle microistruzioni precedenti poiché alcune
istruzioni non sono completamente utilizzate
100 / 101
Progettazione del livello di microarchitettura /8
Riduzione della lunghezza del percorso di esecuzione
Versione originale
pop1
pop2
pop3
Main1
MAR = SP = SP - 1; rd
TOS = MDR ; goto Main1
PC = PC + 1; fetch ; goto ( MBR )
Versione ottimizata
pop1
Main1 . pop
pop3
MAR = SP = SP - 1; rd
PC = PC + 1; fetch
TOS = MDR ; goto ( MBR )
101 / 101