Progetto CPU (multiciclo) Problemi con progetto a singolo ciclo

Problemi con progetto a singolo ciclo
•
Problemi del singolo ciclo
– Ciclo di clock lungo
– Istruzioni potenzialmente più veloci sono rallentate
• impiegano lo stesso tempo dell’istruzione più lenta
Progetto CPU
(multiciclo)
– Unità funzionali e collegamenti del Datapath sono replicati
• dobbiamo poter computare in parallelo tutti i passi computazionali necessari
per l’esecuzione di qualsiasi istruzione dell’ISA
•
Salvatore Orlando
Possibile soluzione:
– datapath “multiciclo”
– usiamo un ciclo più corto
– istruzioni differenti impiegano un numero di cicli diversi
– unità funzionali possono essere usate più volte per eseguire la stessa
istruzione ⇒ meno replicazione
• basta usarle in cicli differenti
– registri aggiuntivi
• usati per memorizzare i risultati parziali nell’esecuzione delle istruzioni
Arch. Elab. - S. Orlando 1
Arch. Elab. - S. Orlando 2
Esempio di riduzione del ciclo di clock
•
•
Datapath multiciclo
Effettua un taglio su grafo delle dipendenze corrispondente al circuito
combinatorio, e inserisci un registro nel mezzo
Fai lo stesso lavoro di prima in 2 cicli più veloci, invece che in singolo ciclo
più lento
elemento di memoria
Logica
Combinatoria
Aciclica
elemento di memoria
Logica
Combinatoria
Aciclica (A)
Addr dati
Registri addizionali
elemento di memoria
•
elemento di memoria
Logica
Combinatoria
Aciclica (B)
•
elemento di memoria
Arch. Elab. - S. Orlando 3
PC
Registri interni addizionali usati per memorizzare valori intermedi, da usare nel
ciclo di clock successivo per continuare l’esecuzione della stessa istruzione
– IR, MDR, A, B, ALUOut
Riuso di unità funzionali
– ALU usata anche per calcolare gli indirizzo dei salti e incrementare il PC
– Memoria usata sia per leggere le istruzioni e per leggere/scrivere i dati
Arch. Elab. - S. Orlando 4
Suddivisione in passi del Datapth
Sequenza dei cinque passi di esecuzione
• Fetch dell’istruzione
• Decodifica dell’istruzione e
•
• R-type exe
Completa Branch
Nell’inserire i registri addizionali, abbiamo pensato di spezzare l’esecuzione
delle istruzioni in passi
– ogni passo da eseguire in un ciclo di clock (ciclo più corto rispetto alla
CPU a ciclo singolo)
– importante il bilanciamento della quantità di lavoro eseguito nei vari passi,
perché dobbiamo fissare un ciclo di clock unico
•
• Accesso alla memoria
Completa R-type (scrittura regs)
• Write back (scrittura reg: solo LW)
OGNI PASSO ESEGUITO IN UN CICLO DI CLOCK
LE ISTRUZIONI IMPIEGANO DA 3 A 5 CICLI
Arch. Elab. - S. Orlando 6
Inseriamo i multiplexer
Controllo
Ulteriore ingresso:
PC
•
I segnali di controllo alle varie unità funzionali e ai multiplexer non dipendono
solo dal tipo istruzione da eseguire
– es.: rispetto ad una sub, l’ALU dovrà essere usata, in cicli di clock
differenti, per
• PC = PC + 4;
• R[rd] <– R[rs] – R[rt];
MDR oppure ALUOut
o
– dipende dal tipo di istruzione
Al termine di ogni ciclo i valori intermedi, da impiegare nei cicli successivi,
sono memorizzati nei registri interni addizionali
Register File e PC sono invece impiegati per memorizzare valori da usare per
l’esecuzione di una nuova istruzione
Arch. Elab. - S. Orlando 5
PC oppure
ALUout (addr, lw/sw)
Calcolo Indirizzo Memoria o
Completa Jump
– dipende dal tipo di istruzione
• determinato sulla base del passo più lungo, ovvero più costoso dal punto di
vista computazionale
•
o
o
Lettura dei regs. (e Addr. Branch)
(somma)
(sottrazione)
•
Quindi i segnali di controllo dovranno essere diversi durante i vari passi (cicli
di clock) necessari per l’esecuzione dell’istruzione
•
Il controllo sarà infatti implementato come circuito sequenziale
– l’output del circuito (segnali di controllo) dipenderanno dallo stato interno
al circuito al tempo ti
– stato del circuito sequenziale = passo di esecuzione di una istruzione
Altri 2 ingressi, da sommare con PC:
PC = PC + 4
PC = PC + (sign_ext(imm16) << 2)
Arch. Elab. - S. Orlando 7
Arch. Elab. - S. Orlando 8
Datapath e Controllo multi-ciclo
Segnali di controllo di 1 bit
Segnale
Effetto se uguale a 0
Effetto se uguale a 1
Reg. dest. proviene da rt
Nessuno
Reg. dest. proviene da rd
Scrittura in Reg. File
MemRead
1^ ingresso dell'ALU è PC
Nessuno
1^ ingresso dell'ALU è reg. A
Lettura da Mem. in reg. MDR
RegDest
Reg Write
AluSrcA
MemWrite
Nessuno
Scrittura in Mem.
MemtoReg
Reg. scritto proviene da ALUOut
Reg. scritto proviene da MDR
IorD
Addr.della Mem. proviene da PC
Nessuno
Nessuno
Addr.della Mem. proviene da ALUOut
Scrittura in IR (proviene da Mem. )
Scrittura in PC
PC viene scritto se è anche vero che
Zero = 1 (beq)
IRWrite
PCWrite
PCWriteCond Nessuno
Per istruzioni di beq: PCWriteCond=1 e PCWrite=0
Il segnale di scrittura di PC è infatti calcolato come:
PCWrite + (PCWriteCond ⋅ Zero)
Arch. Elab. - S. Orlando 9
Arch. Elab. - S. Orlando 10
Segnali di controllo di 2 bit
Passo 1: Fetch dell’istruzione
•
S e gna le
ALUOp
ALUS rcB
P CS ource
V alore
E ffetto
00
A LU c alc ola s om m a ( lw, sw , PC + … )
01
A LU c alc ola s ottraz ione ( beq )
10
A LU c alc ola l'operaz ione determ inata da funct
00
2^ ingres s o dell'A LU è reg. B
01
2^ ingres s o dell'A LU è costante 4
10
2^ ingres s o dell'A LU è sign_ext(im m 16) ( lw/sw )
•
•
11
2^ ingres s o dell'A LU è sign_ext(im m 16) < < 2 ( beq )
00
In P C viene s c ritto l'us c ita dell'A LU ( PC+ 4 )
01
In P C viene s c ritto A LUOut ( beq )
10
In P C viene s c ritto PC[31-28] || sign_ext(im m 26) < < 2 ( jum p )
Arch. Elab. - S. Orlando 11
Usa PC per prelevare l’istruzione dalla memoria e porla nell’Instruction
Register (IR)
Incrementa PC di 4, e rimetti il risultato nel PC
Passo identico per tutte le istruzioni
•
Usando la notazione RTL:
IR = M[PC];
PC = PC + 4;
•
Durante questo passo (stesso ciclo di clock) usiamo:
– Memoria
– ALU
•
Vediamo in dettaglio i valori dei segnali di controllo
Arch. Elab. - S. Orlando 12
Passo 1: Fetch dell’istruzione
Passo 2: Decodifica istruzione & Lettura registri
•
•
•
•
•
•
IR = M[PC];
– MemRead ← 1
– IRWrite ← 1
– IorD ← 0
•
PC = PC + 4;
– ALUSrcA ← 0
ALUSrcB ← 01
– ALUOp ← 00 (somma)
– PCWrite ← 1
PCSource ← 00
•
•
Leggi i registri rs e rt, e calcola l’indirizzo del salto del beq
IR (op) viene inviato al controllo per la decodifica e la determinazione dei
passi successivi ⇒ Decodifica dell’istruzione
RTL:
A = Reg[ IR[25-21] ];
B = Reg[ IR[20-16] ];
ALUOut = PC + (sign-ext( IR[15-0] ) << 2);
Passo identico per tutte le istruzioni , ma potremmo anticipare del lavoro non
necessario.
– per certe istruzioni, i due campi (rs, rt) potrebbero essere non significativi
– calcoliamo l’indirizzo a cui saltare, come se l’istruzione fosse beq, ma il
campo imm16 potrebbe essere non significativo
Quali i vantaggi di questo lavoro anticipato?
Durante questo passo (stesso ciclo di clock) usiamo:
– Register File
– ALU
Vediamo i valori dei segnali di controllo
Arch. Elab. - S. Orlando 13
Passo 2: Decodifica istruzione & Lettura registri
Arch. Elab. - S. Orlando 14
Passo 3: (dipende dall’istruzione)
• Usiamo l’ALU in dipendenza del tipo di istruzione
• Il controllo, avendo già decodificato l’istruzione letta al passo
precedente, può già decidere i segnali da inviare al Datapath in
relazione al tipo di istruzione
• R-type exe:
ALUOut = A op B;
• Calcolo Indirizzo Memoria (load/store)
ALUOut = A + sign-ext( IR[15-0] );
• Completa Branch
•
A = Reg[ IR[25-21] ];
B = Reg[ IR[20-16] ];
– A e B sovrascritti per
ogni tipo di istruzioni
•
ALUOut = PC + (sign-ext( IR[15-0] ) << 2)
– ALUSrcA ← 0
ALUSrcB ← 11
– ALUOp ← 00 (somma)
if (A == B)
then
PC = ALUOut;
• Completa Jump
PC = PC[31-28] II (IR[25-0] << 2);
Arch. Elab. - S. Orlando 15
Arch. Elab. - S. Orlando 16
Passo 3: (dipende dall’istruzione)
R-type exe:
Passo 3: (dipende dall’istruzione)
LOAD / STORE:
ALUOut = A op B;
ALUSrcA ← 1
ALUSrcB ← 00
ALUOp ← 10 (campo FUNCT)
ALUOut riscritto ad ogni ciclo
ALUOut = A + sign-ext( IR[15-0] );
ALUSrcA ← 1
ALUSrcB ← 10
ALUOp ← 00 (somma)
Completa Branch
if (A == B)
then PC = ALUOut;
ALUSrcA ← 1
ALUSrcB ← 00
ALUOp ← 01 (sottr.)
(sottrazione registri A e B, check salto sulla base di Zero)
Per abilitare la scrittura nel PC del valore precedentemente
calcolato (ALUOut), necessari altri segnali di controllo non illustrati:
PCWrite ← 0
PCWriteCond ← 1
PCSource ← 01
Arch. Elab. - S. Orlando 17
Arch. Elab. - S. Orlando 18
Passo 3: (dipende dall’istruzione)
Passo 4: (dipende dall’istruzione)
•
LOAD e STORE accedono alla memoria
MDR = Memory[ALUOut];
or
Memory[ALUOut] = B;
•
Terminazione istruzioni R-type
Reg[ IR[15-11] ] = ALUOut;
Completa Jump
PC = PC[31-28] II (IR[25-0] << 2);
Per abilitare la scrittura nel PC, i segnali di
controllo, non illustrati in figura, sono:
PCWrite ← 1 PCSource ← 10
Arch. Elab. - S. Orlando 19
•
Durante questo passo usiamo:
– Register File (Write) oppure Memoria
•
Vediamo i segnali di controllo
Arch. Elab. - S. Orlando 20
Passo 4: (dipende dall’istruzione)
Load:
Store:
MDR = Memory[ALUOut];
IorD ← 1
MemRead ← 1
Passo 5: Write-back (LOAD)
R-type:
Memory[ALUOut] = B;
IorD ← 1
MemWrite ← 1
Load:
Reg[ IR[15-11] ] = ALUOut;
RegDest ← 1
RegWrite ← 1
MemtoReg ← 0
Reg[ IR[20-16]]= MDR;
RegDest ← 0
RegWrite ← 1
MemtoReg ←1
Arch. Elab. - S. Orlando 21
Riassumendo
S tep name
Instruction fe tch
Instruction d ecod e /
reg ister fetch/
bra nch addr. com p.
E xecution, a ddre ss
co m putation, bra nch/
jum p co m ple tion
M e m ory access or R-type
co m ple tion
M e m ory rea d co m ple tion
A L UOut = A op B
Re g [IR[15-1 1]] =
A L UOut
Action for m em ory-reference
Action for
instructions
branches
IR = M e m ory[P C ]
PC = PC + 4
A = Reg [IR[25-2 1]]
B = Reg [IR[20-1 6]]
A L UOut = P C + (sign-exte nd (IR[15 -0]) << 2)
A L UOut = A + sig n-extend
(IR[15-0 ])
Arch. Elab. - S. Orlando 22
Alcune semplici domande
•
Action for R -type
instructions
NOTA: Le altre istruzioni
non giungono al passo 5
if (A ==B ) then
P C = A LUO ut
lw $t2, 0($t3)
lw $t3, 4($t3)
beq $t2, $t3, Label
add $t5, $t2, $t3
sw $t5, 8($t3)
Label: ...
Action for
jum ps
P C = P C [31 -28] II
(IR[25-0 ]<<2 )
Quanti cicli sono necessari per eseguire questo codice?
•
#assume not
5
5
3
4
4
21
Cosa accade durante l’8o ciclo di esecuzione?
• Calcolo dell’indirizzo della 2a lw
Lo ad: M D R = M em ory[A LUOut]
or
S to re: M em ory [A L UOut] = B
•
Lo ad: Re g[IR[20-1 6]] = M D R
In quale ciclo avviene effettivamente la somma tra $t2 e $t3 ?
• Nel 16-esimo ciclo
Arch. Elab. - S. Orlando 23
Arch. Elab. - S. Orlando 24
Definizione controllo
•
•
Automa completo
Possiamo implementare il controllo della CPU come un circuito sequenziale di
Moore, modellabile come un automa a stati finiti
Automa
– ogni nodo corrisponde a un stato differente del circuito, in corrispondenza
di un certo ciclo di clock
– gli output del controllo (segnali di controllo) dipendono dallo stato
corrente
– da 3 a 5 stati devono essere attraversati (ovvero, da 3 a 5 cicli di clock)
Inizio
Fetch
•
•
•
Decode, Read reg, Beq
Addr. comp.
M read
R-type Exe
M write
Beq completam.
Jump completam.
R write
R write
Etichette interni ai nodi
– corrispondono ai
segnali che il Controllo
deve inviare al Datapath
Etichette sugli archi
– dipendono dagli input
del Controllo
– ovvero, dal valore di del
campo Op
dell’istruzione letta
10 stati
– ogni stato associato
con un’etichetta
mnemonica, e anche
con un identificatore
numerico
– quanti bit sono
necessari per il registro
di stato?
Arch. Elab. - S. Orlando 25
Arch. Elab. - S. Orlando 26
Componenti CPU (Datapath+Control) e Memoria
•
CPU
ALUSrcA
MemRead
IorD
IRWrite
ALUSrcB RegWrite MemtoReg MemWrite MemRead
Addr
Instr/Data
Memory
PC (fetch) o ALUOut (sw,lw)
IR (fetch) o
MDR (lw)
DATA PATH
Funct =IR[5:0]
Op =IR[31:26]
Zero
B (sw)
– poiché il controllo è di Moore, l’output (controlli) dipende solo dallo stato (veloce)
• decodifica del controllo dell’ALU più complessa (2 livelli):
Operation = f(AluOp, Funct)
– l’input del controllo, importante per la transizione di stato, è Op
• Op è un campo del registro IR del Datapath (non necessario calcolarlo)
– il segnale di Zero è importante nel caso di BEQ ...
Next
State
Controllo
•
Op
Dataout
Datain
Nota: tra i segnali provenienti dal Datapath, solo Op è usato per selezionare il
prossimo stato
Arch. Elab. - S. Orlando 27
Datapath
ALU
PC write
signal
RegDest
•
Zero
PCSource
PCWrite +
(Zero · PCWriteCond)
Ipotizziamo gli stessi costi precedenti (in ns) per le varie componenti
– Mem. Istr/Dati: 2 ns
Reg. File: 1 ns
ALU: 2 ns
– non li usiamo mai in sequenza ⇒ possiamo ipotizzare un ciclo di 2 ns
Più in dettaglio, per determinare il ciclo ci clock, consideriamo il diagramma di
sotto, che si riferisce al 3o passo della BEQ
controlli
CONTROL
Operation = f(AluOp, Funct)
Dimensionamento ciclo di clock
Esempio di diagramma
temporale per il 3o passo
di esecuzione di
un’istruzione
2 ns
Arch. Elab. - S. Orlando 28
Costo istruzioni
•
•
•
•
Circuito sequenziale che implementa il controllo
Per le varie istruzioni, possiamo impiegare un numero differente di cicli
– introduciamo il concetto di CPI (no. di cicli per istruzione)
Quant’è il CPI delle varie istruzioni rispetto all’architettura multi-ciclo ?
– R-type, sw:
4 cicli (tempo: 8 ns)
– lw:
5 cicli (tempo: 10 ns)
– beq, jump:
3 cicli (tempo: 6ns)
Nota che l’istruzione di lw impiega ben 10 ns invece degli 8 ns dell’architettura
a singolo ciclo
– purtroppo ciò è dovuto alla necessità di fissare il ciclo di clock abbastanza
lungo da permettere l’esecuzione di uno qualsiasi dei passi previsti per le
varie istruzioni
– il 5o passo della lw, anche se usa solo il Register File (latenza 1 ns), viene
comunque eseguito in un ciclo di clock da 2 ns
Abbiamo ottenuto un risparmio solo per le istruzioni di beq e jump
– se avessimo considerato istruzioni molto più lunghe (come quelle FP), non
avremmo osservato questa apparente decadimento di prestazione nel
passare all’architettura multi-ciclo
– in quel caso, la scelta del ciclo singolo ci avrebbe costretto ad allungare a
Arch. Elab. - S. Orlando 29
dismisura il ciclo di clock per eseguire l’istruzione FP
•
•
•
Nota
– blocco combinatorio per calcolare NEXT_STATE & OUTPUTS
– state register per memorizzare stato corrente
Arch. Elab. - S. Orlando 30
Implem. cablata (a logica sparsa) del Controllo
Circuiti combinatori e ROM
•
•
•
•
•
Blocco combinatorio all’interno
del circuito sequenziale che
implementa il controllo della CPU
può essere implementato con
logica digitale a 2 livelli
– PLA
Numero minimo di porte logiche,
e quindi di transistor
Implementazione ottima, ma non
modificabile
– poca flessibilità
Efficiente finché il numero di stati
del circuito è abbastanza piccolo
•
ROM = "Read Only Memory"
– i valori delle varie celle di memoria sono fissate in anticipo
ROM usata per memorizzare una tabella di verità = il circuito combinatorio
necessario per implementare il controllo della CPU
– se l’indirizzo è di m bit, possiamo indirizzare 2m celle della ROM
– gli output della ROM corrispondono al contenuti delle varie celle
indirizzare dai m bit dell’indirizzo
Tabella di verità
m
n
ROM
•
Arch. Elab. - S. Orlando 31
Controllo a due livelli
– ALUOp calcolato sulla base
di Op, combinato con Funct
(IR[5:0]) per generare il
segnale a 3 bit (Operation) da
inviare all’ALU
PCWrite e PCWriteCond usati
assieme a Zero proveniente dal
Datapath, per generare il segnale
a 1 bit che permette la scrittura di
PC
0
0
0
0
1
1
1
1
0
0
1
1
0
0
1
1
0
1
0
1
0
1
0
1
0
1
1
1
0
0
0
0
0
1
1
0
0
0
1
1
1
0
0
0
0
0
1
1
1
0
0
0
0
1
0
1
Tabella di verità con m variabili in input e n in output
– sufficiente una ROM di 2m x n bit
Arch. Elab. - S. Orlando 32
Implementazione del controllo tramite ROM
•
•
•
•
•
•
Quanti sono gli input del blocco combinatorio interno al controllo ?
– 6 bit per Opcode, 4 bit per lo Stato
– < Opcode, Stato >= 10 linee di indirizzo
– 210 = 1024 indirizzi differenti
Quanti sono gli output ?
– 16 bit per i vari segnali di controllo del Datapath
– 4 bit per lo Stato
– 20 bit in output
ROM è 210 × 20 = 20K bits (dimensione non usuale)
Soluzione che spreca molte risorse, poiché molte celle della ROM (e i
corrispondenti output della ROM) sono identiche o quasi identiche
Poiché il circuito sequenziale è di Moore, i 16 bit dell’Output (relativi ai segnali
di controllo) dipendono solo dallo Stato
– per gli indirizzi <X, Stato > le celle della ROM sono quasi identiche
Da certi Stati, la transizione (i 4 bit di Output del Next State) avviene
indipendentemente dall’Opcode
– per alcuni indirizzi <X, Stato > le celle sono identiche
Arch. Elab. - S. Orlando 33
ROM vs. PLA
•
Spezziamo la tabella di verità in due parti (OUTPUTS e NEXT_STATE)
– i 4 bit di Stato determinano i 16 Outputs ⇒ ROM di 24x16 b = 28 b = 0.25 Kb
– i 10 bits (Opcode, Stato) determinano i 4 bit del prossimo Stato ⇒ ROM di
210 x 4 b = 4 Kb
– Totale: ROM di 4.25 Kb (invece di 20 Kb)
•
La PLA risulta sempre più piccola
– molti prodotti sono condivisi
– i DON’T CARE sono tutti considerati attentamente per ridurre il numero di
prodotti o il numero di fattori in ogni prodotto
•
Il numero di celle PLA (porte AND e OR) sono:
– (#inputs × #product-terms) + (#outputs × #product-terms)
– nel nostro caso:
•
Dimensione (in spazio e numero di transistor) delle celle PLA è simile alla
dimensione delle celle ROM (celle PLA un po’ più grandi)
Arch. Elab. - S. Orlando 34
Un altro stile di implementazione
Sequenzializzatore in dettaglio
Spesso NEXT_STATE corrisponde a current state + 1
– vedi, rispetto al nostro automa, le transizioni di stato 0→1, 3→4 o 6→7
Control unit
PLA or ROM
Outputs
Input
PCWrite
PCWriteCond
IorD
MemRead
MemWrite
IRWrite
BWrite
MemtoReg
PCSource
ALUOp
ALUSrcB
ALUSrcA
RegWrite
RegDst
AddrCtl
Op
000000
000010
000100
100011
101011
Dispatch ROM 1
Opcode name
R-format
jmp
beq
lw
sw
Value
0110
1001
1000
0010
0010
Op
100011
101011
Dispatch ROM 2
Opcode name
lw
sw
Value
0011
0101
Fetch (0)
Stato++
1
State
Adder
Address select logic
Op[5– 0]
•
(10x17)+(20x17) = 460 celle PLA
Instruction registerı
opcode field
Arch. Elab. - S. Orlando 35
State number
0
1
2
3
4
5
6
7
8
9
Address-control action
Use incremented state
Use dispatch ROM 1
Use dispatch ROM 2
Use incremented state
Replace state number by 0
Replace state number by 0
Use incremented state
Replace state number by 0
Replace state number by 0
Replace state number by 0
Value of AddrCtl
3
1
2
3
0
0
3
0
0
0
Arch. Elab. - S. Orlando 36
Microprogrammazione
Formato microistruzione
Field name
•
•
Rappresentazione tramite automi a stati finiti diventa improponibile quando
dobbiamo trattare un numero elevato di stati
– un foglio non basta più se si considerano tutte le istruzioni MIPS (> 100) e
il numero di cicli necessari per i le istruzioni più complesse (oltre 20 cicli)
Microprogrammazione
– idea prese in prestito dal campo della programmazione (dallo stile grafico
a quello testuale: dagli automi ai microprogrammi)
– scopo di una microistruzione è quello di specificare (simbolicamente) i
segnali di controllo da affermare nel Datapath ad un certo istante
– eseguire la microistruzione (Moore) avrà l’effetto di affermare alcuni
segnali di controllo per l’esecuzione di una certa istruzione macchina
– ogni microistruzione dovrà specificare quale sarà la prossima
microistruzione da eseguire, ovvero il prossimo stato del controllo
ALU control
SRC1
SRC2
Value
Add
Subt
Func code
PC
A
B
4
Extend
Extshft
Read
ALUOp =
ALUSrcA
ALUSrcA
ALUSrcB
ALUSrcB
ALUSrcB
ALUSrcB
Write ALU
RegWrite,
RegDst = 1,
MemtoReg = 0
RegWrite,
RegDst = 0,
MemtoReg = 1
MemRead,
lorD = 0
MemRead,
lorD = 1
MemWrite,
lorD = 1
PCSource = 00
PCWrite
PCSource = 01,
PCWriteCond
PCSource = 10,
PCWrite
AddrCtl = 11
AddrCtl = 00
AddrCtl = 01
AddrCtl = 10
Register
control
Write MDR
Read PC
Memory
Read ALU
Write ALU
ALU
• la prossima microistruzione da eseguire potrà essere sempre univocamente
determinata
– es. sempre la successiva secondo l’ordine lessicografico del micoprogramma,
oppure una determinata altra microistruzione
• la scelta della prossima microistruzione potrà dipendere dagli input (Op code)
PC write control
ALUOut-cond
jump address
Sequencing
Signals active
ALUOp = 00
ALUOp = 01
Seq
Fetch
Dispatch 1
Dispatch 2
10
=0
=1
= 00
= 01
= 10
= 11
Comment
Cause the ALU to add.
Cause the ALU to subtract; this implements the compare for
branches.
Use the instruction's function code to determine ALU control.
Use the PC as the first ALU input.
Register A is the first ALU input.
Register B is the second ALU input.
Use 4 as the second ALU input.
Use output of the sign extension unit as the second ALU input.
Use the output of the shift-by-two unit as the second ALU input.
Read two registers using the rs and rt fields of the IR as the register
numbers and putting the data into registers A and B.
Write a register using the rd field of the IR as the register number and
the contents of the ALUOut as the data.
Write a register using the rt field of the IR as the register number and
the contents of the MDR as the data.
Read memory using the PC as address; write result into IR (and
the MDR).
Read memory using the ALUOut as address; write result into MDR.
Write memory using the ALUOut as address, contents of B as the
data.
Write the output of the ALU into the PC.
If the Zero output of the ALU is active, write the PC with the contents
of the register ALUOut.
Write the PC with the jump address from the instruction.
Choose the next microinstruction sequentially.
Go to the first microinstruction to begin a new instruction.
Dispatch using the ROM 1.
Dispatch using the ROM 2.
Arch. Elab. - S. Orlando 37
Arch. Elab. - S. Orlando 38
Microprogramma relativo alla nostra CPU
•
Microprogramma completo della nostra semplice unità di controllo
– nota che per la corretta sequenzializzazione delle istruzioni, in 2 casi
rimanda ad una specifica tabella di smistamento
Label
F e tc h
Mem 1
LW 2
AL U
c o n tro l
Add
Add
Add
S RC 1
PC
PC
A
SW 2
R fo rm at1 F unc c o d e A
BEQ1
J UM P 1
•
•
S ub t
A
P C Write
Re g is te r
c o n tro l
M e m o ry
c o n tro l
S RC 2
4
R e ad P C A L U
E xts hft R e ad
E xte nd
R e ad A L U
W rite M D R
W rite A L U
B
W rite A L U
B
A L UO ut-c o nd
J um p ad d re s s
Implementazione del microprogramma
•
•
S e q u e n c in g
Seq
D is p atc h 1
D is p atc h 2
Seq
F e tc h
F e tc h
Seq
F e tc h
F e tc h
F e tc h
Un’implementazione diversa di questa stessa ISA avrebbe lo stesso microcodice?
Cosa dovrebbe un microassembler ?
Arch. Elab. - S. Orlando 39
Microprogramma ≡ Rappresentazione
alternativa all’automa a stati finiti
– rappresenta il comportamento di
un circuito sequenziale
Per l’implementazione, possibili tutte
le alternative viste per gli automi
– PLA o ROM
– circuiti distinti per calcolare
sequenzializzazione (NEXT_STATE) e
output del circuito sequenziale
•
Storicamente, le implementazioni del
controllo microprogrammato
impiegano
– ROM per memorizzare microistruzioni
– incrementatore esplicito e logica di
sequenzializzazione per determinare la
prossima microistruzione
– Label della microistruzione ≡
Registro di controllo
≡
Contatore di microprogramma
Arch. Elab. - S. Orlando 40
Microprogrammazione: pro e contro
•
Eccezioni e interruzioni
Specifica del controllo tramite microprogramma
•
Il progetto del controllo del processore si complica a causa della necessità di
considerare, durante l’esecuzione delle istruzioni, il verificarsi di eventi
inattesi, quali:
– interruzioni ed eccezioni
•
Eccezione
– evento sincrono, generato all’interno del processore, e provocato da
problemi nell’esecuzione di un’istruzione
– Pro
• semplice da progettare e scrivere
• possiamo progettare l’architettura e il codice assieme
•
Implementazione del controllo tramite ROM off-chip (macchine anni ‘60-’70)
– Pro
• Firmware (=Microcodice memorizzato nella ROM) facile da modificare
– basta sostituire la ROM
• es.: overflow, istruzione non valida
•
• stesso Datapath può emulare altre ISA
– Contro
• Eccessiva lentezza, considerando che oggi
– controllo implementato sullo stesso chip del processore (microprocessori)
– la ROM non è più (come un tempo) più veloce della RAM
• es.: la terminazione di
un’operazione di I/O la cui
esecuzione era stata richiesta in
precedenza dalla CPU
• fetch di una microistruzione per inviare i controlli al Datapath sarebbe
costoso come effettuare il fetch di una istruzione macchina
– non c’e’ più necessità di riprogettare ISA, correggere errori, o apportare cambi al
microcodice
Arch. Elab. - S. Orlando 41
Processore
Control
Memoria
Datapath
I/O
Interruzione
Arch. Elab. - S. Orlando 42
Gestione di eccezioni e interruzioni
Gestione di eccezioni e interruzioni
•
Il controllo di ogni processore deve essere predisposto per gestire il verificarsi
di eventi inattesi
•
Tutti i processori, quando si verifica un evento di eccezione/interruzione, la
gestiscono secondo lo schema seguente:
– interruzione dell’esecuzione del programma corrente
– salvataggio di parte dello stato di esecuzione corrente (almeno PC)
– salto ad una routine del codice che costituisce il Sistema Operativo (SO)
•
•
• il SO è stato caricato in memoria al momento del boot del sistema
• il salvataggio dello stato del programma interrotto serve al SO per poter
riprenderne eventualmente l’esecuzione, successivamente e se necessario
•
Interruzione
– evento asincrono, che giunge
dall’esterno del processore
– segnale che giunge da un’unità di
I/O, utilizzato per comunicare alla
CPU il verificarsi di certi eventi
Nota che le routine del SO possono essere invocate esplicitamente dai
programmi (es.: invocazione routine di I/O)
– nel MIPS abbiamo l’istruzione syscall
– esecuzione della syscall interpretata dal controllo come una particolare
eccezione interna
•
•
Arch. Elab. - S. Orlando 43
Problema:
– l’handler del SO deve essere in grado di capire quale evento si è verificato
Soluzioni alternative:
1 il controllo della CPU, prima di saltare all’handler predisposto dal SO (ad
un indirizzo fisso), deve salvare in un registro interno un identificatore
numerico del tipo di eccezione/interruzione verificatosi.
L’handler accederà al registro interno per determinare la causa
dell’eccezione/interruzione
2 interruzioni vettorizzate: esistono handler diversi per
eccezioni/interruzioni differenti. Il controllo della CPU deve scegliere
l’handler corretto, saltando all’indirizzo corretto.
A questo scopo, viene predisposto un vettore di indirizzi, uno per ogni tipo
di eccezioni/interruzioni, da indirizzare tramite il codice numerico
dell’eccezione/interruzione
Nel MIPS viene adottata la 1a soluzione, usando un registro, denominato
Cause, per memorizzare il motivo dell’eccezione/interruzione
Il PC corrente viene invece salvato nel registro EPC
Arch. Elab. - S. Orlando 44
Gestione eccezioni nel MIPS
•
Rilevamento eccezione
Il Controllo (ma anche il Datapath corrispondente) deve essere progettato per
– individuare l’evento inatteso
– interrompere l’istruzione corrente
– salvare il PC corrente (nel registro interno EPC = Exception PC)
– salvare la causa dell’interruzione nel registro Cause
•
•
•
• consideremo solo le eccezioni di overflow e istruzione non valida
0 = istruzione non valida
1=overflow
• solo se giunge un Op non valido
– saltare ad una routine del SO (exception/interrupt handler) ad un indirizzo
fisso:
0xC0000000
•
– a partire dallo stato R-type Completion, dobbiamo poter anche transire
nello stato Overflow
• solo se giunge un segnale di overflow dal Datapath (ALU)
• questa transizione si potrebbe anticipare allo stato Execution
– Problema: next state da calcolare in base ad un segnale calcolato dal Datapath
durante lo stesso ciclo di clock
Il MIPS non salva nessun altro registro oltre PC
– è compito dell’handler salvare altre porzioni dello stato corrente del
programma (es. tutti i registri generali), se necessario
• approccio RISC
•
– esistono CPU dove questo salvataggio esteso dello stato viene sempre
effettuato prima di saltare all’interrupt handler
• salvataggio garantito dal microcodice
• approccio CISC
Arch. Elab. - S. Orlando 45
Overflow
– segnale che arriva al controllo dall’ALU
Istruzione non valida
– controllo lo deve rilevare sulla base del campo op dell’istruzione
Dobbiamo aggiungere 2 nuovi stati al nostro automa
– a partire dallo stato Instruction Decode, dobbiamo poter transire nel nuovo
stato Invalid Instruction
•
Nuovo controllo
I nuovi stati che gestiscono le eccezioni dovranno occuparsi
– di salvare in EPC il PC corrente (ovvero PC - 4)
– di salvare 0/1 in Cause
– di memorizzare 0xC0000000 in PC
Il prossimo stato sarà il Fetch (ma della prima istruzione dell’handler)
Arch. Elab. - S. Orlando 46
Nuovo Datapath
Invalid
Instruction
Overflow
Arch. Elab. - S. Orlando 47
•
•
•
Nuovo ingresso per PC (ind. Interrupt handler):
0xC0000000
EPC viene caricato con il risultato dell’ALU, che calcola PC- 4
Cause viene caricato con 0, oppure con 1.
Arch. Elab. - S. Orlando 48