13-CPU_Multiciclo

Calcolatori Elettronici
Il Processore (2)
Francesco Lo Presti
Rielaborate da
Salvatore Tucci
Approccio Multiciclo
 Suddividere l’esecuzione di una istruzione in piu’
passi (steps)




Fetch, Decode, Execute, Memory Access, Write Back
Ogni passo richiede un ciclo di clock
Istruzioni diverse possono richiedere un numero diverso
di passi (cicli)
I passi scelti in modo da bilanciare il carico di lavoro
 In modo da minimizzare la durata del ciclo di clock
 Assunzione: in un passo/ciclo di clock si puo’
effettuare una sola operazione tra:



Accesso in memoria
Accesso al banco dei registri (lettura o scrittura)
Operazione ALU
CPU (2)
2
Approccio Multiciclo
 Alla fine di ogni ciclo
 Bisogna memorizzare i valori richiesti dai cicli successivi
dell’istuzione corrente
 Richiede l’impiego di registri addizionali interni (invisibili al
programmatore):
 IR:
Instruction Register
 MDR: Memory Data Register
 A & B:Valori letti dai registri
 ALUout: Registro che memorizza il risultato delle operazioni
ALU
CPU (2)
3
Approccio Multiciclo
 Vantaggi
 Unita’ funzionali che devono essere usata piu’ volte per la
stessa istruzione non devono essere replicate se
impiegate in passi diversi
 Una sola memoria per dati e istruzioni
 Una sola ALU (no adder)


Tempo di ciclo piu’ breve
Tempi di esecuzione inferiori
 Istruzioni usano il solo tempo (cicli) necessario alla loro
esecuzione
CPU (2)
4
Unità di elaborazione a ciclo multiplo: una
vista astratta
Contiene
l’istruzione
Dati dal primo
registro
Dati dalla
memoria
Risultato
della ALU
Dati dal secondo
registro
CPU (2)
5
Una vista più dettagliata
 Poiché le unità funzionali sono condivise, occorre aggiungere dei
multiplexer ed ampliare quelli già esistenti nel ciclo singolo
 Unica Memoria per dati e istruzioni

Si aggiunge un multiplexer per selezionare il PC o ALUOut come
indirizzo della memoria da leggere/scrivere
 Dovendo condividere la ALU


Si aggiunge un multiplexer per il primo ingresso della ALU per
selezionare il registro A (primo registro) oppure il PC (per il calcolo
dell’indirizzo dell’istruzione successiva)
Il multiplexer a 2 vie sul secondo ingresso della ALU viene ampliato
a 4 vie
 Una per il valore 4 (per il calcolo dell’indirizzo dell’istruzione successiva)
 Una per il valore dell’indirizzo (16 bit, estesi in segno a 32 e traslati a
sinistra)
CPU (2)
6
Una vista più dettagliata (2)
Indirizzo da PC
o da ALU
Mux su primo
ingresso ALU
Mux su secondo
ingresso ALU
CPU (2)
7
I segnali di controllo
 Nell’unità a ciclo multiplo occorre cambiare anche
l’insieme dei segnali di controllo




Gli elementi di memoria visibili al programmatore (il PC, la
memoria ed i registri) e l’IR hanno bisogno di un segnale
di controllo per la scrittura
La memoria ha anche bisogno di un segnale di controllo
per la lettura
Ciascuno dei due multiplexer a due vie aggiunti ha bisogno
di un segnale di controllo a 1 bit
Il multiplexer a quattro vie ha bisogno di un segnale di
controllo a 2 bit
CPU (2)
8
L’unità con i segnali di controllo
CPU (2)
9
Implementazione dei salti
 Per le istruzioni di jump e branch, ci sono tre possibili sorgenti
per il valore da scrivere in PC



L’output della ALU, con il valore PC+4 calcolato durante la fase di
fetch dell’istruzione
Il registro ALUOut, dove è memorizzato l’indirizzo del branch una
volta che è stato calcolato
I 26 bit meno significativi dell’IR traslati a sinistra di 2 e
concatenati con i 4 bit più significativi del PC incrementato, se
l’istruzione è di jump
CPU (2)
10
Implementazione dei salti: jump
Prelievo dei 26 bit
per jump
Scelta del valore
da scrivere in PC:
0: PC+4
1: indirizzo del
salto condizionato
2: indirizzo
di jump 11
CPU (2)
Implementazione dei salti: beq
In OR con PCWrite
per indicare la
scrittura di PC
Zero (dalla
ALU) AND
PCWriteCond
Scelta del
valore in PC
CPU (2)
12
Il controllo della ALU
ALUOp come
input
3 bit di controllo alla
ALU come output
6 bit di funct
come input
Unità di controllo
della ALU
CPU (2)
13
L’unità di elaborazione multi-ciclo
CPU (2)
14
I segnali di controllo ad 1 bit
Segnale
Effetto quando vale 0
Effetto quando vale 1
RegDst
Registro destinazione = rt
Registro destinazione = rd
RegWrite
Nessuno
Nel registro indicato sull’ingresso Write
register viene scritto il valore Write data
ALUSrcA
Il primo operando di ALU è PC
Il primo operando di ALU è registro A
MemRead
Nessuno
Lettura della locazione di memoria
indicata da Address
MemWrite
Nessuno
Scrittura della locazione di memoria
indicata da Address
MemtoReg
Il valore in Write data (registri)
viene da ALUOut
Il valore in Write data (registri) viene da
MDR
IorD
L’indirizzo proviene da PC
L’indirizzo proviene da ALUOut
IRWrite
Nessuno
Uscita memoria scritta in IR
PCWrite
Nessuno
Scrittura in PC: provenienza da PCSource
PCWriteCond
Nessuno
Scrittura in PC se Zero di ALU è 1
CPU (2)
15
I segnali di controllo a 2 bit
Segnale
Val
Effetto
ALUOp
00
L’ALU calcola la somma
01
L’ALU calcola la sottrazione
10
Operazione determinata dal campo funct
00
Il secondo ingresso della ALU: proviene da reg. B
01
…: è la costante 4
10
…: il valore dei 16 bit meno sign. di IR, estesi a 32
11
…: il valore dei 16 bit meno sign. di IR, estesi a 32,
traslati a sinistra di 2 bit
00
In PC viene scritta l’uscita della ALU (PC+4)
01
In PC viene scritto ALUOut (indirizzo di beq)
10
In PC viene scritto l’indirizzo di jump (26 bit meno
sign. di IR, traslati a sinistra di 2 bit e concatenati
con i 4 bit più sign. di PC)
ALUScrB
PCSource
CPU (2)
16
Esecuzione di una istruzione in più cicli
 Obiettivo:
 Decomporre le istruzioni in modo da bilanciare il carico di
