architetture dei calcolatori (lettere j-z) il processore (2) ing. davide damico
Post on 01-May-2015
218 Views
Preview:
TRANSCRIPT
Architetture dei Architetture dei CalcolatoriCalcolatori
(Lettere j-z)(Lettere j-z)
Il Processore (2) Il Processore (2)
Ing. Davide D’AmicoIng. Davide D’Amico
CPU (2) 2
Suddividere l’esecuzione di una istruzione in Suddividere l’esecuzione di una istruzione in piu’ passi (steps) piu’ passi (steps) Fetch, Decode, Execute, Memory Access, Write Fetch, Decode, Execute, Memory Access, Write
BackBack Ogni passo richiede un ciclo di clockOgni passo richiede un ciclo di clock Istruzioni diverse possono richiedere un numero Istruzioni diverse possono richiedere un numero
diverso di passi (cicli) diverso di passi (cicli) I passi scelti in modo da bilanciare il carico di lavoroI passi scelti in modo da bilanciare il carico di lavoro
In modo da minimizzare la durata del ciclo di clockIn modo da minimizzare la durata del ciclo di clock
Assunzione: in un passo/ciclo di clock si puo’ Assunzione: in un passo/ciclo di clock si puo’ effettuare una sola operazione tra:effettuare una sola operazione tra: Accesso in memoriaAccesso in memoria Accesso al banco dei registri (lettura o scrittura)Accesso al banco dei registri (lettura o scrittura) Operazione ALUOperazione ALU
Approccio MulticicloApproccio Multiciclo
CPU (2) 3
Approccio MulticicloApproccio Multiciclo
Alla fine di ogni cicloAlla fine di ogni ciclo Bisogna memorizzare i valori richiesti dai cicli Bisogna memorizzare i valori richiesti dai cicli
successivi dell’istuzione correntesuccessivi dell’istuzione corrente Richiede l’impiego di registri addizionali Richiede l’impiego di registri addizionali interniinterni
(invisibili al programmatore):(invisibili al programmatore): IR: IR: Instruction RegisterInstruction Register MDR: MDR: Memory Data RegisterMemory Data Register A & B:A & B: Valori letti dai registriValori letti dai registri ALUout: Registro che memorizza il risultato delle ALUout: Registro che memorizza il risultato delle
operazioni ALUoperazioni ALU
CPU (2) 4
Approccio MulticicloApproccio Multiciclo
VantaggiVantaggi Unita’ funzionali che devono essere usata piu’ volte Unita’ funzionali che devono essere usata piu’ volte
per la stessa istruzione non devono essere replicate per la stessa istruzione non devono essere replicate se impiegate in passi diversise impiegate in passi diversi Una sola memoria per dati e istruzioniUna sola memoria per dati e istruzioni Una sola ALU (no adder)Una sola ALU (no adder)
Tempo di ciclo piu’ breveTempo di ciclo piu’ breve Tempi di esecuzione inferioriTempi di esecuzione inferiori
Istruzioni usano il solo tempo (cicli) necessario alla loro Istruzioni usano il solo tempo (cicli) necessario alla loro esecuzioneesecuzione
CPU (2) 5
Unità di elaborazione a ciclo multiplo: una Unità di elaborazione a ciclo multiplo: una vista astrattavista astratta
Contiene l’istruzion
e
Dati dalla memoria Dati dal
secondo registro
Risultato della ALU
Dati dal primo registro
CPU (2) 6
Una vista più dettagliata Una vista più dettagliata
Poiché le unità funzionali sono condivise, occorre Poiché le unità funzionali sono condivise, occorre aggiungere dei multiplexer ed ampliare quelli già esistenti aggiungere dei multiplexer ed ampliare quelli già esistenti nel ciclo singolonel ciclo singolo
Unica Memoria per dati e istruzioniUnica Memoria per dati e istruzioni Si aggiunge un multiplexer per selezionare il PC o ALUOut Si aggiunge un multiplexer per selezionare il PC o ALUOut
come indirizzo della memoria da leggere/scriverecome indirizzo della memoria da leggere/scrivere Dovendo condividere la ALUDovendo condividere la ALU
Si aggiunge un multiplexer per il primo ingresso della ALU per Si aggiunge un multiplexer per il primo ingresso della ALU per selezionare il registro A (primo registro) oppure il PC (per il selezionare il registro A (primo registro) oppure il PC (per il calcolo dell’indirizzo dell’istruzione successiva)calcolo dell’indirizzo dell’istruzione successiva)
Il multiplexer a 2 vie sul secondo ingresso della ALU viene Il multiplexer a 2 vie sul secondo ingresso della ALU viene ampliato a 4 vieampliato a 4 vie
Una per il valore 4 (per il calcolo dell’indirizzo dell’istruzione Una per il valore 4 (per il calcolo dell’indirizzo dell’istruzione successiva)successiva)
Una per il valore dell’indirizzo (16 bit, estesi in segno a 32 e Una per il valore dell’indirizzo (16 bit, estesi in segno a 32 e traslati a sinistra)traslati a sinistra)
CPU (2) 7
Una vista più dettagliata (2)Una vista più dettagliata (2)
Mux su primo ingresso ALU
Mux su secondo ingresso ALU
Indirizzo da PC o da ALU
CPU (2) 8
I segnali di controlloI segnali di controllo
Nell’unità a ciclo multiplo occorre cambiare Nell’unità a ciclo multiplo occorre cambiare anche l’insieme dei segnali di controlloanche l’insieme dei segnali di controllo Gli elementi di memoria visibili al programmatore (il Gli elementi di memoria visibili al programmatore (il
PC, la memoria ed i registri) e l’IR hanno bisogno di PC, la memoria ed i registri) e l’IR hanno bisogno di un segnale di controllo per la scritturaun segnale di controllo per la scrittura
La memoria ha anche bisogno di un segnale di La memoria ha anche bisogno di un segnale di controllo per la lettura controllo per la lettura
Ciascuno dei due multiplexer a due vie aggiunti ha Ciascuno dei due multiplexer a due vie aggiunti ha bisogno di un segnale di controllo a 1 bitbisogno di un segnale di controllo a 1 bit
Il multiplexer a quattro vie ha bisogno di un segnale Il multiplexer a quattro vie ha bisogno di un segnale di controllo a 2 bitdi controllo a 2 bit
CPU (2) 9
L’unità con i segnali di controlloL’unità con i segnali di controllo
CPU (2) 10
Implementazione dei saltiImplementazione dei salti
Per le istruzioni di jump e branch, ci sono tre possibili Per le istruzioni di jump e branch, ci sono tre possibili sorgenti per il valore da scrivere in PCsorgenti per il valore da scrivere in PC L’output della ALU, con il valore PC+4 calcolato durante la L’output della ALU, con il valore PC+4 calcolato durante la
fase di fetch dell’istruzionefase di fetch dell’istruzione Il registro ALUOut, dove è memorizzato l’indirizzo del branch Il registro ALUOut, dove è memorizzato l’indirizzo del branch
una volta che è stato calcolatouna volta che è stato calcolato I 26 bit meno significativi dell’IR traslati a sinistra di 2 e I 26 bit meno significativi dell’IR traslati a sinistra di 2 e
concatenati con i 4 bit più significativi del PC incrementato, concatenati con i 4 bit più significativi del PC incrementato, se l’istruzione è di jumpse l’istruzione è di jump
CPU (2) 11
Implementazione dei salti: jumpImplementazione 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
CPU (2) 12
Implementazione dei salti: beqImplementazione dei salti: beq
Zero (dalla ALU) AND
PCWriteCond
Scelta del valore in
PC
In OR con PCWrite per indicare la scrittura di PC
CPU (2) 13
Il controllo della ALUIl controllo della ALU
Unità di controllo della ALU
ALUOp come input
6 bit di funct come input
3 bit di controllo alla ALU come output
CPU (2) 14
L’unità di elaborazione multi-cicloL’unità di elaborazione multi-ciclo
CPU (2) 15
I segnali di controllo ad 1 bitI segnali di controllo ad 1 bit
SegnaleSegnale Effetto quando vale 0Effetto quando vale 0 Effetto quando vale 1Effetto quando vale 1
RegDstRegDst Registro destinazione = rtRegistro destinazione = rt Registro destinazione = rdRegistro destinazione = rd
RegWriteRegWrite NessunoNessuno Nel registro indicato sull’ingresso Nel registro indicato sull’ingresso Write registerWrite register viene scritto il valore viene scritto il valore Write dataWrite data
ALUSrcAALUSrcA Il primo operando di ALU è PCIl primo operando di ALU è PC Il primo operando di ALU è registro AIl primo operando di ALU è registro A
MemReadMemRead NessunoNessuno Lettura della locazione di memoria Lettura della locazione di memoria indicata da indicata da AddressAddress
MemWriteMemWrite NessunoNessuno Scrittura della locazione di memoria Scrittura della locazione di memoria indicata da indicata da AddressAddress
MemtoRegMemtoReg Il valore in Il valore in Write dataWrite data (registri) (registri) viene da ALUOutviene da ALUOut
Il valore in Il valore in Write dataWrite data (registri) viene (registri) viene da MDRda MDR
IorDIorD L’indirizzo proviene da PCL’indirizzo proviene da PC L’indirizzo proviene da ALUOutL’indirizzo proviene da ALUOut
IRWriteIRWrite NessunoNessuno Uscita memoria scritta in IRUscita memoria scritta in IR
PCWritePCWrite NessunoNessuno Scrittura in PC: provenienza da Scrittura in PC: provenienza da PCSourcePCSource
PCWriteCondPCWriteCond NessunoNessuno Scrittura in PC se Scrittura in PC se ZeroZero di ALU è 1 di ALU è 1
CPU (2) 16
I segnali di controllo a 2 bitI segnali di controllo a 2 bit
SegnaleSegnale ValVal EffettoEffetto
ALUOpALUOp 0000 L’ALU calcola la sommaL’ALU calcola la somma
0101 L’ALU calcola la sottrazioneL’ALU calcola la sottrazione
1010 Operazione determinata dal campo functOperazione determinata dal campo funct
ALUScrBALUScrB 0000 Il secondo ingresso della ALU: proviene da reg. BIl secondo ingresso della ALU: proviene da reg. B
0101 ……: è la costante 4: è la costante 4
1010 ……: il valore dei 16 bit meno sign. di IR, estesi a : il valore dei 16 bit meno sign. di IR, estesi a 3232
1111 ……: il valore dei 16 bit meno sign. di IR, estesi a : il valore dei 16 bit meno sign. di IR, estesi a 32, traslati a sinistra di 2 bit32, traslati a sinistra di 2 bit
PCSourcePCSource 0000 In PC viene scritta l’uscita della ALU (PC+4)In PC viene scritta l’uscita della ALU (PC+4)
0101 In PC viene scritto ALUOut (indirizzo di beq)In PC viene scritto ALUOut (indirizzo di beq)
1010 In PC viene scritto l’indirizzo di jump (26 bit meno In PC viene scritto l’indirizzo di jump (26 bit meno sign. di IR, traslati a sinistra di 2 bit e concatenati sign. di IR, traslati a sinistra di 2 bit e concatenati con i 4 bit più sign. di PC) con i 4 bit più sign. di PC)
CPU (2) 17
Esecuzione di una istruzione in più cicliEsecuzione di una istruzione in più cicli
Obiettivo:Obiettivo: Decomporre le istruzioni in modo da bilanciare il Decomporre le istruzioni in modo da bilanciare il
carico di lavoro in ogni ciclo (e minimizzare la durata carico di lavoro in ogni ciclo (e minimizzare la durata del ciclo di clock)del ciclo di clock)
Suddividiamo le istruzioni in una serie di passiSuddividiamo le istruzioni in una serie di passi Ogni passo coincide con un ciclo di clockOgni passo coincide con un ciclo di clock Ogni passo comprende al più:Ogni passo comprende al più:
Un’operazione con la ALUUn’operazione con la ALU Un accesso al banco dei registriUn accesso al banco dei registri Un accesso alla memoriaUn accesso alla memoria
In questo modo, la durata del ciclo di clock In questo modo, la durata del ciclo di clock sarà pari alla durata della più lenta di queste sarà pari alla durata della più lenta di queste tre operazionitre operazioni
CPU (2) 18
Alla fine di ciascun ciclo di clockAlla fine di ciascun ciclo di clock
Tutti i valori che sono necessari al passo Tutti i valori che sono necessari al passo successivo/Istruzione successivo/Istruzione Sono memorizzati in qualche componenteSono memorizzati in qualche componente
Ad esempioAd esempio Il Program CounterIl Program Counter Il banco dei registiIl banco dei registi La memoriaLa memoria Uno dei registri addizionaliUno dei registri addizionali
A, B, MDR oppure ALUOutA, B, MDR oppure ALUOut IR (dotato di segnale di controllo per la scrittura)IR (dotato di segnale di controllo per la scrittura)
– IR è l’unico tra i registri addizionali a contenere lo IR è l’unico tra i registri addizionali a contenere lo stesso dato (l’istruzione) per tutti i passi di esecuzione stesso dato (l’istruzione) per tutti i passi di esecuzione di una istruzionedi una istruzione
CPU (2) 19
Si suddividono le istruzioni nei seguenti passi Si suddividono le istruzioni nei seguenti passi potenzialipotenziali – non tutte le istruzioni le richiedono tutte– non tutte le istruzioni le richiedono tutte
1.1. Prelievo Istruzione e Incremento del PC (Prelievo Istruzione e Incremento del PC (IFIF)) Si preleva l’istruzione in base a PC e si salva in IR. PC e’ Si preleva l’istruzione in base a PC e si salva in IR. PC e’
incrementato di 4incrementato di 4
2.2. Decodifica Istruzione e Prelievo Registri (Decodifica Istruzione e Prelievo Registri (IDID)) Si leggono i registri rs e rt in caso servanoSi leggono i registri rs e rt in caso servano Si calcola l’indirizzo di salto (nel caso l’istruzione sia di Si calcola l’indirizzo di salto (nel caso l’istruzione sia di
salto).salto).
3.3. Esecuzione, Calcolo Indirizzo di Memoria, o Esecuzione, Calcolo Indirizzo di Memoria, o completamento salto (completamento salto (EXEX)) ALU esegue una delle seguenti funzioni in base al tipo di ALU esegue una delle seguenti funzioni in base al tipo di
istruzioneistruzione memory referencememory reference R-typeR-type
branch (Istruzione Completata)branch (Istruzione Completata) jump (Istruzione Completata)jump (Istruzione Completata)
Suddivisione in PassiSuddivisione in Passi
CPU (2) 20
4.4. Accesso in Memoria e Completamento Istruzione R Accesso in Memoria e Completamento Istruzione R ((MEMMEM)) In base al tipo di istruzioneIn base al tipo di istruzione
Legge dalla memoriaLegge dalla memoria Scrive in memoria (Istruzione Completata)Scrive in memoria (Istruzione Completata) Scrittura nel Registro Destinazione (Istruzione Completata)Scrittura nel Registro Destinazione (Istruzione Completata)
5.5. Completamento lettura da Memoria (Completamento lettura da Memoria (WBWB)) Il dato letto dalla memoria in 4 viene scritto nel registro Il dato letto dalla memoria in 4 viene scritto nel registro
Destinazione (Load completato)Destinazione (Load completato)
Le istruzioni MIPS richiedono da 3 a 5 cicli di clockLe istruzioni MIPS richiedono da 3 a 5 cicli di clock Jump e branch: Jump e branch: 3 cicli3 cicli Formato R, store:Formato R, store: 4 cicli4 cicli Write:Write: 5 cicli5 cicli
Suddivisione in PassiSuddivisione in Passi
CPU (2) 21
Prelievo dell’Istruzione (IF)Prelievo dell’Istruzione (IF)
IR = M[PC];IR = M[PC];PC = PC + 4;PC = PC + 4;
4PC + 4
5 5
RD1
RD2
RN1 RN2 WN
WD
RegWrite
Registers
Operation
ALU
3
Zero
RD
WDMemRead
MemoryADDR
MemWrite
5
Instruction I
PC
IR
MDR
A
B
ALUOUT
CPU (2) 22
A = Reg[IR[25-21]];A = Reg[IR[25-21]]; (A = Reg[rs])(A = Reg[rs])B = Reg[IR[20-15]];B = Reg[IR[20-15]]; (B = Reg[rt])(B = Reg[rt])ALUOut = (PC + sign-extend(IR[15-0]) << 2)ALUOut = (PC + sign-extend(IR[15-0]) << 2)
BranchTarget
Address
Reg[rs]
Reg[rt]
PC + 4
5 5
RD1
RD2
RN1 RN2 WN
WD
RegWrite
Registers
Operation
ALU
3
Zero
RD
WDMemRead
MemoryADDR
MemWrite
5
Instruction I
PC
IR
MDR
A
B
ALUOUT
Decodifica Istruzione e Lettura Registri Decodifica Istruzione e Lettura Registri (ID)(ID)
CPU (2) 23
Formato R: (EX) – Esecuzione ALUFormato R: (EX) – Esecuzione ALU
ALUOut = A op BALUOut = A op B
R-TypeResult
Reg[rs]
Reg[rt]
PC + 4
5 5
RD1
RD2
RN1 RN2 WN
WD
RegWrite
Registers
Operation
ALU
3
Zero
RD
WDMemRead
MemoryADDR
MemWrite
5
Instruction I
PC
IR
MDR
A
B
ALUOUT
CPU (2) 24
Formato R: (MEM) – Scrittura Registro Formato R: (MEM) – Scrittura Registro Dest.Dest.
Reg[IR[15:11]] = ALUOUTReg[IR[15:11]] = ALUOUT
R-TypeResult
Reg[rs]
Reg[rt]
PC + 4
5 5
RD1
RD2
RN1 RN2 WN
WD
RegWrite
Registers
Operation
ALU
3
Zero
RD
WDMemRead
MemoryADDR
MemWrite
5
Instruction I
PC
IR
MDR
A
B
ALUOUT
CPU (2) 25
A = Reg[IR[25-21]];A = Reg[IR[25-21]]; (A = Reg[rs])(A = Reg[rs])B = Reg[IR[20-15]];B = Reg[IR[20-15]]; (B = Reg[rt])(B = Reg[rt])ALUOut = (PC + sign-extend(IR[15-0]) << 2)ALUOut = (PC + sign-extend(IR[15-0]) << 2)
BranchTarget
Address
Reg[rs]
Reg[rt]
PC + 4
5 5
RD1
RD2
RN1 RN2 WN
WD
RegWrite
Registers
Operation
ALU
3
Zero
RD
WDMemRead
MemoryADDR
MemWrite
5
Instruction I
PC
IR
MDR
A
B
ALUOUT
Decodifica Istruzione e Lettura Registri Decodifica Istruzione e Lettura Registri (ID)(ID)
CPU (2) 26
Branch: (EX) – Aggiornamento PCBranch: (EX) – Aggiornamento PC
if (A == B) PC = ALUOut;if (A == B) PC = ALUOut;
BranchTarget
Address
Reg[rs]
Reg[rt]
BranchTarget
Address
5 5
RD1
RD2
RN1 RN2 WN
WD
RegWrite
Registers
Operation
ALU
3
Zero
RD
WDMemRead
MemoryADDR
MemWrite
5
Instruction I
PC
IR
MDR
A
B
ALUOUT
CPU (2) 27
A = Reg[IR[25-21]];A = Reg[IR[25-21]]; (A = Reg[rs])(A = Reg[rs])B = Reg[IR[20-15]];B = Reg[IR[20-15]]; (B = Reg[rt])(B = Reg[rt])ALUOut = (PC + sign-extend(IR[15-0]) << 2)ALUOut = (PC + sign-extend(IR[15-0]) << 2)
BranchTarget
Address
Reg[rs]
Reg[rt]
PC + 4
5 5
RD1
RD2
RN1 RN2 WN
WD
RegWrite
Registers
Operation
ALU
3
Zero
RD
WDMemRead
MemoryADDR
MemWrite
5
Instruction I
PC
IR
MDR
A
B
ALUOUT
Decodifica Istruzione e Lettura Registri Decodifica Istruzione e Lettura Registri (ID)(ID)
CPU (2) 28
Jump: (EX) – Aggiornamento PCJump: (EX) – Aggiornamento PC
PC = PC[31-28] concat (IR[25-0] << 2)PC = PC[31-28] concat (IR[25-0] << 2)
JumpAddress
Reg[rs]
Reg[rt]
BranchTarget
Address
5 5
RD1
RD2
RN1 RN2 WN
WD
RegWrite
Registers
Operation
ALU
3
Zero
RD
WDMemRead
MemoryADDR
MemWrite
5
Instruction I
PC
IR
MDR
A
B
ALUOUT
CPU (2) 29
A = Reg[IR[25-21]];A = Reg[IR[25-21]]; (A = Reg[rs])(A = Reg[rs])B = Reg[IR[20-15]];B = Reg[IR[20-15]]; (B = Reg[rt])(B = Reg[rt])ALUOut = (PC + sign-extend(IR[15-0]) << 2)ALUOut = (PC + sign-extend(IR[15-0]) << 2)
BranchTarget
Address
Reg[rs]
Reg[rt]
PC + 4
5 5
RD1
RD2
RN1 RN2 WN
WD
RegWrite
Registers
Operation
ALU
3
Zero
RD
WDMemRead
MemoryADDR
MemWrite
5
Instruction I
PC
IR
MDR
A
B
ALUOUT
Decodifica Istruzione e Lettura Registri Decodifica Istruzione e Lettura Registri (ID)(ID)
CPU (2) 30
ALUOut = A + sign-extend(IR[15-0]);ALUOut = A + sign-extend(IR[15-0]);
Mem.Address
Reg[rs]
Reg[rt]
PC + 4
5 5
RD1
RD2
RN1 RN2 WN
WD
RegWrite
Registers
Operation
ALU
3
Zero
RD
WDMemRead
MemoryADDR
MemWrite
5
Instruction I
PC
IR
MDR
A
B
ALUOUT
Store: (EX) Calcolo IndirizzoStore: (EX) Calcolo Indirizzo
CPU (2) 31
Store: (MEM) Scrittura in MemoriaStore: (MEM) Scrittura in Memoria
M[ALUOut] = B;M[ALUOut] = B;
PC + 4
Reg[rs]
Reg[rt]
5 5
RD1
RD2
RN1 RN2 WN
WD
RegWrite
Registers
Operation
ALU
3
Zero
RD
WDMemRead
MemoryADDR
MemWrite
5
Instruction I
PC
IR
MDR
A
B
ALUOUT
CPU (2) 32
A = Reg[IR[25-21]];A = Reg[IR[25-21]]; (A = Reg[rs])(A = Reg[rs])B = Reg[IR[20-15]];B = Reg[IR[20-15]]; (B = Reg[rt])(B = Reg[rt])ALUOut = (PC + sign-extend(IR[15-0]) << 2)ALUOut = (PC + sign-extend(IR[15-0]) << 2)
BranchTarget
Address
Reg[rs]
Reg[rt]
PC + 4
5 5
RD1
RD2
RN1 RN2 WN
WD
RegWrite
Registers
Operation
ALU
3
Zero
RD
WDMemRead
MemoryADDR
MemWrite
5
Instruction I
PC
IR
MDR
A
B
ALUOUT
Decodifica Istruzione e Lettura Registri Decodifica Istruzione e Lettura Registri (ID)(ID)
CPU (2) 33
ALUOut = A + sign-extend(IR[15-0]);ALUOut = A + sign-extend(IR[15-0]);
Mem.Address
Reg[rs]
Reg[rt]
PC + 4
5 5
RD1
RD2
RN1 RN2 WN
WD
RegWrite
Registers
Operation
ALU
3
Zero
RD
WDMemRead
MemoryADDR
MemWrite
5
Instruction I
PC
IR
MDR
A
B
ALUOUT
Load: (EX) Calcolo IndirizzoLoad: (EX) Calcolo Indirizzo
CPU (2) 34
Load: (MEM) Lettura in MemoriaLoad: (MEM) Lettura in Memoria
MDR = M[ALUOut];MDR = M[ALUOut];
Mem.Data
PC + 4
Reg[rs]
Reg[rt]
Mem.Address
5 5
RD1
RD2
RN1 RN2 WN
WD
RegWrite
Registers
Operation
ALU
3
Zero
RD
WDMemRead
MemoryADDR
MemWrite
5
Instruction I
PC
IR
MDR
A
B
ALUOUT
CPU (2) 35
Load: (WB) – Scrittura nel Registro Dest. Load: (WB) – Scrittura nel Registro Dest.
Reg[IR[20-16]] = MDRReg[IR[20-16]] = MDR;;
PC + 4
Reg[rs]
Reg[rt]Mem.Data
Mem.Address
5 5
RD1
RD2
RN1 RN2 WN
WD
RegWrite
Registers
Operation
ALU
3
Zero
RD
WDMemRead
MemoryADDR
MemWrite
5
Instruction I
PC
IR
MDR
A
B
ALUOUT
CPU (2) 36
Schema Riassuntivo Implementazione Schema Riassuntivo Implementazione MulticicloMulticiclo
1: IF
2: ID
3: EX
4: MEM
5: WB
StepStep name
Action for R-type instructions
Action for memory-reference instructions
Action for branches
Action for jumps
Instruction fetch IR = M[PC]PC = PC + 4
Instruction A = Reg [IR[25-21]]decode/register fetch B = Reg [IR[20-16]]
ALUOut = PC + (sign-extend (IR[15-0]) << 2)
Execution, address ALUOut = A op B ALUOut = A + sign-extend if (A ==B) then PC = PC [31-28] IIcomputation, branch/ (IR[15-0]) PC = ALUOut (IR[25-0]<<2)jump completion
Memory access or R-type Reg [IR[15-11]] = Load: MDR = M[ALUOut]completion ALUOut or
Store: M[ALUOut] = B
Memory read completion Load: Reg[IR[20-16]] = MDR
CPU (2) 37
ControlloControllo
L’Unita di Controllo deve generare:L’Unita di Controllo deve generare: I segnali di controllo dell’ALUI segnali di controllo dell’ALU I segnali di controllo dei vari multiplexerI segnali di controllo dei vari multiplexer I segnali di abilitazione alla I segnali di abilitazione alla
scrittura/lettura dei diversi elementi di scrittura/lettura dei diversi elementi di memoriamemoria
In funzione del…In funzione del…
1.1. Tipo di Istruzione da eseguire (Ingresso)Tipo di Istruzione da eseguire (Ingresso) I bit del campo opcode (e funct nel caso I bit del campo opcode (e funct nel caso
del formato R) dell’istruzionedel formato R) dell’istruzione
2.2. Step dell’istruzioneStep dell’istruzione
Una rete combinatoria non e’ sufficiente Una rete combinatoria non e’ sufficiente ad implementare il controllo multicicload implementare il controllo multiciclo
Controllo
Opcode
Funct
Controllo ALU
Controllo MUX
Read/Write
Memorie
6
6
CPU (2) 38
Controllo Multiplo Ciclo: Rete SequenzialeControllo Multiplo Ciclo: Rete Sequenziale
Il controllo sara’ realizzato da Il controllo sara’ realizzato da una rete sequenzialeuna rete sequenziale Automa a Stati finitiAutoma a Stati finiti MicropragrammaMicropragramma
Per semplificare la Per semplificare la progettazione/circuito del progettazione/circuito del controllo suddivideremo controllo suddivideremo l’unita’ di controllo in l’unita’ di controllo in Unita’ di Controllo PrincipaleUnita’ di Controllo Principale Unita’ di Controllo ALUUnita’ di Controllo ALU
Per il controllo dell’ALU Per il controllo dell’ALU useremo la stessa rete useremo la stessa rete combinatoria vista per combinatoria vista per l’implementazione singolo l’implementazione singolo ciclociclo
Controllo
Opcode
Funct
Controllo ALU
Controllo MUX
Read/Write
Memorie
6
6
Controllo
ALUOp
Controllo MUX
Read/Write
Memorie
2
6
Funct
6
ALU
Control
Controllo ALU
Opcode
CPU (2) 39
Implementazione Unita’ di Controllo PrincipaleImplementazione Unita’ di Controllo Principale
Possiamo implementare l’Unita’ di Controllo come Possiamo implementare l’Unita’ di Controllo come una rete sequenziale di Mooreuna rete sequenziale di Moore Stato: passo di esecuzione dell’istruzione correnteStato: passo di esecuzione dell’istruzione corrente
IF, ID, Ex-Formato R, Ex-beq, etc…IF, ID, Ex-Formato R, Ex-beq, etc… Ingressi: Opcode IstruzioneIngressi: Opcode Istruzione Uscite: Segnali di Controllo verso DataPathUscite: Segnali di Controllo verso DataPath
Bisogna Specificare Bisogna Specificare Funzione Prossimo Stato: Funzione Prossimo Stato:
Stato(n+1)=F(Stato(n),Ingressi(n))Stato(n+1)=F(Stato(n),Ingressi(n)) Funzione Uscita: Uscite(n)=G(Stato(n))Funzione Uscita: Uscite(n)=G(Stato(n))
Perche’ e’ un automa di MoorePerche’ e’ un automa di Moore
Opcode
Controllo MUXRead/Write Memorie
6
ALUOp
2
Rete Combinatoria
Stato
CPU (2) 40
Struttura dell’Automa a Stati FinitiStruttura dell’Automa a Stati Finiti
I primi due passi sono indipendenti dall’istruzioneI primi due passi sono indipendenti dall’istruzione I restanti passi sono differenziati a seconda I restanti passi sono differenziati a seconda
dell’operazionedell’operazione Ciascuna porzione della macchina a stati finiti può Ciascuna porzione della macchina a stati finiti può
essere composta da più statiessere composta da più stati
R-type EXE Calcolo Indirizzo
M-Read M-Write
R-Write
R-Write
Beq EXE (PC update) Jump EXE (PC update)
Fetch
Decode, Fetch Reg, beq
Inizio
CPU (2) 41
Segnali di Controllo: (IF)Segnali di Controllo: (IF)
IR = M[PC];IR = M[PC];- MemRead=1MemRead=1- IRWrite=1IRWrite=1- IorD=0IorD=0
PC = PC + 4;PC = PC + 4;- ALUSrcA=0, ALUSrcB=01ALUSrcA=0, ALUSrcB=01- ALUOp=00ALUOp=00- PCWrite=1, PCSource=00PCWrite=1, PCSource=00
1
0
1
0
1
0X
0X
0010
1
5 5
RD1
RD2
RN1 RN2 WN
WD
RegWrite
Registers
Operation
ALU
3
EXTND
16 32
Zero
RD
WDMemRead
MemoryADDR
MemWrite
5
Instruction I
32
ALUSrcB
<<2
PC
4
RegDst
5
IR
MDR
MUX
0123
MUX
1
0
MUX
0
1A
BALUOUT
0
1
2MUX
<<2 CONCAT28 32
MUX
0
1
ALUSrcA
jmpaddrI[25:0]
rd
MUX0 1
rtrs
immediate
PCSource
MemtoReg
IorD
PCWr*
IRWrite
CPU (2) 42
Segnali di Controllo: (ID)Segnali di Controllo: (ID)
A = Reg[IR[25-21]]; (A = Reg[rs])A = Reg[IR[25-21]]; (A = Reg[rs])B = Reg[IR[20-15]]; (B = Reg[rt])B = Reg[IR[20-15]]; (B = Reg[rt])- A e B sempre sovrascritti - A e B sempre sovrascritti
(nessun segnale di controllo)(nessun segnale di controllo)
ALUOut = (PC + sign-extend(IR[15-0]) << 2);ALUOut = (PC + sign-extend(IR[15-0]) << 2);- ALUSrcA=0, ALUSrcB=11ALUSrcA=0, ALUSrcB=11- ALUOp=00ALUOp=00
0
0X
0
0X
3
0X
X
010
0
5 5
RD1
RD2
RN1 RN2 WN
WD
RegWrite
Registers
Operation
ALU
3
EXTND
16 32
Zero
RD
WDMemRead
MemoryADDR
MemWrite
5
Instruction I
32
ALUSrcB
<<2
PC
4
RegDst
5
IR
MDR
MUX
0123
MUX
1
0
MUX
0
1A
BALUOUT
0
1
2MUX
<<2 CONCAT28 32
MUX
0
1
ALUSrcA
jmpaddrI[25:0]
rd
MUX0 1
rtrs
immediate
PCSource
MemtoReg
IorD
PCWr*
IRWrite
CPU (2) 43
Segnali di Controllo: (EX) Formato R - ALUSegnali di Controllo: (EX) Formato R - ALU
ALUOut = A op B;ALUOut = A op B;- ALUSrcA=1, ALUSrcB=00ALUSrcA=1, ALUSrcB=00- ALUOp=10 (Operation dipende da Funct)ALUOp=10 (Operation dipende da Funct)- ALUOut riscritto ad ogni ciclo)ALUOut riscritto ad ogni ciclo)
0X
X
0
0
0X
0 1
X
???
0
5 5
RD1
RD2
RN1 RN2 WN
WD
RegWrite
Registers
Operation
ALU
3
EXTND
16 32
Zero
RD
WDMemRead
MemoryADDR
MemWrite
5
Instruction I
32
ALUSrcB
<<2
PC
4
RegDst
5
IR
MDR
MUX
0123
MUX
1
0
MUX
0
1A
BALUOUT
0
1
2MUX
<<2 CONCAT28 32
MUX
0
1
ALUSrcA
jmpaddrI[25:0]
rd
MUX0 1
rtrs
immediate
PCSource
MemtoReg
IorD
PCWr*
IRWrite
CPU (2) 44
10
0X
0
X
0
XXX
X
X
0
15 5
RD1
RD2
RN1 RN2 WN
WD
RegWrite
Registers
Operation
ALU
3
EXTND
16 32
Zero
RD
WD
MemRead
MemoryADDR
MemWrite
5
Instruction I
32
ALUSrcB
<<2
PC
4
RegDst
5
IR
MDR
MUX
0123
MUX
1
0
MUX
0
1A
BALUOUT
0
1
2MUX
<<2 CONCAT28 32
MUX
0
1
ALUSrcA
jmpaddrI[25:0]
rd
MUX0 1
rtrs
immediate
PCSource
MemtoReg
IorD
PCWr*
IRWrite
Segnali di Controllo: (MEM) Formato R – Segnali di Controllo: (MEM) Formato R – Scrittura Registro DestinazioneScrittura Registro Destinazione
Reg[IR[15:11]] = ALUOut; (Reg[Rd] = ALUOut)Reg[IR[15:11]] = ALUOut; (Reg[Rd] = ALUOut)- RegDest=1RegDest=1- ReWrite=1ReWrite=1- MemtoReg=0MemtoReg=0
CPU (2) 45
Segnali di Controllo: (ID)Segnali di Controllo: (ID)
A = Reg[IR[25-21]]; (A = Reg[rs])A = Reg[IR[25-21]]; (A = Reg[rs])B = Reg[IR[20-15]]; (B = Reg[rt])B = Reg[IR[20-15]]; (B = Reg[rt])- A e B sempre sovrascritti - A e B sempre sovrascritti
(nessun segnale di controllo)(nessun segnale di controllo)
ALUOut = (PC + sign-extend(IR[15-0]) << 2);ALUOut = (PC + sign-extend(IR[15-0]) << 2);- ALUSrcA=0, ALUSrcB=11ALUSrcA=0, ALUSrcB=11- ALUOp=00ALUOp=00
0
0X
0
0X
3
0X
X
010
0
5 5
RD1
RD2
RN1 RN2 WN
WD
RegWrite
Registers
Operation
ALU
3
EXTND
16 32
Zero
RD
WDMemRead
MemoryADDR
MemWrite
5
Instruction I
32
ALUSrcB
<<2
PC
4
RegDst
5
IR
MDR
MUX
0123
MUX
1
0
MUX
0
1A
BALUOUT
0
1
2MUX
<<2 CONCAT28 32
MUX
0
1
ALUSrcA
jmpaddrI[25:0]
rd
MUX0 1
rtrs
immediate
PCSource
MemtoReg
IorD
PCWr*
IRWrite
CPU (2) 46
1 if Zero=1
Segnali di Controllo: (EX) Branch – Agg. Segnali di Controllo: (EX) Branch – Agg. PCPCif (A == B) PC = ALUOut;if (A == B) PC = ALUOut;- ALUSrcA=1, ALUSrcB=00ALUSrcA=1, ALUSrcB=00- ALUOp=01ALUOp=01- PCWrite=0, PCWriteCond=1, PCSource=01PCWrite=0, PCWriteCond=1, PCSource=01
0X
X
0
0
X0 1
1
110
0
5 5
RD1
RD2
RN1 RN2 WN
WD
RegWrite
Registers
Operation
ALU
3
EXTND
16 32
Zero
RD
WDMemRead
MemoryADDR
MemWrite
5
Instruction I
32
ALUSrcB
<<2
PC
4
RegDst
5
IR
MDR
MUX
0123
MUX
1
0
MUX
0
1A
BALUOUT
0
1
2MUX
<<2 CONCAT28 32
MUX
0
1
ALUSrcA
jmpaddrI[25:0]
rd
MUX0 1
rtrs
immediate
PCSource
MemtoReg
IorD
PCWr*
IRWrite
CPU (2) 47
Segnali di Controllo: (ID)Segnali di Controllo: (ID)
A = Reg[IR[25-21]]; (A = Reg[rs])A = Reg[IR[25-21]]; (A = Reg[rs])B = Reg[IR[20-15]]; (B = Reg[rt])B = Reg[IR[20-15]]; (B = Reg[rt])- A e B sempre sovrascritti - A e B sempre sovrascritti
(nessun segnale di controllo)(nessun segnale di controllo)
ALUOut = (PC + sign-extend(IR[15-0]) << 2);ALUOut = (PC + sign-extend(IR[15-0]) << 2);- ALUSrcA=0, ALUSrcB=11ALUSrcA=0, ALUSrcB=11- ALUOp=00ALUOp=00
0
0X
0
0X
3
0X
X
010
0
5 5
RD1
RD2
RN1 RN2 WN
WD
RegWrite
Registers
Operation
ALU
3
EXTND
16 32
Zero
RD
WDMemRead
MemoryADDR
MemWrite
5
Instruction I
32
ALUSrcB
<<2
PC
4
RegDst
5
IR
MDR
MUX
0123
MUX
1
0
MUX
0
1A
BALUOUT
0
1
2MUX
<<2 CONCAT28 32
MUX
0
1
ALUSrcA
jmpaddrI[25:0]
rd
MUX0 1
rtrs
immediate
PCSource
MemtoReg
IorD
PCWr*
IRWrite
CPU (2) 48
Segnali di Controllo: (EX) Jump – Agg. PCSegnali di Controllo: (EX) Jump – Agg. PC
PC = PC[21-28] concat (IR[25-0] << 2);PC = PC[21-28] concat (IR[25-0] << 2);- PCWrite=1, PCSource=10- PCWrite=1, PCSource=10
0X
X
X
0
1X
0 X
2
XXX
0
5 5
RD1
RD2
RN1 RN2 WN
WD
RegWrite
Registers
Operation
ALU
3
EXTND
16 32
Zero
RD
WDMemRead
MemoryADDR
MemWrite
5
Instruction I
32
ALUSrcB
<<2
PC
4
RegDst
5
IR
MDR
MUX
0123
MUX
1
0
MUX
0
1A
BALUOUT
0
1
2MUX
<<2 CONCAT28 32
MUX
0
1
ALUSrcA
jmpaddrI[25:0]
rd
MUX0 1
rtrs
immediate
PCSource
MemtoReg
IorD
PCWr*
IRWrite
CPU (2) 49
Segnali di Controllo: (ID)Segnali di Controllo: (ID)
A = Reg[IR[25-21]]; (A = Reg[rs])A = Reg[IR[25-21]]; (A = Reg[rs])B = Reg[IR[20-15]]; (B = Reg[rt])B = Reg[IR[20-15]]; (B = Reg[rt])- A e B sempre sovrascritti - A e B sempre sovrascritti
(nessun segnale di controllo)(nessun segnale di controllo)
ALUOut = (PC + sign-extend(IR[15-0]) << 2);ALUOut = (PC + sign-extend(IR[15-0]) << 2);- ALUSrcA=0, ALUSrcB=11ALUSrcA=0, ALUSrcB=11- ALUOp=00ALUOp=00
0
0X
0
0X
3
0X
X
010
0
5 5
RD1
RD2
RN1 RN2 WN
WD
RegWrite
Registers
Operation
ALU
3
EXTND
16 32
Zero
RD
WDMemRead
MemoryADDR
MemWrite
5
Instruction I
32
ALUSrcB
<<2
PC
4
RegDst
5
IR
MDR
MUX
0123
MUX
1
0
MUX
0
1A
BALUOUT
0
1
2MUX
<<2 CONCAT28 32
MUX
0
1
ALUSrcA
jmpaddrI[25:0]
rd
MUX0 1
rtrs
immediate
PCSource
MemtoReg
IorD
PCWr*
IRWrite
CPU (2) 50
0X
ALUOut = A + sign-extend(IR[15-0]);ALUOut = A + sign-extend(IR[15-0]);- ALUSrcA=1, ALUSrcB=10ALUSrcA=1, ALUSrcB=10- ALUOp=00ALUOp=00
X
2
0
0X
0 1
X
010
0
5 5
RD1
RD2
RN1 RN2 WN
WD
RegWrite
Registers
Operation
ALU
3
EXTND
16 32
Zero
RD
WDMemRead
MemoryADDR
MemWrite
5
Instruction I
32
ALUSrcB
<<2
PC
4
RegDst
5
IR
MDR
MUX
0123
MUX
1
0
MUX
0
1A
BALUOUT
0
1
2MUX
<<2 CONCAT28 32
MUX
0
1
ALUSrcA
jmpaddrI[25:0]
rd
MUX0 1
rtrs
immediate
PCSource
MemtoReg
IorD
PCWr*
IRWrite
Segnali di Controllo: (EX) Store – Calc. IndirizzoSegnali di Controllo: (EX) Store – Calc. Indirizzo
CPU (2) 51
Segnali di Controllo: (MEM) Store – Scr. in Segnali di Controllo: (MEM) Store – Scr. in MemoriaMemoria
Memory[ALUOut] = B;Memory[ALUOut] = B;- IorD=1 IorD=1 - MemWrite=1MemWrite=1
0X
X
X
0
01
1 X
X
XXX
0
5 5
RD1
RD2
RN1 RN2 WN
WD
RegWrite
Registers
Operation
ALU
3
EXTND
16 32
Zero
RD
WDMemRead
MemoryADDR
MemWrite
5
Instruction I
32
ALUSrcB
<<2
PC
4
RegDst
5
IR
MDR
MUX
0123
MUX
1
0
MUX
0
1A
BALUOUT
0
1
2MUX
<<2 CONCAT28 32
MUX
0
1
ALUSrcA
jmpaddrI[25:0]
rd
MUX0 1
rtrs
immediate
PCSource
MemtoReg
IorD
PCWr*
IRWrite
CPU (2) 52
Segnali di Controllo: (ID)Segnali di Controllo: (ID)
A = Reg[IR[25-21]]; (A = Reg[rs])A = Reg[IR[25-21]]; (A = Reg[rs])B = Reg[IR[20-15]]; (B = Reg[rt])B = Reg[IR[20-15]]; (B = Reg[rt])- A e B sempre sovrascritti - A e B sempre sovrascritti
(nessun segnale di controllo)(nessun segnale di controllo)
ALUOut = (PC + sign-extend(IR[15-0]) << 2);ALUOut = (PC + sign-extend(IR[15-0]) << 2);- ALUSrcA=0, ALUSrcB=11ALUSrcA=0, ALUSrcB=11- ALUOp=00ALUOp=00
0
0X
0
0X
3
0X
X
010
0
5 5
RD1
RD2
RN1 RN2 WN
WD
RegWrite
Registers
Operation
ALU
3
EXTND
16 32
Zero
RD
WDMemRead
MemoryADDR
MemWrite
5
Instruction I
32
ALUSrcB
<<2
PC
4
RegDst
5
IR
MDR
MUX
0123
MUX
1
0
MUX
0
1A
BALUOUT
0
1
2MUX
<<2 CONCAT28 32
MUX
0
1
ALUSrcA
jmpaddrI[25:0]
rd
MUX0 1
rtrs
immediate
PCSource
MemtoReg
IorD
PCWr*
IRWrite
CPU (2) 53
0X
ALUOut = A + sign-extend(IR[15-0]);ALUOut = A + sign-extend(IR[15-0]);- ALUSrcA=1, ALUSrcB=10ALUSrcA=1, ALUSrcB=10- ALUOp=00ALUOp=00
X
2
0
0X
0 1
X
010
0
5 5
RD1
RD2
RN1 RN2 WN
WD
RegWrite
Registers
Operation
ALU
3
EXTND
16 32
Zero
RD
WDMemRead
MemoryADDR
MemWrite
5
Instruction I
32
ALUSrcB
<<2
PC
4
RegDst
5
IR
MDR
MUX
0123
MUX
1
0
MUX
0
1A
BALUOUT
0
1
2MUX
<<2 CONCAT28 32
MUX
0
1
ALUSrcA
jmpaddrI[25:0]
rd
MUX0 1
rtrs
immediate
PCSource
MemtoReg
IorD
PCWr*
IRWrite
Segnali di Controllo: (EX) Load – Calc. IndirizzoSegnali di Controllo: (EX) Load – Calc. Indirizzo
CPU (2) 54
Segnali di Controllo: (MEM) Load – Lett. in Segnali di Controllo: (MEM) Load – Lett. in MemoriaMemoria
MDR = Memory[ALUOut];MDR = Memory[ALUOut];- IorD=1 IorD=1 - MemRead=1MemRead=1
0X
X
X
1
01
0 X
X
XXX
0
5 5
RD1
RD2
RN1 RN2 WN
WD
RegWrite
Registers
Operation
ALU
3
EXTND
16 32
Zero
RD
WDMemRead
MemoryADDR
MemWrite
5
Instruction I
32
ALUSrcB
<<2
PC
4
RegDst
5
IR
MDR
MUX
0123
MUX
1
0
MUX
0
1A
BALUOUT
0
1
2MUX
<<2 CONCAT28 32
MUX
0
1
ALUSrcA
jmpaddrI[25:0]
rd
MUX0 1
rtrs
immediate
PCSource
MemtoReg
IorD
PCWr*
IRWrite
CPU (2) 55
Segnali di Controllo: (WB) Load – Scr. Registro di Segnali di Controllo: (WB) Load – Scr. Registro di DestinazioneDestinazione
Reg[IR[20-16]] = MDR;Reg[IR[20-16]] = MDR;- RegDest=0 RegDest=0 - RegWrite=1RegWrite=1- MemtoReg=0MemtoReg=0
1
0
0
X
0
0X
0 X
X
XXX
0
5 5
RD1
RD2
RN1 RN2 WN
WD
RegWrite
Registers
Operation
ALU
3
EXTND
16 32
Zero
RD
WD
MemRead
MemoryADDR
MemWrite
5
Instruction I
32
ALUSrcB
<<2
PC
4
RegDst
5
IR
MDR
MUX
0123
MUX
0
1
MUX
0
1A
BALUOUT
0
1
2MUX
<<2 CONCAT28 32
MUX
0
1
ALUSrcA
jmpaddrI[25:0]
rd
MUX0 1
rtrs
immediate
PCSource
MemtoReg
IorD
PCWr*
IRWrite
CPU (2) 56
Struttura dell’Automa a Stati FinitiStruttura dell’Automa a Stati Finiti
I primi due passi sono indipendenti dall’istruzioneI primi due passi sono indipendenti dall’istruzione I restanti passi sono differenziati a seconda I restanti passi sono differenziati a seconda
dell’operazionedell’operazione Ciascuna porzione della macchina a stati finiti può Ciascuna porzione della macchina a stati finiti può
essere composta da più statiessere composta da più stati
R-type EXE Calcolo Indirizzo
M-Read M-Write
R-Write
R-Write
Beq EXE (PC update) Jump EXE (PC update)
Fetch
Decode, Fetch Reg, beq
Inizio
CPU (2) 57
L’Automa a stati finiti completoL’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) 58
Unita’ di Controllo: Funzione di UscitaUnita’ di Controllo: Funzione di Uscita
OutputsOutputs Input Values (Current State[3-0])Input Values (Current State[3-0])
00000000
00000011
00100100
00100111
01001000
01001011
01101100
01101111
10010000
10010011
PCWritePCWrite 11 00 00 00 00 00 00 00 00 11
PCWriteConPCWriteCondd
XX 00 00 00 00 00 00 00 11 XX
IorDIorD 00 XX XX 11 XX 11 XX XX XX XX
MemReadMemRead 11 00 00 11 00 00 00 00 00 00
MemWriteMemWrite 00 00 00 00 00 11 00 00 00 00
IRWriteIRWrite 11 00 00 00 00 00 00 00 00 00
MemtoRegMemtoReg XX XX XX XX 11 XX XX 00 XX XX
PCSourcePCSource 0000 XXXX XXXX XXXX XXXX XXXX XXXX XXXX 0101 1010
ALUOpALUOp 0000 0000 0000 XXXX XXXX XXXX 1010 XXXX 0101 XXXX
ALUSrcBALUSrcB 0101 1111 1010 XXXX XXXX XXXX 0000 XXXX 0000 XXXX
ALUSrcAALUSrcA 00 00 11 XX XX XX 11 XX 11 XX
RegWriteRegWrite 00 00 00 00 11 00 00 11 00 00
RegDstRegDst XX XX XX XX 00 XX XX 11 XX XX
CPU (2) 59
Unita’ di Controllo: Funzione Prossimo Unita’ di Controllo: Funzione Prossimo StatoStato
CurreCurrent nt
State State [3-0][3-0]
Inst[31-26] (Op[5-0])Inst[31-26] (Op[5-0])
00000000000 (R-0 (R-type)type)
00001000010 (jmp)0 (jmp)
00010000100 (beq)0 (beq)
10001100011 (lw)1 (lw)
10101101011 (sw)1 (sw)
Any Any otherother
00000000 00010001 00010001 00010001 00010001 00010001 00010001
00010001 01100110 10011001 10001000 00100010 00100010 illegalillegal
00100010 XXXXXXXX XXXXXXXX XXXXXXXX 00110011 01010101 illegalillegal
00110011 XXXXXXXX XXXXXXXX XXXXXXXX 01000100 XXXXXXXX illegalillegal
01000100 XXXXXXXX XXXXXXXX XXXXXXXX 00000000 XXXXXXXX illegalillegal
01010101 XXXXXXXX XXXXXXXX XXXXXXXX XXXXXXXX 00000000 illegalillegal
01100110 01110111 XXXXXXXX XXXXXXXX XXXXXXXX XXXXXXXX illegalillegal
01110111 00000000 XXXXXXXX XXXXXXXX XXXXXXXX XXXXXXXX illegalillegal
10001000 XXXXXXXX XXXXXXXX 00000000 XXXXXXXX XXXXXXXX illegalillegal
10011001 XXXXXXXX 00000000 XXXXXXXX XXXXXXXX XXXXXXXX illegalillegal
CPU (2) 60
Diagramma a blocchi della CPU (Datapath e Diagramma a blocchi della CPU (Datapath e Control) e MemoriaControl) e Memoria
Memoria
CONTROLLO
DATAPATHAddr
Operation=f(ALUOp,funct)
RegDstALUSrcA/BMemtoReg
PCWrite+(Zero*PCWriteCond)MemWr MemRd RegWr
Zero
Register file
PC
ALU
PCSoruce
IorD IRWrite
A
BALUOut
MDR
IR
OpcodeFunct
Registro di Stato
CPU (2) 61
Implementazione dell’unità di controllo Implementazione dell’unità di controllo dall’Automa a Stati Finitidall’Automa a Stati Finiti
La macchina a stati La macchina a stati finiti può essere finiti può essere implementata usandoimplementata usando Un registro Un registro
temporaneo che temporaneo che memorizza lo stato memorizza lo stato correntecorrente
Un blocco di logica Un blocco di logica combinatoria che combinatoria che determina i segnali e determina i segnali e lo stato futurolo stato futuro
Realizzabile tramite Realizzabile tramite PLA o ROMPLA o ROM
PCWrite
PCWriteCond
IorD
MemtoReg
PCSource
ALUOp
ALUSrcB
ALUSrcA
RegWrite
RegDst
NS3NS2NS1NS0
Op5
Op4
Op3
Op2
Op1
Op0
S3
S2
S1
S0
State register
IRWrite
MemRead
MemWrite
Instruction registeropcode field
Outputs
Control logic
Inputs
CPU (2) 62
Implementazione Controllo Tramite PLAImplementazione Controllo Tramite PLA
Blocco combinatorio della Blocco combinatorio della rete sequenziale puo’ rete sequenziale puo’ essere implementato con essere implementato con logica digitale a 2 livellilogica digitale a 2 livelli PLAPLA
Numero minimo di porte Numero minimo di porte logichelogiche
# celle=# celle= #ingresso*#termini #ingresso*#termini
prodotto+#uscite*termini prodotto+#uscite*termini prodottoprodotto
10*17+20*17=510 celle 10*17+20*17=510 celle PLAPLA
Non modificabileNon modificabile Poco flessibilePoco flessibile
Soluzione efficiente per Soluzione efficiente per piccoli circuitipiccoli circuiti
Op5
Op4
Op3
Op2
Op1
Op0
S3
S2
S1
S0
IorD
IRWrite
MemReadMemWrite
PCWritePCWriteCond
MemtoRegPCSource1
ALUOp1
ALUSrcB0ALUSrcARegWriteRegDstNS3NS2NS1NS0
ALUSrcB1ALUOp0
PCSource0
CPU (2) 63
ROM (Read Only Memory)ROM (Read Only Memory) I valori delle varie celle di memoria sono fissatiI valori delle varie celle di memoria sono fissati
Le ROM possono essere usate per implementare Le ROM possono essere usate per implementare Tabelle di Verita’=Reti CombinatorieTabelle di Verita’=Reti Combinatorie Se l’indirizzo e’ di m-bit, possiamo indirizzzare 2Se l’indirizzo e’ di m-bit, possiamo indirizzzare 2mm celle celle
della ROMdella ROM Le uscite della ROM corrispondono ai contenuti della varie Le uscite della ROM corrispondono ai contenuti della varie
celle indirizzate dai m bit dell’indirizzocelle indirizzate dai m bit dell’indirizzo Tabella di Verita’ con m variabili in ingresso e n di Tabella di Verita’ con m variabili in ingresso e n di
outputoutput Sufficiente una ROM di 2Sufficiente una ROM di 2mmxn bitxn bit
Reti Combinatorie e ROMReti Combinatorie e ROM
0 0 0 0 0 1 10 0 1 1 1 0 00 1 0 1 1 0 00 1 1 1 0 0 0 1 0 0 0 0 0 0 1 0 1 0 0 0 11 1 0 0 1 1 01 1 1 0 1 1 1
m n
ROMm = 3n = 4
Output=
Contenuto celle
Input=
indirizzo
CPU (2) 64
Implementazione del Controllo tramite Implementazione del Controllo tramite ROMROM Rete combinatoria dell’unita’ di controllo ha:Rete combinatoria dell’unita’ di controllo ha:
10 linee in ingresso10 linee in ingresso 6 bit opcode6 bit opcode 4 bit stato4 bit stato Indirizzo=<Opcode,Stato>Indirizzo=<Opcode,Stato>
20 linee di output20 linee di output 16 bit di segnali di controllo16 bit di segnali di controllo 4 bit di stato4 bit di stato
Realizzazione ROM richiede Realizzazione ROM richiede 221010x20=20Kbitsx20=20Kbits
Soluzione inefficienteSoluzione inefficiente 16 bit di uscita (segnali di controllo) dipendono 16 bit di uscita (segnali di controllo) dipendono
solo dai 4 bit dello statosolo dai 4 bit dello stato Automa di MooreAutoma di Moore
indirizzi <XXX,Stato>, al variare di XXX i 16 bit indirizzi <XXX,Stato>, al variare di XXX i 16 bit relativi alle linee di controllo sono identicirelativi alle linee di controllo sono identici
Per molti stati le transizioni non dipendono Per molti stati le transizioni non dipendono dall’opcodedall’opcode
Per molti indirizzi <XXX,Stato>, al variare di XXX i Per molti indirizzi <XXX,Stato>, al variare di XXX i contenuti delle celle spesso sono identicicontenuti delle celle spesso sono identici
Stato __Uscita (Linee di Controllo)
0000 10010100000010000001 00000000000110000010 00000000001010000011 00110000000000000100 00000010000000100101 00101000000000000110 00000000010001000111 00000000000000111000 01000000101001001001 1000000100000000
CPU (2) 65
Implementazione del Controllo tramite Implementazione del Controllo tramite ROMROM
Implementare separatamente Implementare separatamente le tabelle di verita’ delle le tabelle di verita’ delle funzioni F (uscita) e G funzioni F (uscita) e G (prossimo stato)(prossimo stato) F: 4 bit di stato determinano le 16 F: 4 bit di stato determinano le 16
uscite (di controllo)uscite (di controllo) ROM di 2ROM di 244x16b=0.25Kbx16b=0.25Kb
G: 10 bit (4 stato+6 opcode) G: 10 bit (4 stato+6 opcode) determinano il prossimo statodeterminano il prossimo stato ROM di 2ROM di 21010x4b=4Kbx4b=4Kb
Totale 4.25Kbit >> numero celle Totale 4.25Kbit >> numero celle PLAPLA PLA ottimizza la rete grazie ai PLA ottimizza la rete grazie ai
molti DON’T CAREmolti DON’T CARE
Data la struttura degli automi di Data la struttura degli automi di Moore, la dimensione della ROM Moore, la dimensione della ROM e’ dominata dalla funzione Ge’ dominata dalla funzione G 4Kb vs 0.25Kb4Kb vs 0.25Kb
Stato __Uscita (Linee di Controllo)
0000 10010100000010000001 00000000000110000010 00000000001010000011 00110000000000000100 00000010000000100101 00101000000000000110 00000000010001000111 00000000000000111000 01000000101001001001 1000000100000000
Si puo’ semplificare
l’implementazione sfruttando la
struttura di G?
CPU (2) 66
Altro Stile di ImplementazioneAltro Stile di Implementazione
Implementare F come primaImplementare F come prima Per G osservare che: Per G osservare che:
1.1. Spesso la funzione stato Spesso la funzione stato successivo e’:successivo e’:
Stato(n+1)=Stato(n)+1Stato(n+1)=Stato(n)+1 0->10->1 IF->IDIF->ID 3->43->4 lw(MEM)->lw(WB)lw(MEM)->lw(WB) 6->76->7 f. R(EX)->f. R(MEM)f. R(EX)->f. R(MEM)
2.2. o semplicemente a fine o semplicemente a fine istruzione:istruzione:
Stato(n+1)=0Stato(n+1)=0
3.3. Tuttavia alcune volteTuttavia alcune volte
Stato(n+1)=G(Stato(n),OpcodStato(n+1)=G(Stato(n),Opcode)e) Stato 1 e 2Stato 1 e 2
CPU (2) 67
Implementazione con un Implementazione con un SequenzializzatoreSequenzializzatore
Inserire:Inserire:1.1. ContatoreContatore
Incremento Stato Incremento Stato
2.2. Logica selezione Logica selezione prossimo statoprossimo stato Per i “salti” Per i “salti”
Aggiungere un Aggiungere un segnale di controllo segnale di controllo AddrCtrlAddrCtrl che controlla che controlla come si determina il come si determina il prossimo stato:prossimo stato: Stato(n)+1Stato(n)+1 00 In base a Stato(n)In base a Stato(n)
+Opcode+Opcode
CPU (2) 68
Sequenzializzatore Sequenzializzatore in dettaglioin dettaglio
Rom
CPU (2) 69
Sequenzializzatore: Contenuto della Memoria di Sequenzializzatore: Contenuto della Memoria di ControlloControllo
Stato Uscita Linee di Controllo
AddrCtl
0000 1001010000001000 110001 0000000000011000 010010 0000000000101000 100011 0011000000000000 110100 0000001000000010 000101 0010100000000000 000110 0000000001000100 110111 0000000000000011 001000 0100000010100100 001001 1000000100000000 00
Funzione F
Funzione G
CPU (2) 70
MicroprogrammazioneMicroprogrammazione
Unita’ di Controllo e’ la parte piu’ complessa del Unita’ di Controllo e’ la parte piu’ complessa del ProcessoreProcessore DataPath ha struttura regolareDataPath ha struttura regolare Controllo di un set completo ISA ha centinaia/migliaia di Controllo di un set completo ISA ha centinaia/migliaia di
statistati
Rappresentazione Grafica dell’Unita’ di Controllo Rappresentazione Grafica dell’Unita’ di Controllo estramamente complessaestramamente complessa
Necessita’ Strumento Progettuale piu’ Efficace: Necessita’ Strumento Progettuale piu’ Efficace: MicroprogrammazioneMicroprogrammazione
Obiettivo: Obiettivo: Impiegare una Rappresentazione Impiegare una Rappresentazione Simbolica dell’Unita’ di Controllo – Simbolica dell’Unita’ di Controllo – MicroprogrammaMicroprogramma Richiama il formato di un programmaRichiama il formato di un programma La logica di controllo si ottiene sintetizzando il La logica di controllo si ottiene sintetizzando il
microprogramma con prodotti CADmicroprogramma con prodotti CAD
CPU (2) 71
MicroprogrammazioneMicroprogrammazione
IdeaIdea: Considerare i segnali di : Considerare i segnali di controllo che devono essere controllo che devono essere affermati ad un certo passo come affermati ad un certo passo come una una (micro)istruzione(micro)istruzione da far da far eseguire dal DataPatheseguire dal DataPath
““Eseguire” una microistruzione Eseguire” una microistruzione significa affermare i segnali di significa affermare i segnali di controllo specificati dalla controllo specificati dalla microistruzionemicroistruzione
Microistruzione specifica:Microistruzione specifica: I segnali di controllo da affermareI segnali di controllo da affermare La prossima microistruzioneLa prossima microistruzione
Microistruzione corrisponde ad uno Microistruzione corrisponde ad uno Stato dell’Automa di ControlloStato dell’Automa di Controllo
Microprogramma: Sequenza di Microprogramma: Sequenza di Microistruzioni in forma simbolicaMicroistruzioni in forma simbolica
Stato Uscita Linee di Controllo
AddrCtl
0000 1001010000001000 110001 0000000000011000 010010 0000000000101000 100011 0011000000000000 110100 0000001000000010 000101 0010100000000000 000110 0000000001000100 110111 0000000000000011 001000 0100000010100100 001001 1000000100000000 00
microistruzione
CPU (2) 72
Microprogrammazione: Formato MicroistruzioniMicroprogrammazione: Formato Microistruzioni
Rappresentazione simbolica delle microistruzioniRappresentazione simbolica delle microistruzioni Etichetta, Campo1, Campo2, Campo3,…, SequenzaEtichetta, Campo1, Campo2, Campo3,…, Sequenza
EtichettaEtichetta specifica locazione (in memoria) della microistruzione specifica locazione (in memoria) della microistruzione SequenzaSequenza specifica come scegliere la prossima microistruzione specifica come scegliere la prossima microistruzione Segnali di controllo sono raggruppati in Segnali di controllo sono raggruppati in CampiCampi (field) (field)
– Segnali di uno stesso campo hanno funzioni tra loro Segnali di uno stesso campo hanno funzioni tra loro collegatecollegate
Progettazione Formato Microistruzioni Progettazione Formato Microistruzioni
1.1. Individuare Segnali di ControlloIndividuare Segnali di Controllo
2.2. Raggruppare i segnali in CampiRaggruppare i segnali in Campi Segnali che svolgono funzioni fra loro collegateSegnali che svolgono funzioni fra loro collegate
3.3. Ordinare i CampiOrdinare i Campi
4.4. Creare una Tabella del Formato Microistruzioni che mostriCreare una Tabella del Formato Microistruzioni che mostri Nomi dei campiNomi dei campi Valori assumibili da ciascun campo e relativa funzione svoltaValori assumibili da ciascun campo e relativa funzione svolta Relativi impostazioni dei segnali di controlloRelativi impostazioni dei segnali di controllo
CPU (2) 73
Campi Microistruzioni (Passi 1-3)Campi Microistruzioni (Passi 1-3)
CampoCampo Segnali di Segnali di ControlloControllo
FunzioneFunzione
ALU ALU controlcontrol
ALUOpALUOp Operazione compiuta da ALU; risultato in Operazione compiuta da ALU; risultato in ALUOutALUOut
SRC1SRC1 ALUSrcAALUSrcA Provenienza primo operando ALUProvenienza primo operando ALU
SRC2SRC2 ALUSrcBALUSrcB Provenienza secondo operando ALUProvenienza secondo operando ALU
Register Register controlcontrol
RegWrite, RegWrite, RegDest, RegDest, MemtoRegMemtoReg
Lettura o scrittura dei registri nel banco e Lettura o scrittura dei registri nel banco e provenienza dei valori in caso di scritturaprovenienza dei valori in caso di scrittura
MemoryMemory MemRead,MemMemRead,MemWrite, IorDWrite, IorD
Lettura o scrittura della memoria e provenienza Lettura o scrittura della memoria e provenienza dei dati; in caso di lettura specifica il registro di dei dati; in caso di lettura specifica il registro di destinazionedestinazione
PCWrite PCWrite controlcontrol
PCWrite, PCWrite, PCSource, PCSource, PRWriteCondPRWriteCond
Modalità di aggiornamento di PCModalità di aggiornamento di PC
SequencinSequencingg
AddrCtlAddrCtl Modalità di scelta dell’istruzione successivaModalità di scelta dell’istruzione successiva
CPU (2) 74
Campi Istruzione (Passo 4) -1Campi Istruzione (Passo 4) -1
Field name Value Signals active CommentAdd ALUOp = 00 Cause the ALU to add.
ALU control Subt ALUOp = 01 Cause the ALU to subtract; this implements the compare for
branches.
Func code ALUOp = 10 Use the instruction's function code to determine ALU control.
SRC1 PC ALUSrcA = 0 Use the PC as the first ALU input.
A ALUSrcA = 1 Register A is the first ALU input.
B ALUSrcB = 00 Register B is the second ALU input.
SRC2 4 ALUSrcB = 01 Use 4 as the second ALU input.
Extend ALUSrcB = 10 Use output of the sign extension unit as the second ALU input.
Extshft ALUSrcB = 11 Use the output of the shift-by-two unit as the second ALU input.
Read 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 ALU RegWrite, Write a register using the rd field of the IR as the register number and
Register RegDst = 1, the contents of the ALUOut as the data.
control MemtoReg = 0Write MDR RegWrite, Write a register using the rt field of the IR as the register number and
RegDst = 0, the contents of the MDR as the data.
MemtoReg = 1
CPU (2) 75
Campi Istruzione (Passo 4) -2Campi Istruzione (Passo 4) -2
Field name Value Signals active CommentRead PC MemRead, Read memory using the PC as address; write result into IR (and
lorD = 0 the MDR).
Memory Read ALU MemRead, Read memory using the ALUOut as address; write result into MDR.
lorD = 1Write ALU MemWrite, Write memory using the ALUOut as address, contents of B as the
lorD = 1 data.
ALU PCSource = 00 Write the output of the ALU into the PC.
PCWritePC write ALUOut PCSource = 01, If the Zero output of the ALU is active, write the PC with the contents
control -cond PCWriteCond of the register ALUOut.
jump PCSource = 10, Write the PC with the jump address from the instruction.
address PCWriteSeq AddrCtl = 11 Choose the next microinstruction sequentially.
Sequencing Fetch AddrCtl = 00 Go to the first microinstruction to begin a new instruction.
Dispatch 1 AddrCtl = 01 Dispatch using the ROM 1.
Dispatch 2 AddrCtl = 10 Dispatch using the ROM 2.
CPU (2) 76
LabelALU
control SRC1 SRC2Register control Memory
PCWrite control Sequencing
Fetch Add PC 4 Read PC ALU SeqAdd PC Extshft Read Dispatch 1
Mem1 Add A Extend Dispatch 2LW2 Read ALU Seq
Write MDR FetchSW2 Write ALU FetchRformat1 Func code A B Seq
Write ALU FetchBEQ1 Subt A B ALUOut-cond FetchJUMP1 Jump address Fetch
Dispatch ROM 1
Dispatch ROM 2Op Opcode name Value
Op Opcode name Value000000 R-format Rformat1
100011 lw LW2000010 jmp JUMP1
101011 sw SW2000100 beq BEQ1100011 lw Mem1101011 sw Mem1
Microprogramma di Controllo CompletoMicroprogramma di Controllo Completo
CPU (2) 77
ImplementazioneImplementazione
Il Microprogramma e’ Il Microprogramma e’ una rappresentazione una rappresentazione alternativa di un automa alternativa di un automa a stati finitia stati finiti Implementabile secondo Implementabile secondo
lo schema con lo schema con sequenzializzatore visto sequenzializzatore visto prima doveprima dove
ROM<-> Memoria ROM<-> Memoria MicrocodiceMicrocodice
Stato<-> Contatore di Stato<-> Contatore di MicroprogrammaMicroprogramma
CPU (2) 78
Unita’ di Controllo MicroprogrammataUnita’ di Controllo Microprogrammata
Il Processore “interpreta” le istruzioni Il Processore “interpreta” le istruzioni macchina in memoriamacchina in memoria Legge istruzioni in memoria (scritte in L2)Legge istruzioni in memoria (scritte in L2) Ne simula il comportamento passo passo Ne simula il comportamento passo passo
“eseguendo” una sequenza di microistruzioni (in L1)“eseguendo” una sequenza di microistruzioni (in L1) L’Unita’ di Controllo genera i segnali di controllo e L’Unita’ di Controllo genera i segnali di controllo e
determina il sequenziamento determina il sequenziamento Il Datapath realizza le operazioni ed il trasferimento fra Il Datapath realizza le operazioni ed il trasferimento fra
registri secondo i segnali di controlloregistri secondo i segnali di controllo
Il Microprogramma dell’Unita’ di Controllo Il Microprogramma dell’Unita’ di Controllo (scritto in L1) e’ l’interprete del linguaggio (scritto in L1) e’ l’interprete del linguaggio macchina (L2) macchina (L2)
CPU (2) 79
Riassunto Metodi Alternativi per Specificare ed Riassunto Metodi Alternativi per Specificare ed Implementare l’Unita’ di ControlloImplementare l’Unita’ di Controllo
RappresentazioneIniziale
Controllo delSequenziamento
RappresentazioneLogica
Implementazione
Automa aStati Finiti Microprogramma
Funzione pross.Stato in forma
esplicita
Contatore+Tabelle di dispatch
Tabelle di Verita’Equazione booleane
PLA ROM
Controllo
Cablato
Controllo Microprogrammato
CPU (2) 80
Vantaggi nella ProgettazioneVantaggi nella Progettazione Semplicita’ nella progettazione e scritturaSemplicita’ nella progettazione e scrittura Design congiunto dell’architettura e del microprogrammaDesign congiunto dell’architettura e del microprogramma
Vantaggi nell’ImplementazioneVantaggi nell’Implementazione Facile da modificare (implementazione su off-chip ROM – anni Facile da modificare (implementazione su off-chip ROM – anni
’60-’70)’60-’70)
Permette l’emulazione di altre ISAPermette l’emulazione di altre ISA
Svantaggi dell’ImplementazioneSvantaggi dell’Implementazione Controllo e’ oggi sullo stesso chip del processoreControllo e’ oggi sullo stesso chip del processore
ROM e’ oggi (relativamente) lenta rispetto alle altre memorieROM e’ oggi (relativamente) lenta rispetto alle altre memorie
Non c’e’ piu’ necessita’ di cambiare il microprogramma di Non c’e’ piu’ necessita’ di cambiare il microprogramma di
controllo controllo Computer general purposeComputer general purpose
Microprogrammazione: Pro e ControMicroprogrammazione: Pro e Contro
CPU (2) 81
EccezioniEccezioni
La gestione delle eccezioni e degli interrupt è una delle parti La gestione delle eccezioni e degli interrupt è una delle parti più difficili del controllopiù difficili del controllo
Eccezione: un evento non atteso, Eccezione: un evento non atteso, internointerno al processore, che al processore, che interrompe l’esecuzione del programmainterrompe l’esecuzione del programma Esempi: overflow aritmetico, istruzione non definita Esempi: overflow aritmetico, istruzione non definita
Interrupt: un evento non atteso, Interrupt: un evento non atteso, esternoesterno al processore, che al processore, che interrompe l’esecuzione del programmainterrompe l’esecuzione del programma Esempi: richiesta di un dispositivo di I/O, malfunzionamento Esempi: richiesta di un dispositivo di I/O, malfunzionamento
hardwarehardware Nella terminologia MIPS: interrupt Nella terminologia MIPS: interrupt eccezione eccezione Nella terminologia IA-32: non c’è distinzione tra interrupt ed Nella terminologia IA-32: non c’è distinzione tra interrupt ed
eccezioneeccezione
CPU (2) 82
Gestione delle eccezioniGestione delle eccezioni
Quando avviene un’eccezione occorreQuando avviene un’eccezione occorre Salvare nel registro Salvare nel registro EPCEPC (Exception Program Counter) l’indirizzo (Exception Program Counter) l’indirizzo
dell’istruzione che ha causato l’eccezionedell’istruzione che ha causato l’eccezione Trasferire il controllo al sistema operativo a qualche indirizzo specifico Trasferire il controllo al sistema operativo a qualche indirizzo specifico
per la gestione dell’eccezioneper la gestione dell’eccezione Il sistema operativo, dopo aver eseguito le azioni necessarie, può Il sistema operativo, dopo aver eseguito le azioni necessarie, può
terminare il programma o continuarne l’esecuzione usando EPC per terminare il programma o continuarne l’esecuzione usando EPC per determinare da dove riprendere l’esecuzione determinare da dove riprendere l’esecuzione
Oltre a EPC, il sistema operativo deve conoscere la ragione Oltre a EPC, il sistema operativo deve conoscere la ragione dell’eccezione; esistono due meccanismidell’eccezione; esistono due meccanismi
Registro di statoRegistro di stato ( (CauseCause register nel MIPS): contiene un campo che indica register nel MIPS): contiene un campo che indica la causa dell’eccezionela causa dell’eccezione
Interrupt vettorializzatoInterrupt vettorializzato: l’indirizzo a cui trasferire il controllo è determinato : l’indirizzo a cui trasferire il controllo è determinato dalla causa dell’eccezionedalla causa dell’eccezione
Consideriamo due tipi di eccezioni nell’implementazione a ciclo Consideriamo due tipi di eccezioni nell’implementazione a ciclo multiplomultiplo Esecuzione di un’istruzione non definitaEsecuzione di un’istruzione non definita Overflow aritmeticoOverflow aritmetico
CPU (2) 83
Gestione delle eccezioni (2)Gestione delle eccezioni (2)
Per gestire le eccezioni nel MIPS occorre aggiungere Per gestire le eccezioni nel MIPS occorre aggiungere nell’unità di elaborazionenell’unità di elaborazione Registro EPC a 32 bitRegistro EPC a 32 bit Registro Cause a 32 bitRegistro Cause a 32 bit
Istruzione non definita: Cause = 0Istruzione non definita: Cause = 0 Overflow aritmetico: Cause = 1Overflow aritmetico: Cause = 1
Aggiungiamo due segnali di controllo per abilitare la Aggiungiamo due segnali di controllo per abilitare la scrittura dei registri EPC e Cause: scrittura dei registri EPC e Cause: EPCWriteEPCWrite e e CauseWriteCauseWrite
Aggiungiamo un altro segnale di controllo per settare il Aggiungiamo un altro segnale di controllo per settare il bit meno significativo del registro Cause: bit meno significativo del registro Cause: IntCauseIntCause
Occorre scrivere in PC l’Occorre scrivere in PC l’indirizzo di eccezioneindirizzo di eccezione (punto di (punto di ingresso del sistema operativo per gestire le eccezioni)ingresso del sistema operativo per gestire le eccezioni) Nel MIPS, l’indirizzo di eccezione è (8000 0180)Nel MIPS, l’indirizzo di eccezione è (8000 0180)1616 Modifichiamo il multiplexer in ingresso a PC da tre a Modifichiamo il multiplexer in ingresso a PC da tre a
quattro viequattro vie PCSource = 11 per abilitare l’indirizzo di eccezione PCSource = 11 per abilitare l’indirizzo di eccezione
CPU (2) 84
L’unità a ciclo multiplo con la gestione L’unità a ciclo multiplo con la gestione delle eccezionidelle eccezioni
Indirizzo di eccezione
EPC: usiamo ALU per
sottrarre 4 a PC
CPU (2) 85
La macchina a stati finiti con la gestione La macchina a stati finiti con la gestione delle eccezionidelle eccezioni
top related