lavoro in ogni ciclo (e minimizzare la durata del ciclo di
clock)
 Suddividiamo le istruzioni in una serie di passi
 Ogni passo coincide con un ciclo di clock
 Ogni passo comprende al più:
 Un’operazione con la ALU
 Un accesso al banco dei registri
 Un accesso alla memoria
 In questo modo, la durata del ciclo di clock sarà
pari alla durata della più lenta di queste tre
operazioni
CPU (2)
17
Alla fine di ciascun ciclo di clock
 Tutti i valori che sono necessari al passo
successivo/Istruzione

Sono memorizzati in qualche componente
 Ad esempio
 Il Program Counter
 Il banco dei registi
 La memoria
 Uno dei registri addizionali
 A, B, MDR oppure ALUOut
 IR (dotato di segnale di controllo per la scrittura)
– IR è l’unico tra i registri addizionali a contenere lo stesso
dato (l’istruzione) per tutti i passi di esecuzione di una
istruzione
CPU (2)
18
Suddivisione in Passi
 Si suddividono le istruzioni nei seguenti passi potenziali – non
tutte le istruzioni le richiedono tutte
1. Prelievo Istruzione e Incremento del PC (IF)

Si preleva l’istruzione in base a PC e si salva in IR. PC e’
incrementato di 4
2. Decodifica Istruzione e Prelievo Registri (ID)


Si leggono i registri rs e rt in caso servano
Si calcola l’indirizzo di salto (nel caso l’istruzione sia di salto).
3. Esecuzione, Calcolo Indirizzo di Memoria, o completamento
salto (EX)

ALU esegue una delle seguenti funzioni in base al tipo di
istruzione
 memory reference
 R-type


branch (Istruzione Completata)
jump (Istruzione Completata)
CPU (2)
19
Suddivisione in Passi
1.
Accesso in Memoria e Completamento Istruzione R (MEM)
 In base al tipo di istruzione



2.
Completamento lettura da Memoria (WB)


Legge dalla memoria
Scrive in memoria (Istruzione Completata)
Scrittura nel Registro Destinazione (Istruzione Completata)
Il dato letto dalla memoria in 4 viene scritto nel registro Destinazione
(Load completato)
Le istruzioni MIPS richiedono da 3 a 5 cicli di clock



Jump e branch:
3 cicli
Formato R, store: 4 cicli
Write:
5 cicli
CPU (2)
20
Prelievo dell’Istruzione (IF)
IR = M[PC];
PC = PC + 4;
PC + 4
4
CPU (2)
21
Decodifica Istruzione e Lettura Registri (ID)
A = Reg[IR[25-21]];
(A = Reg[rs])
B = Reg[IR[20-15]];
(B = Reg[rt])
ALUOut = (PC + sign-extend(IR[15-0]) << 2)
Reg[rs]
Branch
Target
Address
PC + 4
Reg[rt]
CPU (2)
22
Formato R: (EX) – Esecuzione ALU
ALUOut = A op B
Reg[rs]
R-Type
Result
PC + 4
Reg[rt]
CPU (2)
23
Formato R: (MEM) – Scrittura Registro Dest.
Reg[IR[15:11]] = ALUOUT
Reg[rs]
R-Type
Result
PC + 4
Reg[rt]
CPU (2)
24
Decodifica Istruzione e Lettura Registri (ID)
A = Reg[IR[25-21]];
(A = Reg[rs])
B = Reg[IR[20-15]];
(B = Reg[rt])
ALUOut = (PC + sign-extend(IR[15-0]) << 2)
Reg[rs]
Branch
Target
Address
PC + 4
Reg[rt]
CPU (2)
25
Branch: (EX) – Aggiornamento PC
if (A == B) PC = ALUOut;
Reg[rs]
Branch
Target
Address
Branch
Target
Address
Reg[rt]
CPU (2)
26
Decodifica Istruzione e Lettura Registri (ID)
A = Reg[IR[25-21]];
(A = Reg[rs])
B = Reg[IR[20-15]];
(B = Reg[rt])
ALUOut = (PC + sign-extend(IR[15-0]) << 2)
Reg[rs]
Branch
Target
Address
PC + 4
Reg[rt]
CPU (2)
27
Jump: (EX) – Aggiornamento PC
PC = PC[31-28] concat (IR[25-0] << 2)
Reg[rs]
Branch
Target
Address
Jump
Address
Reg[rt]
CPU (2)
28
Decodifica Istruzione e Lettura Registri (ID)
A = Reg[IR[25-21]];
(A = Reg[rs])
B = Reg[IR[20-15]];
(B = Reg[rt])
ALUOut = (PC + sign-extend(IR[15-0]) << 2)
Reg[rs]
Branch
Target
Address
PC + 4
Reg[rt]
CPU (2)
29
Store: (EX) Calcolo Indirizzo
ALUOut = A + sign-extend(IR[15-0]);
Reg[rs]
Mem.
Address
PC + 4
Reg[rt]
CPU (2)
30
Store: (MEM) Scrittura in Memoria
M[ALUOut] = B;
Reg[rs]
PC + 4
Reg[rt]
CPU (2)
31
Decodifica Istruzione e Lettura Registri (ID)
A = Reg[IR[25-21]];
(A = Reg[rs])
B = Reg[IR[20-15]];
(B = Reg[rt])
ALUOut = (PC + sign-extend(IR[15-0]) << 2)
Reg[rs]
Branch
Target
Address
PC + 4
Reg[rt]
CPU (2)
32
Load: (EX) Calcolo Indirizzo
ALUOut = A + sign-extend(IR[15-0]);
Reg[rs]
Mem.
Address
PC + 4
Reg[rt]
CPU (2)
33
Load: (MEM) Lettura in Memoria
MDR = M[ALUOut];
Reg[rs]
Mem.
Address
PC + 4
Mem.
Data
Reg[rt]
CPU (2)
34
Load: (WB) – Scrittura nel Registro Dest.
Reg[IR[20-16]] = MDR;
Reg[rs]
Mem.
Address
PC + 4
Mem.
Data
Reg[rt]
CPU (2)
35
Schema Riassuntivo Implementazione Multiciclo
Step
1: IF
Step name
Instruction fetch
Action for R-type
instructions
Action for memory-reference
Action for
instructions
branches
IR = M[PC]
PC = PC + 4
A = Reg [IR[25-21]]
B = Reg [IR[20-16]]
ALUOut = PC + (sign-extend (IR[15-0]) << 2)
2: ID
Instruction
decode/register fetch
3: EX
Execution, address
computation, branch/
jump completion
ALUOut = A op B
ALUOut = A + sign-extend
(IR[15-0])
4: MEM
Memory access or R-type
completion
Reg [IR[15-11]] =
ALUOut
Load: MDR = M[ALUOut]
or
Store: M[ALUOut] = B
5: WB
Memory read completion
Action for
jumps
if (A ==B) then PC = PC [31-28] II
PC = ALUOut
(IR[25-0]<<2)
Load: Reg[IR[20-16]] = MDR
CPU (2)
36
Controllo
 L’Unita di Controllo deve generare:



I segnali di controllo dell’ALU
Opcode
I segnali di controllo dei vari multiplexer
6
I segnali di abilitazione alla scrittura/lettura
dei diversi elementi di memoria
 In funzione del…
1.
Memorie
Controllo
Controllo MUX
Funct
Tipo di Istruzione da eseguire (Ingresso)

Read/Write
6
Controllo ALU
I bit del campo opcode (e funct nel caso del
formato R) dell’istruzione
2. Step dell’istruzione
 Una rete combinatoria non e’ sufficiente ad
implementare il controllo multiciclo
CPU (2)
37
Controllo Multiplo Ciclo: Rete Sequenziale
 Il controllo sara’ realizzato da
Opcode
una rete sequenziale



Unita’ di Controllo Principale
Unita’ di Controllo ALU
Controllo MUX
Controllo
Funct
6
 Per semplificare la

Memorie
6
Automa a Stati finiti
Micropragramma
progettazione/circuito del
controllo suddivideremo l’unita’
di controllo in
Read/Write
Opcode
Controllo ALU
Read/Write
Memorie
6
Controllo MUX
Controllo
ALUOp
 Per il controllo dell’ALU
useremo la stessa rete
combinatoria vista per
l’implementazione singolo ciclo
2
ALU
Funct
Controllo ALU
Control
6
CPU (2)
38
Implementazione Unita’ di Controllo Principale
 Possiamo implementare l’Unita’ di Controllo come una
rete sequenziale di Moore

Stato: passo di esecuzione dell’istruzione corrente
 IF, ID, Ex-Formato R, Ex-beq, etc…


Ingressi: Opcode Istruzione
Uscite: Segnali di Controllo verso DataPath
Opcode
6
Rete
Combinatoria
Stato
Rete
Combinatoria
Read/Write Memorie
Controllo MUX
ALUOp
2
 Bisogna Specificare
 Funzione Prossimo Stato: Stato(n+1)=F(Stato(n),Ingressi(n))
 Funzione Uscita: Uscite(n)=G(Stato(n))
 Perche’ e’ un automa di Moore
CPU (2)
39
Struttura dell’Automa a Stati Finiti
 I primi due passi sono indipendenti dall’istruzione
 I restanti passi sono differenziati a seconda dell’operazione
 Ciascuna porzione della macchina a stati finiti può essere
composta da più stati
Inizio
Fetch
Decode, Fetch Reg, beq
Calcolo Indirizzo
M-Read
M-Write
R-type EXE
Beq EXE (PC update)
Jump EXE (PC update)
R-Write
R-Write
CPU (2)
40
Segnali di Controllo: (IF)
PC = PC + 4;
ALUSrcA=0, ALUSrcB=01
ALUOp=00
PCWrite=1, PCSource=00
IR = M[PC];
- MemRead=1
- IRWrite=1
- IorD=0
1
IRWrite
I
R
1
Instruction I
rs
PCWr*
0
0
IorD
32
U
1X
5
rt
5
5
0
MUX
rd
1
RN1
MemWrite
ADDR
Memory
RD
M
D
R
RegDst
U
X
RD2
MemRead
1
E
X
T
N
D
32
0
0
1M
U
2X
3
X
3
PCSource
Zero
0
ALU
B
RegWrite
16
010
1X
A
4
0
immediate
M
1U
Operation
0M
MemtoReg
X
2
U
RD1
WD
WD
CONCAT
0
ALUSrcA
WN
Registers
1M
0X
RN2
32
<<2
I[25:0]
5
PC
0M
28
jmpaddr
ALU
OUT
ALUSrcB
<<2
1
CPU (2)
41
Segnali di Controllo: (ID)
A = Reg[IR[25-21]]; (A = Reg[rs])
B = Reg[IR[20-15]]; (B = Reg[rt])
- A e B sempre sovrascritti
(nessun segnale di controllo)
ALUOut = (PC + sign-extend(IR[15-0]) << 2);
ALUSrcA=0, ALUSrcB=11
ALUOp=00
0IRWrite
I
R
0
PCWr*
Instruction I
rs
X
0
IorD
32
U
1X
5
0
MUX
rd
1
RN1
RD
M
D
R
U
RD1
WD
WD
RD2
MemRead
X
4
0
immediate
16
E
X
T
N
D
32
M
010
1U
0
0
1M
U
2X
3
X
3
PCSource
Zero
X
ALU
B
RegWrite
2
U
1X
A
X
CONCAT
ALUSrcA
Operation
0M
MemtoReg
0
0
RegDst
WN
Registers
1M
0X
RN2
32
<<2
I[25:0]
5
MemWrite
ADDR
Memory
5
rt
5
PC
0M
28
jmpaddr
ALU
OUT
ALUSrcB
<<2
3
CPU (2)
42
Segnali di Controllo: (EX) Formato R - ALU
ALUOut = A op B;
- ALUSrcA=1, ALUSrcB=00
- ALUOp=10 (Operation dipende da Funct)
- ALUOut riscritto0 ad ogni ciclo)
IRWrite
I
R
0
PCWr*
Instruction I
rs
X
32
0
IorD
U
1X
5
0
MUX
rd
1
RN1
RD
M
D
R
U
RD1
WD
WD
RD2
MemRead
X
0
16
E
X
T
N
D
32
M
1U
???
0
B
0
1M
U
2X
3
X
3
PCSource
Zero
X
ALU
4
0
immediate
2
U
1X
A
RegWrite
CONCAT
ALUSrcA
Operation
0M
MemtoReg
X
1
RegDst
WN
Registers
1M
0X
RN2
32
<<2
I[25:0]
5
MemWrite
ADDR
Memory
5
rt
5
PC
0M
28
jmpaddr
ALU
OUT
ALUSrcB
<<2
0
CPU (2)
43
Segnali di Controllo: (MEM) Formato R –
Scrittura Registro Destinazione
Reg[IR[15:11]] = ALUOut;
- RegDest=1
- ReWrite=1
- MemtoReg=0
0
(Reg[Rd] = ALUOut)
IRWrite
I
R
0
Instruction I
rs
PCWr*
X
32
0
IorD
U
1X
5
0
MUX
rd
1
RN1
RD
M
D
R
1
0
M
U
X
RN2
1
RD2
0
immediate
E
X
T
N
D
32
1U
XXX
0
0
1M
U
2X
3
X
3
PCSource
Zero
ALU
B
RegWrite
1
M
1X
A
4
16
2
Operation
0M
MemtoReg
0
X
ALUSrcA
CONCAT
U
RD1
WD
WD
MemRead
RegDst
WN
Registers
32
<<2
I[25:0]
5
MemWrite
ADDR
Memory
5
rt
5
PC
0M
28
jmpaddr
ALU
OUT
X
ALUSrcB
<<2
X
CPU (2)
44
Segnali di Controllo: (ID)
A = Reg[IR[25-21]]; (A = Reg[rs])
B = Reg[IR[20-15]]; (B = Reg[rt])
- A e B sempre sovrascritti
(nessun segnale di controllo)
ALUOut = (PC + sign-extend(IR[15-0]) << 2);
ALUSrcA=0, ALUSrcB=11
ALUOp=00
0IRWrite
I
R
0
PCWr*
Instruction I
rs
X
0
IorD
32
U
1X
5
0
MUX
rd
1
RN1
RD
M
D
R
U
RD1
WD
WD
RD2
MemRead
X
4
0
immediate
16
E
X
T
N
D
32
M
010
1U
0
0
1M
U
2X
3
X
3
PCSource
Zero
X
ALU
B
RegWrite
2
U
1X
A
X
CONCAT
ALUSrcA
Operation
0M
MemtoReg
0
0
RegDst
WN
Registers
1M
0X
RN2
32
<<2
I[25:0]
5
MemWrite
ADDR
Memory
5
rt
5
PC
0M
28
jmpaddr
ALU
OUT
ALUSrcB
<<2
3
CPU (2)
45
Segnali di Controllo: (EX) Branch – Agg. PC
if (A == B) PC = ALUOut;
- ALUSrcA=1, ALUSrcB=00
- ALUOp=01
- PCWrite=0, PCWriteCond=1, PCSource=01
0
IRWrite
1 if
Zero=1
PCWr*
X
I
R
Instruction I
rs
32
0
IorD
U
1X
5
0
MUX
rd
1
RN1
RD
M
D
R
U
X
RD2
0
16
E
X
T
N
D
32
1U
0
0
1M
U
2X
3
X
3
PCSource
Zero
1
ALU
B
RegWrite
M
110
1X
A
4
0
immediate
2
ALUSrcA
Operation
0M
MemtoReg
X
CONCAT
U
RD1
WD
WD
MemRead
1
RegDst
WN
Registers
1M
0X
RN2
32
<<2
I[25:0]
5
MemWrite
ADDR
Memory
5
rt
5
PC
0M
28
jmpaddr
ALU
OUT
ALUSrcB
<<2
0
CPU (2)
46
Segnali di Controllo: (ID)
A = Reg[IR[25-21]]; (A = Reg[rs])
B = Reg[IR[20-15]]; (B = Reg[rt])
- A e B sempre sovrascritti
(nessun segnale di controllo)
ALUOut = (PC + sign-extend(IR[15-0]) << 2);
ALUSrcA=0, ALUSrcB=11
ALUOp=00
0IRWrite
I
R
0
PCWr*
Instruction I
rs
X
0
IorD
32
U
1X
5
0
MUX
rd
1
RN1
RD
M
D
R
U
RD1
WD
WD
RD2
MemRead
X
4
0
immediate
16
E
X
T
N
D
32
M
010
1U
0
0
1M
U
2X
3
X
3
PCSource
Zero
X
ALU
B
RegWrite
2
U
1X
A
X
CONCAT
ALUSrcA
Operation
0M
MemtoReg
0
0
RegDst
WN
Registers
1M
0X
RN2
32
<<2
I[25:0]
5
MemWrite
ADDR
Memory
5
rt
5
PC
0M
28
jmpaddr
ALU
OUT
ALUSrcB
<<2
3
CPU (2)
47
Segnali di Controllo: (EX) Jump – Agg. PC
PC = PC[21-28] concat (IR[25-0] << 2);
- PCWrite=1, PCSource=10
0
IRWrite
I
R
1
Instruction I
rs
PCWr*
X
32
0
IorD
U
1X
5
0
MUX
rd
1
RN1
RD
M
D
R
U
RD2
0
immediate
X
ALUSrcA
X
E
X
T
N
D
32
1U
XXX
0
0
1M
U
2X
3
X
3
PCSource
Zero
ALU
B
RegWrite
0
M
1X
A
4
16
2
Operation
0M
MemtoReg
X
CONCAT
U
RD1
WD
WD
MemRead
RegDst
WN
Registers
1M
0X
RN2
32
<<2
I[25:0]
5
MemWrite
ADDR
Memory
5
rt
5
PC
0M
28
jmpaddr
ALU
OUT
2
ALUSrcB
<<2
X
CPU (2)
48
Segnali di Controllo: (ID)
A = Reg[IR[25-21]]; (A = Reg[rs])
B = Reg[IR[20-15]]; (B = Reg[rt])
- A e B sempre sovrascritti
(nessun segnale di controllo)
ALUOut = (PC + sign-extend(IR[15-0]) << 2);
ALUSrcA=0, ALUSrcB=11
ALUOp=00
0IRWrite
I
R
0
PCWr*
Instruction I
rs
X
0
IorD
32
U
1X
5
0
MUX
rd
1
RN1
RD
M
D
R
U
RD1
WD
WD
RD2
MemRead
X
4
0
immediate
16
E
X
T
N
D
32
M
010
1U
0
0
1M
U
2X
3
X
3
PCSource
Zero
X
ALU
B
RegWrite
2
U
1X
A
X
CONCAT
ALUSrcA
Operation
0M
MemtoReg
0
0
RegDst
WN
Registers
1M
0X
RN2
32
<<2
I[25:0]
5
MemWrite
ADDR
Memory
5
rt
5
PC
0M
28
jmpaddr
ALU
OUT
ALUSrcB
<<2
3
CPU (2)
49
Segnali di Controllo: (EX) Store – Calc. Indirizzo
ALUOut = A + sign-extend(IR[15-0]);
- ALUSrcA=1, ALUSrcB=10
- ALUOp=00
0
IRWrite
I
R
0
Instruction I
rs
PCWr*
X
IorD
32
0
U
1X
5
0
MUX
rd
1
RN1
RD
M
D
R
U
RD2
0
immediate
1
ALUSrcA
X
E
X
T
N
D
32
1U
010
0
0
1M
U
2X
3
X
3
PCSource
Zero
ALU
B
RegWrite
0
M
1X
A
4
16
2
Operation
0M
MemtoReg
X
CONCAT
U
RD1
WD
WD
MemRead
RegDst
WN
Registers
1M
0X
RN2
32
<<2
I[25:0]
5
MemWrite
ADDR
Memory
5
rt
5
PC
0M
28
jmpaddr
ALU
OUT
X
ALUSrcB
<<2
2
CPU (2)
50
Segnali di Controllo: (MEM) Store – Scr. in Memoria
Memory[ALUOut] = B;
- IorD=1
- MemWrite=1
IRWrite
I
R
0
0
Instruction I
rs
PCWr*
1
32
1
IorD
U
1X
5
0
MUX
rd
1
RN1
RD
M
D
R
U
X
RD2
0
immediate
E
X
T
N
D
32
1U
XXX
0
0
1M
U
2X
3
X
3
PCSource
Zero
ALU
B
RegWrite
0
M
1X
A
4
16
2
ALUSrcA
Operation
0M
MemtoReg
X
X
CONCAT
U
RD1
WD
WD
MemRead
RegDst
WN
Registers
1M
0X
RN2
32
<<2
I[25:0]
5
MemWrite
ADDR
Memory
5
rt
5
PC
0M
28
jmpaddr
ALU
OUT
X
ALUSrcB
<<2
X
CPU (2)
51
Segnali di Controllo: (ID)
A = Reg[IR[25-21]]; (A = Reg[rs])
B = Reg[IR[20-15]]; (B = Reg[rt])
- A e B sempre sovrascritti
(nessun segnale di controllo)
ALUOut = (PC + sign-extend(IR[15-0]) << 2);
ALUSrcA=0, ALUSrcB=11
ALUOp=00
0IRWrite
I
R
0
PCWr*
Instruction I
rs
X
0
IorD
32
U
1X
5
0
MUX
rd
1
RN1
RD
M
D
R
U
RD1
WD
WD
RD2
MemRead
X
4
0
immediate
16
E
X
T
N
D
32
M
010
1U
0
0
1M
U
2X
3
X
3
PCSource
Zero
X
ALU
B
RegWrite
2
U
1X
A
X
CONCAT
ALUSrcA
Operation
0M
MemtoReg
0
0
RegDst
WN
Registers
1M
0X
RN2
32
<<2
I[25:0]
5
MemWrite
ADDR
Memory
5
rt
5
PC
0M
28
jmpaddr
ALU
OUT
ALUSrcB
<<2
3
CPU (2)
52
Segnali di Controllo: (EX) Load – Calc. Indirizzo
ALUOut = A + sign-extend(IR[15-0]);
- ALUSrcA=1, ALUSrcB=10
- ALUOp=00
0
IRWrite
I
R
0
Instruction I
rs
PCWr*
X
IorD
32
0
U
1X
5
0
MUX
rd
1
RN1
RD
M
D
R
U
RD2
0
immediate
1
ALUSrcA
X
E
X
T
N
D
32
1U
010
0
0
1M
U
2X
3
X
3
PCSource
Zero
ALU
B
RegWrite
0
M
1X
A
4
16
2
Operation
0M
MemtoReg
X
CONCAT
U
RD1
WD
WD
MemRead
RegDst
WN
Registers
1M
0X
RN2
32
<<2
I[25:0]
5
MemWrite
ADDR
Memory
5
rt
5
PC
0M
28
jmpaddr
ALU
OUT
X
ALUSrcB
<<2
2
CPU (2)
53
Segnali di Controllo: (MEM) Load – Lett. in Memoria
MDR = Memory[ALUOut];
- IorD=1
- MemRead=1
IRWrite
I
R
0
PCWr*
0
Instruction I
1
32
0
IorD
U
1X
0
MUX
rd
1
RN2
RN1
RD
M
D
R
U
0X
X
RD2
1
16
E
X
T
N
D
32
0
0
1M
U
2X
3
X
3
PCSource
Zero
X
ALU
B
RegWrite
M
1U
XXX
1X
A
4
0
immediate
2
ALUSrcA
Operation
0M
MemtoReg
X
CONCAT
U
RD1
WD
WD
MemRead
X
RegDst
WN
Registers
1M
<<2
I[25:0]
5
MemWrite
ADDR
Memory
5
5
PC
0M
5
rt
rs
32
28
jmpaddr
ALU
OUT
ALUSrcB
<<2
X
CPU (2)
54
Segnali di Controllo: (WB) Load – Scr. Registro di
Destinazione
Reg[IR[20-16]] = MDR;
- RegDest=0
- RegWrite=1
- MemtoReg=0
IRWrite
I
R
0
PCWr*
0
Instruction I
rs
X
32
0
IorD
U
1X
5
0
MUX
rd
1
RN1
RD
M
D
R
0
1
M
U
X
RN2
RD2
0
0
immediate
1
E
X
T
N
D
32
0
0
1M
U
2X
3
X
3
PCSource
Zero
X
ALU
B
RegWrite
M
1U
XXX
1X
A
4
16
2
Operation
0M
MemtoReg
0
ALUSrcA
CONCAT
U
RD1
WD
WD
MemRead
X
RegDst
WN
Registers
32
<<2
I[25:0]
5
MemWrite
ADDR
Memory
5
rt
5
PC
0M
28
jmpaddr
ALU
OUT
ALUSrcB
<<2
X
CPU (2)
55
Struttura dell’Automa a Stati Finiti
 I primi due passi sono indipendenti dall’istruzione
 I restanti passi sono differenziati a seconda dell’operazione
 Ciascuna porzione della macchina a stati finiti può essere
composta da più stati
Inizio
Fetch
Decode, Fetch Reg, beq
Calcolo Indirizzo
M-Read
M-Write
R-type EXE
Beq EXE (PC update)
Jump EXE (PC update)
R-Write
R-Write
CPU (2)
56
L’Automa a stati finiti completo
Tutti i segnali di
scrittura che non
appaiono sono pari a 0
Tutti i segnali di
controllo dei mux che non
appaiono sono pari ad X
CPU (2)
57
Unita’ di Controllo: Funzione di Uscita
Outputs
Input Values (Current State[3-0])
0000
0001
0010
0011
0100
0101
0110
0111
1000
1001
PCWrite
1
0
0
0
0
0
0
0
0
1
PCWriteCond
X
0
0
0
0
0
0
0
1
X
IorD
0
X
X
1
X
1
X
X
X
X
MemRead
1
0
0
1
0
0
0
0
0
0
MemWrite
0
0
0
0
0
1
0
0
0
0
IRWrite
1
0
0
0
0
0
0
0
0
0
MemtoReg
X
X
X
X
1
X
X
0
X
X
PCSource
00
XX
XX
XX
XX
XX
XX
XX
01
10
ALUOp
00
00
00
XX
XX
XX
10
XX
01
XX
ALUSrcB
01
11
10
XX
XX
XX
00
XX
00
XX
ALUSrcA
0
0
1
X
X
X
1
X
1
X
RegWrite
0
0
0
0
1
0
0
1
0
0
CPU (2)
58
Unita’ di Controllo: Funzione Prossimo Stato
Current
Inst[31-26]
State 000000 000010 000100
[3-0]
(R(jmp)
(beq)
type)
(Op[5-0])
100011
(lw)
101011
(sw)
Any
other
0000
0001
0001
0001
0001
0001
0001
0001
0110
1001
1000
0010
0010
illegal
0010
XXXX
XXXX
XXXX
0011
0101
illegal
0011
XXXX
XXXX
XXXX
0100
XXXX
illegal
0100
XXXX
XXXX
XXXX
0000
XXXX
illegal
0101
XXXX
XXXX
XXXX
XXXX
0000
illegal
0110
0111
XXXX
XXXX
XXXX
XXXX
illegal
0111
0000
XXXX
XXXX
XXXX
XXXX
illegal
1000
XXXX
XXXX
0000
XXXX
XXXX
CPU
(2)
illegal
59
Diagramma a blocchi della CPU (Datapath e Control) e
Memoria
Registro di Stato
Operation=f(ALUOp,funct)
PCSoruce
Addr
Memoria
CONTROLLO
PCWrite+(Zero*PCWriteCond)
RegDstALUSrcA/B MemtoReg
Opcode
Funct
A
IR
B
PC
MDR
IorD IRWrite
MemWr MemRd
RegWr
Zero
ALU
ALUOut
DATAPATH
Register
file
CPU (2)
60
Implementazione dell’unità di controllo
dall’Automa a Stati Finiti
 La macchina a stati
PCWrite
PCWriteCond
IorD
MemRead
finiti può essere
implementata usando
IRWrite
Control logic
MemtoReg
PCSource
ALUOp
Outputs
ALUSrcB
ALUSrcA
RegWrite
RegDst
 Realizzabile tramite
PLA o ROM
NS3
NS2
NS1
NS0
Instruction register
opcode field
S0
S1
S2
S3
Op0
Op1
Op2
Op3
Inputs
Op4

Un registro
temporaneo che
memorizza lo stato
corrente
Un blocco di logica
combinatoria che
determina i segnali e
lo stato futuro
Op5

MemWrite
State register
CPU (2)
61
Implementazione Controllo Tramite PLA
 Blocco combinatorio della
rete sequenziale puo’ essere
implementato con logica
digitale a 2 livelli

PLA
 Numero minimo di porte
logiche
 # celle=


#ingresso*#termini
prodotto+#uscite*termini
prodotto
10*17+20*17=510 celle PLA
 Non modificabile

Poco flessibile
 Soluzione efficiente per
piccoli circuiti
O p5
O p4
O p3
O p2
O p1
O p0
S3
S2
S1
S0
P C W r ite
P C W r ite C o n d
Io rD
M em Read
M e m W r ite
IR W rite
M e m to R e g
P C S o u rc e 1
P C S o u rc e 0
ALU O p1
ALU O p0
A L U S rc B 1
A L U S rc B 0
A L U S rc A
R e g W r ite
R egD st
NS3
NS2
NS1
NS0
CPU (2)
62
Reti Combinatorie e ROM
 ROM (Read Only Memory)

I valori delle varie celle di memoria sono fissati
 Le ROM possono essere usate per implementare Tabelle di
Verita’=Reti Combinatorie


Se l’indirizzo e’ di m-bit, possiamo indirizzzare 2m celle della
ROM
Le uscite della ROM corrispondono ai contenuti della varie celle
indirizzate dai m bit dell’indirizzo
 Tabella di Verita’ con m variabili in ingresso e n di output

Sufficiente una ROM di 2mxn bit
Input
Output
=
=
indirizzo Contenuto celle
m = 3
n = 4
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
m
ROM
n
CPU (2)
63
Implementazione del Controllo tramite ROM
 Rete combinatoria dell’unita’ di controllo ha:

10 linee in ingresso
 6 bit opcode
 4 bit stato
 Indirizzo=<Opcode,Stato>

20 linee di output
 16 bit di segnali di controllo
 4 bit di stato
 Realizzazione ROM richiede
210x20=20Kbits
 Soluzione inefficiente

Stato
0000
0001
0010
0011
0100
0101
0110
0111
1000
1001
__Uscita (Linee di Controllo)
1001010000001000
0000000000011000
0000000000101000
0011000000000000
0000001000000010
0010100000000000
0000000001000100
0000000000000011
0100000010100100
1000000100000000
16 bit di uscita (segnali di controllo) dipendono solo dai
4 bit dello stato
 Automa di Moore
 indirizzi <XXX,Stato>, al variare di XXX i 16 bit relativi
alle linee di controllo sono identici
 Per molti stati le transizioni non dipendono dall’opcode
 Per molti indirizzi <XXX,Stato>, al variare di XXX i
contenuti delle celle spesso sono identici
CPU (2)
64
Implementazione del Controllo tramite ROM
 Implementare separatamente le
tabelle di verita’ delle funzioni F
(uscita) e G (prossimo stato)

F: 4 bit di stato determinano le 16
uscite (di controllo)
 ROM di 24x16b=0.25Kb

G: 10 bit (4 stato+6 opcode)
determinano il prossimo stato
 ROM di 210x4b=4Kb

Totale 4.25Kbit >> numero celle PLA
Stato
0000
0001
0010
0011
0100
0101
0110
0111
1000
1001
__Uscita (Linee di Controllo)
1001010000001000
0000000000011000
0000000000101000
0011000000000000
0000001000000010
0010100000000000
0000000001000100
0000000000000011
0100000010100100
1000000100000000
 PLA ottimizza la rete grazie ai molti
DON’T CARE

Data la struttura degli automi di
Moore, la dimensione della ROM e’
dominata dalla funzione G
 4Kb vs 0.25Kb
Si puo’ semplificare
l’implementazione
sfruttando la
struttura di G?
CPU (2)
65
Altro Stile di Implementazione


1.
Implementare F come prima
Per G osservare che:
Spesso la funzione stato
successivo e’:
Stato(n+1)=Stato(n)+1



1.
1.
0->1
3->4
6->7
IF->ID
lw(MEM)->lw(WB)
f. R(EX)->f. R(MEM)
o semplicemente a fine
istruzione:
Stato(n+1)=0
Tuttavia alcune volte
Stato(n+1)=G(Stato(n),Opcode)
 Stato 1 e 2
CPU (2)
66
Implementazione con un Sequenzializzatore
 Inserire:
1.
Contatore
 Incremento Stato
2.
Logica selezione prossimo
stato
 Per i “salti”
 Aggiungere un segnale
di controllo AddrCtrl
che controlla come si
determina il prossimo
stato:



Stato(n)+1
0
In base a
Stato(n)+Opcode
CPU (2)
67
Sequenzializzatore in
dettaglio
Rom
CPU (2)
68
Sequenzializzatore: Contenuto della Memoria di Controllo
Stato
Uscita
Linee di Controllo
Funzione F
0000
0001
0010
0011
0100
0101
0110
0111
1000
1001
AddrCtl
1001010000001000
0000000000011000
0000000000101000
0011000000000000
0000001000000010
0010100000000000
0000000001000100
0000000000000011
0100000010100100
1000000100000000
11
01
10
11
00
00
11
00
00
00
Funzione G
CPU (2)
69
Microprogrammazione
 Unita’ di Controllo e’ la parte piu’ complessa del
Processore

Controllo di un set completo ISA ha centinaia/migliaia di
stati
 Rappresentazione Grafica dell’Unita’ di Controllo
estramamente complessa
 Necessita’ Strumento Progettuale piu’ Efficace:
Microprogrammazione
 Obiettivo: Impiegare una Rappresentazione Simbolica
dell’Unita’ di Controllo – Microprogramma


Richiama il formato di un programma
La logica di controllo si ottiene sintetizzando il
microprogramma con prodotti CAD
CPU (2)
70
Microprogrammazione
 Idea: Considerare i segnali di controllo
che devono essere affermati ad un
certo passo come una (micro)istruzione
da far eseguire dal DataPath

“Eseguire” una microistruzione significa
affermare i segnali di controllo specificati
dalla microistruzione
 Microistruzione specifica:
 I segnali di controllo da affermare
 La prossima microistruzione
Stato
Uscita
Linee di Controllo
0000
0001
0010
0011
0100
0101
0110
0111
1000
1001
AddrCtl
1001010000001000
0000000000011000
0000000000101000
0011000000000000
0000001000000010
0010100000000000
0000000001000100
0000000000000011
0100000010100100
1000000100000000
11
01
10
11
00
00
11
00
00
00
 Microistruzione corrisponde ad uno
Stato dell’Automa di Controllo
microistruzione
 Microprogramma: Sequenza di
Microistruzioni in forma simbolica
CPU (2)
71
Campi Microistruzione per il Processore
Multi-Ciclo
Campo
Segnali di
Controllo
Funzione
ALU
control
ALUOp
Operazione compiuta da ALU; risultato in ALUOut
SRC1
ALUSrcA
Provenienza primo operando ALU
SRC2
ALUSrcB
Provenienza secondo operando ALU
Register
control
RegWrite,
RegDest,
MemtoReg
Lettura o scrittura dei registri nel banco e
provenienza dei valori in caso di scrittura
Memory
MemRead,Mem
Write, IorD
Lettura o scrittura della memoria e provenienza dei
dati; in caso di lettura specifica il registro di
destinazione
PCWrite
control
PCWrite,
PCSource,
PRWriteCond
Modalità di aggiornamento di PC
Sequencing
AddrCtl
Modalità di scelta dell’istruzione successiva
CPU (2)
73
I valori dei campi
Etichetta stringa
ALU
Add
control
Indica l’etichetta (label) dell’istruzione
ALU deve sommare
ALU deve sottrarre
ALU deve usare funct per l’operazione
SRC1
SRC2
PC
PC è il primo operando della ALU
A
Registro A è il primo operando della ALU
B
Registro B è il secondo operando della ALU
4
Il valore 4 è il secondo operando della ALU
Extend
Uscita esten. segno è il sec. operando della ALU
Extshift
Uscita shift è il secondo operando della ALU
CPU (2)
74
I valori dei campi (2)
Register
control
Memory
PCWrite
control
Read
Legge i due registri usando IR, output in A e B
Write ALU
Scrive usando rd come registro e ALUOut come dato
Write MDR
Scrive usando rt come registro e MDR come dato
Read PC
Legge la memoria usando PC, risultato in IR e MDR
Read ALU
Legge la memoria usando ALUOut, risultato in MDR
Write ALU
Scrive la memoria usando ALUOut e B
ALU
Scrive uscita della ALU in PC
ALUout-cond Se Zero vale 1, scrive in PC il valore di ALUOut
Jump address Scrive in PC l’indirizzo di salto preso dall’istruzione
Sequencing Seq
Vai alla microistruzione successiva
Fetch
Vai alla prima microistruzione
Dispatch i
Usa la tabella di Dispatch per indicare la prossima
CPU (2)
istr.
75
Scelta della microistruzione successiva
Le microistruzioni sono memorizzate in una ROM o PLA

Possiamo assegnare degli indirizzi alle microistruzioni
Diverse possibilità per scegliere la microistruzione successiva
1.
Passare alla microistruzione seguente
 Il campo Sequencing viene messo al valore Seq
2.
Passare alla microistruzione che inizia l’esecuzione della prossima
istruzione MIPS
 La prima microistruzione ha un’etichetta Fetch
 Il campo Sequencing viene messo al valore Fetch
3.
Passare alla microistruzione a seconda di valori indicati in input
all’unità di controllo
 Si usa una tabella di Dispatch (solitamente una ROM)
 Il campo Sequencing viene messo al valore Dispatch i
– i è un valore che viene passato alla tabella di Dispatch che
restituisce la prossima istruzione a seconda del valore dei 6 bit
del campo Op che vengono passati all’unità di controllo
CPU (2)
76
I primi due passi (prelievo e decodifica)
 Incremento del Program Counter e scrittura ALU
dell’incremento
 Lettura istruzione indicata da PC (in IR)
 Salto alla microistruzione indicata dalla tabella di Dispatch
Label
ALU
control
SRC1
SRC2
Fetch
Add
PC
4
Add
PC
Extshift
Register Memory
control
Read PC
Read
PCWrite
control
Sequencing
ALU
Seq
Dispatch 1
CPU (2)
77
Le etichette del Dispatch
 Servono a differenziare i 4 tipi di istruzioni

Una specie di switch
 Esistono 4 etichette




Mem1
Rformat1
BEQ1
JUMP1
 Le informazioni sono memorizzate in una ROM
Op
000000
000010
000100
100011
101011
Dispatch ROM 1
Opcode name
R-format
jmp
beq
lw
sw
Value
Rformat1
JUMP1
BEQ1
Mem1
Mem1
CPU (2)
78
Istruzioni di accesso alla memoria
 Calcolo indirizzo
 Dispatch 2 per determinare prossima micro-istruzione
 Due passi per l’istruzione lw ()
 Un passo per l’istruzione sw
Label
ALU
control
SRC1
SRC2
Mem1
Add
A
Extend
Register
control
Op
100011
101011
Memory
PCWrite
control
Value
LW2
SW2
Sequencing
Dispatch 2
LW2
Read ALU
Write
MDR
SW2
Dispatch ROM 2
Opcode name
lw
sw
Seq
Fetch
Write
ALU
Fetch
CPU (2)
79
Istruzioni di tipo R
 Operazione indicata dal campo funct
 Scrittura nel registro del risultato dell’operazione
 Torna alla microistruzione con label Fetch
Label
ALU
control
SRC1
SRC2
Rformat1
Func
A
B
Register
control
Memory
PCWrite
control
Sequencing
Seq
Write
ALU
Fetch
CPU (2)
80
Istruzione di branch
 Effettua la sottrazione tra A e B

Il risultato non interessa, serve soltanto la linea Zero
 Scrittura del PC calcolato nel passo precedente solamente se la
linea Zero della ALU è pari ad 1
 Torna alla microistruzione con label Fetch
Label
ALU
control
SRC1
SRC2
BEQ1
Sub
A
B
Register
control
Memory
PCWrite
control
Sequencing
ALUOutcond
Fetch
CPU (2)
81
Istruzione di jump
 Scrittura del PC con il nuovo indirizzo
 Torna alla microistruzione con label Fetch
Label
JUMP1
ALU
control
SRC1
SRC2
Register
control
Memory
PCWrite
control
Sequencing
Jump
address
Fetch
CPU (2)
82
Microprogramma di Controllo Completo
Op
000000
000010
000100
100011
101011
Dispatch ROM 1
Opcode name
R-format
jmp
beq
lw
sw
Value
Rformat1
JUMP1
BEQ1
Mem1
Mem1
Op
100011
101011
Dispatch ROM 2
Opcode name
lw
sw
Value
LW2
SW2
CPU (2)
83
Codifica Microistruzioni
CPU (2)
84
Codifica Microistruzioni
Field name
Memory
Value
Read PC
Read ALU
Write ALU
ALU
PC write
control
Sequencing
ALUOut
-cond
jump
address
Seq
Fetch
Dispatch 1
Dispatch 2
Signals active
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
Comment
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.
CPU (2)
85
Implementazione
 Il Microprogramma e’ una
rappresentazione
alternativa di un automa a
stati finiti

Implementabile secondo lo
schema con
sequenzializzatore visto
prima dove
 ROM<-> Memoria
Microcodice
 Stato<-> Contatore di
Microprogramma
CPU (2)
86
Unita’ di Controllo Microprogrammata
 Il Processore “interpreta” le istruzioni macchina in
memoria


Legge istruzioni in memoria (scritte in L2)
Ne simula il comportamento passo passo “eseguendo” una
sequenza di microistruzioni (in L1)
 L’Unita’ di Controllo genera i segnali di controllo e determina
il sequenziamento
 Il Datapath realizza le operazioni ed il trasferimento fra
registri secondo i segnali di controllo
 Il Microprogramma dell’Unita’ di Controllo (scritto
in L1) e’ l’interprete del linguaggio macchina (L2)
CPU (2)
87
Riassunto Metodi Alternativi per Specificare ed
Implementare l’Unita’ di Controllo
Rappresentazione
Iniziale
Automa a
Stati Finiti
Microprogramma
Controllo del
Sequenziamento
Funzione pross.
Stato in forma
esplicita
Contatore+
Tabelle di dispatch
Rappresentazione
Equazione booleane
Logica
Implementazione
PLA
Controllo
Cablato
Tabelle di Verita’
ROM
Controllo
Microprogrammato
CPU (2)
88
Microprogrammazione: Pro e Contro
 Vantaggi nella Progettazione


Semplicita’ nella progettazione e scrittura
Design congiunto dell’architettura e del microprogramma
 Vantaggi nell’Implementazione


Facile da modificare (implementazione su off-chip ROM – anni ’60’70)
Permette l’emulazione di altre ISA
 Svantaggi dell’Implementazione

Controllo e’ oggi sullo stesso chip del processore

ROM e’ oggi (relativamente) lenta rispetto alle altre memorie

Non c’e’ piu’ necessita’ di cambiare il microprogramma di controllo
 Computer general purpose
CPU (2)
89
Eccezioni
 La gestione delle eccezioni e degli interrupt è una delle parti più
difficili del controllo
 Eccezione: un evento non atteso, interno al processore, che
interrompe l’esecuzione del programma

Esempi: overflow aritmetico, istruzione non definita
 Interrupt: un evento non atteso, esterno al processore, che
interrompe l’esecuzione del programma

Esempi: richiesta di un dispositivo di I/O, malfunzionamento
hardware
 Nella terminologia MIPS: interrupt  eccezione
 Nella terminologia IA-32: non c’è distinzione tra interrupt ed
eccezione
CPU (2)
90
Gestione delle eccezioni
 Quando avviene un’eccezione occorre




Salvare nel registro EPC (Exception Program Counter) l’indirizzo
dell’istruzione che ha causato l’eccezione
Trasferire il controllo al sistema operativo a qualche indirizzo
specifico per la gestione dell’eccezione
Il sistema operativo, dopo aver eseguito le azioni necessarie, può
terminare il programma o continuarne l’esecuzione usando EPC per
determinare da dove riprendere l’esecuzione
Oltre a EPC, il sistema operativo deve conoscere la ragione
dell’eccezione; esistono due meccanismi
 Registro di stato (Cause register nel MIPS): contiene un campo che
indica la causa dell’eccezione
 Interrupt vettorializzato: l’indirizzo a cui trasferire il controllo è
determinato dalla causa dell’eccezione
 Consideriamo due tipi di eccezioni nell’implementazione a ciclo
multiplo


Esecuzione di un’istruzione non definita
Overflow aritmetico
CPU (2)
91
Gestione delle eccezioni (2)
 Per gestire le eccezioni nel MIPS occorre aggiungere
nell’unità di elaborazione


Registro EPC a 32 bit
Registro Cause a 32 bit
 Istruzione non definita: Cause = 0
 Overflow aritmetico: Cause = 1
 Aggiungiamo due segnali di controllo per abilitare la scrittura
dei registri EPC e Cause: EPCWrite e CauseWrite
 Aggiungiamo un altro segnale di controllo per settare il bit
meno significativo del registro Cause: IntCause
 Occorre scrivere in PC l’indirizzo di eccezione (punto di
ingresso del sistema operativo per gestire le eccezioni)


Nel MIPS, l’indirizzo di eccezione è (8000 0180)16
Modifichiamo il multiplexer in ingresso a PC da tre a quattro vie
 PCSource = 11 per abilitare l’indirizzo di eccezione
CPU (2)
92
L’unità a ciclo multiplo con la gestione delle
eccezioni
Indirizzo di
eccezione
EPC: usiamo
ALU per
sottrarre 4 a
PC
CPU (2)
93
La macchina a stati finiti con la gestione delle
eccezioni
CPU (2)
94