Post on 17-Feb-2019
1
Pag. 1
Struttura del processoreStruttura del processore
L’unità di elaborazioneL’unità di elaborazione
Corso ACSO Corso ACSO –– prof. Cristina SILVANOprof. Cristina SILVANOPolitecnico di MilanoPolitecnico di Milano
DataData--path ad un solo bus internopath ad un solo bus interno
Faremo riferimento ad una generica CPU e a una memoria con parole da 32 bit (istruzioni e dati)I i iI registri:
– PC: Program Counter – registro contatore di programma;– MAR/MDR (registri per accesso a memoria): Memory
Address Register e Memory Data Register– IR: Instruction Register – registro istruzione in esecuzione;– R0 … Rn: Registri del banco di registri;– TEMP, V, Z (registri interni non visibili al programmatore);
-- 22 --
L’unità di controllo:– Decodifica le istruzioni;– Emette i segnali di controllo interni e esterni (bus per
accesso a memoria e periferiche);– Può essere cablata o microprogrammata.
2
Pag. 2
linee di indirizzo
bus di memoria
PC
MAR
ordini
decodificatoredi istruzioni e circuito
di controllo
bus interno del processore
comandi
linee di datoMDR
V
IR
R0
select costante 4
MUX banco di registri
-- 33 --
riportoin
ingresso
ALU
Z
add
and sub
TEMP
linee di comando della ALU
Rn−1
A B
R
Collegamenti registri e bus Collegamenti registri e bus interno del processoreinterno del processore
Riin
Ri
bus interno del processore
Riout
Vin
BAALU
V
costante da 4 bit
select MUX
R
-- 44 --
Z
Zin
Zout
R
3
Pag. 3
Il registro MDR: collegamenti con bus esterno di Il registro MDR: collegamenti con bus esterno di memoria e con bus interno del processorememoria e con bus interno del processore
linee di dato
MDR
linee di dato del bus esterno
di memoria bus interno del processore
MDRoutE MDRout
-- 55 --
MDRinE MDRin
Sequenza di controlloSequenza di controllo
La sequenza di controllo per eseguire una istruzione assembly è composta da diversi passi, uno per ogni ciclo di clock del processore:
– Fetch (prelievo);(p );– Decode (decodifica);– Execute (esecuzione).
Ad ogni passo (ciclo di clock) vengono generati i comandi (attivi in parallelo) Esempi di comandi:
– Lettura di un registro (dal registro al bus interno) R0out
– Scrittura su un registro (dal bus interno al registro) R1in
– Operazione dell’ALU: add, sub, .....Lettura e scrittura in memoria: read write
-- 66 --
– Lettura e scrittura in memoria: read, writeComandi mutuamente esclusivi
– Lettura da registro: un solo registro alla volta può essere caricato sul bus interno
– Singola operazione dell’ALU
4
Pag. 4
Esempio di operazione aritmetica:Esempio di operazione aritmetica:R3 <R3 <-- [R1] + [R2][R1] + [R2]
Passo Comandi Operazione (in RTL)
1. R1out, Vin V <- [R1]
2. R2out, select V, add, Zin Z <- [V] + [R2]
3. Zout, R3in R3 <- [Z]
RTL: Register Transfer Level o livello di trasferimento tra registri
-- 77 --
Esempio di caricamento da memoria (LOAD):Esempio di caricamento da memoria (LOAD):movemove (R1), R2 (R1), R2 ! R2 <! R2 <-- [[R1]][[R1]]
Passo Comandi Operazione (in RTL)
1. R1out, MARin, read MAR <- [R1], read
2. MDRinE, WMFC MDR <- [data bus], wait
3. MDRout, R2in R2 <- [MDR]
WMFC: Wait for Memory Function Completion
-- 88 --
5
Pag. 5
Esempio di memorizzazione: (STORE):Esempio di memorizzazione: (STORE):movemove R2, (R1) R2, (R1) ![![R1R1] <] <-- [R2][R2]
Passo Comandi Operazione (in RTL)
1. R1out, MARin MAR <- [R1]
2. R2out, MDRin, write MDR <- [R2], write
3. MDRoutE, WMFC data_bus <- [MDR], wait
WMFC: Wait for Memory Function Completion
-- 99 --
Riscontro del completamento dell’operazione Segnale MFC (Memory function completion)E’ attivato dallo slave e indica il completamento dell’operazione
Accesso a memoriaAccesso a memoria
E attivato dallo slave e indica il completamento dell operazione– Ad esempio in lettura indica che il dato è presente sul bus
Comando WMFC (wait for MFC): questo ordine “blocca” l’avanzamento dei passi di controllo finché il processore non riceve il segnale MFC.
– Lettura da memoria: l’uso del registro MDR può avvenire solo al passo successivo a quello associato a WMFC. In generale quindi l’ordine WFMC viene emesso al passo precedente a quello in cui si utilizza il registro MDRScrittura in memoria: l’ordine WMFC viene emesso in generale nello
-- 1010 --
– Scrittura in memoria: l ordine WMFC viene emesso in generale nello stesso passo in cui viene emesso il segnale di write
Clock e temporizzazione:Il fronte attivo per la memorizzazione in un registro è quello di salita
6
Pag. 6
1 2
clock
i di i
passo 3
MARin
1 2 3 4 5
Temporizzazione Temporizzazione dell’operazione di dell’operazione di caricamento (lettura) caricamento (lettura) indirizzo
R / W
dato
read
MDRinE
caricamento (lettura) caricamento (lettura) da memoria (LOAD)da memoria (LOAD)
-- 1111 --
dato
MFC(riscontra)
MDRout
Ottimizzazione del trasferimento da memoriaOttimizzazione del trasferimento da memoria
Passo Comandi Operazione (in RTL)
1. R1out, MARin, read, WMFC MAR <- [R1], read, wait
2. MDRout, R2in R2 <- [MDR]
WMFC: Wait for Memory Function Completion
-- 1212 --
7
Pag. 7
Sequenza di controllo completa: ADD R0, R1Sequenza di controllo completa: ADD R0, R1
Consideriamo l’istruzione ASM ADD R0, R1 ! R1<- [R0] + [R1]Fetch (identica per tutte le istruzioni):
Decode:decodificare l’IR;
Passo Comandi Operazione (in RTL)
1. PCout, MARin, read, select 4, add, Zin MAR <- [PC], Z <- [PC] + 4, read
2. Zout, PCin, Vin, WMFC PC <- [Z], V<- [Z], wait
3. MDRout, IRin IR <- [MDR]
-- 1313 --
– decodificare l IR;
Execute:
4. R0out, Vin V <- [R0]
5. R1out, select V, add, Zin Z <- [V] + [R1]
6. Zout, R1in, end R1 <- [Z]
Consideriamo l’istruzione ASM ADD (R3), R1 !R1 <- [[R3]] + [R1]Fetch (identica per tutte le istruzioni):
Sequenza di controllo completa: ADD (R3), R1Sequenza di controllo completa: ADD (R3), R1
Decode:– decodificare l’IR;
Execute:
Passo Comandi Operazione (in RTL)
1. PCout, MARin, read, select 4, add, Zin MAR <- [PC], Z <- [PC] + 4, read
2. Zout, PCin, Vin, WMFC PC <- [Z], V<- [Z], wait
3. MDRout, IRin IR <- [MDR]
-- 1414 --
Execute:
4. R3out, MARin, read MAR <- [R3], read
5. R1out, Vin , WMFC V <- [R1], wait
6. MDRout, select V, add, Zin Z <- [V] + [MDR]
7. Zout, R1in, end R1 <- [Z]
8
Pag. 8
Consideriamo l’istruzione ASM MOVE (R1), R2 ! R2 <- [[R1]]Fetch (identica per tutte le istruzioni):
Sequenza di controllo completa: MOVE (R1), R2Sequenza di controllo completa: MOVE (R1), R2
Decode:– decodificare l’IR;
Execute:
Passo Comandi Operazione (in RTL)
1. PCout, MARin, read, select 4, add, Zin MAR <- [PC], Z <- [PC] + 4, read
2. Zout, PCin, Vin, WMFC PC <- [Z], V<- [Z], wait
3. MDRout, IRin IR <- [MDR]
-- 1515 --
Execute:
4. R1out, MARin, read MAR <- [R1], read
5. MDRinE, WMFC MDR <- [data bus], wait
6. MDRout, R2in , end R2 <- [MDR]
Consideriamo l’istruzione ASM MOVE #costante, R1 (istruzione codificata su 2 parole) : R1 <- costanteFetch (identica per t tte le istr ioni):
Sequenza di controllo completa: Sequenza di controllo completa: MOVE MOVE #costante#costante, R1, R1
Fetch (identica per tutte le istruzioni):
Decode:– decodificare l’IR;
Passo Comandi Operazione (in RTL)
1. PCout, MARin, read, select 4, add, Zin MAR <- [PC], Z <- [PC] + 4, read
2. Zout, PCin, Vin, WMFC PC <- [Z], V<- [Z], wait
3. MDRout, IRin IR <- [MDR]
-- 1616 --
decodificare l IR;
Execute:
4. PCout, MARin, read, select 4, add, Zin MAR <- [PC], Z <- [PC] + 4, read
5. Zout, PCin, WMFC PC <- [Z], wait
6. MDRout, R1in, end R1 <- [MDR]
9
Pag. 9
Sequenza di controllo completa: Sequenza di controllo completa: salto salto incondizionatoincondizionato
Consideriamo l’istruzione ASM:JMP offset(PC) ! PC ← offset + [PC]
Fetch (identica per tutte le istruzioni):
Decode:decodificare l’IR;
Passo Comandi Operazione (in RTL)
1. PCout, MARin, read, select 4, add, Zin MAR <- [PC], Z <- [PC] + 4, read
2. Zout, PCin, Vin, WMFC PC <- [Z], V <- [Z], wait
3. MDRout, IRin IR <- [MDR]
-- 1717 --
– decodificare l IR;
Execute:
4. Offset of IRout, Select V, Add, Zin Z <- [V] + offset_IRout
5. Zout, PCin, end PC <- [Z]
Sequenza di controllo completa: Sequenza di controllo completa: salto condizionatosalto condizionato
Consideriamo l’istruzione ASM:BCC <0 offset(PC) ! BCC <0 PC ← offset + [PC]Fetch (identica per tutte le istruzioni):
Decode:decodificare l’IR;
Passo Comandi Operazione (in RTL)
1. PCout, MARin, read, select 4, add, Zin MAR <- [PC], Z <- [PC] + 4, read
2. Zout, PCin, Vin, WMFC PC <- [Z], V <- [Z], wait
3. MDRout, IRin IR <- [MDR]
-- 1818 --
– decodificare l IR;
Execute:
4. Offset of IRout, Select V, Add, Zinif bit N=0 end
Z <- [V] + offset_Iroutif bit N=0 end
5. Zout, PCin, end PC <- [Z]
10
Pag. 10
Le istruzioni ISA di salto condizionatoLe istruzioni ISA di salto condizionato
BRA LABEL (long – istruzione codificata su 2 parole)PC <- LABEL + [PC]
Passo Comandi Operazione (in RTL)
1. PCout, MARin, read, select 4, add, Zin MAR <- [PC], Z <- [PC] + 4, read
2. Zout, PCin, Vin, WMFC PC <- [Z], V<- [Z], wait
3. MDRout, IRin IR <- [MDR]
-- 1919 --
4. PCout, MARin, read, select 4, add, Zin MAR <- [PC], Z <- [PC] + 4, read
5. Zout, PCin, Vin, WMFC PC <- [Z], V <- [Z], wait
6. MDRout, Select V, Add, Zin Z <- [V] + [MDR]
7. Zout, PCin, end PC <- [Z]
Le istruzioni ISA di salto condizionatoLe istruzioni ISA di salto condizionato
Bcc <0 OFFSET (long – istruzione codificata su 2 parole)( g p )
Passo Comandi Operazione (in RTL)
1. PCout, MARin, read, select 4, add, Zin MAR <- [PC], Z <- [PC] + 4, read
2. Zout, PCin, Vin, WMFC PC <- [Z], V<- [Z], wait
3 MDR t IRi IR <- [MDR]
-- 2020 --
3. MDRout, IRin IR < [MDR]
4. PCout, MARin, read, select 4, add, Zin MAR <- [PC], Z <- [PC] + 4, read
5. Zout, PCin, Vin, WMFC, if bit N=0 end PC <- [Z], V <- [Z], wait, if bit N=0 end
6. MDRout, Select V, Add, Zin Z <- [V] + [MDR]
7. Zout, PCin, end PC <- [Z]
11
Pag. 11
Struttura del processoreStruttura del processore
L’unità di controlloL’unità di controllo
Unità di controlloUnità di controllo
L’unità di controllo emette i segnali di controllo (comandi) che regolano il funzionamento del data-path.L’unità di controllo può essere:p
– cablata:• costruita ad-hoc;• basata su decodificatore di istruzioni (che utilizza l’IR),
contatore (per scandire la successione dei passi di controllo), codici di condizione, segnali esterni e rete combinatoria in grado di generare i comandi ad ogni passo di controllo.
– microprogrammata:d difi l i i i l i i di ll
-- 2222 --
• decodifica le istruzioni e legge in una memoria di controllo (control-store) tramite microPC una microparola con i segnali di controllo da emettere.
12
Pag. 12
Unità di controllo cablataUnità di controllo cablata
ripristina lo stato inizialeclock contatore passidi controllo
blocca il
segnali esterni
generatore di ordini
decodificatoredi istruzione
decodificatoredi passo
IR
T1 T2 Tn
ISTR1
ISTR2
conteggio
-- 2323 --
ordini
run (WMFC) end
bit di esito (codici di cond.)
ISTRm
Esempio: Generazione segnale Esempio: Generazione segnale ZZinin
addbranch
T4 T6
Zin = T1 OR T4 AND "IR=branch" ORT6 AND "IR=add" OR
T1
T4 T6 T6 AND IR=add OR…
-- 2424 --
Zin
13
Pag. 13
Unità di controllo microprogrammataUnità di controllo microprogrammata
Il comportamento dell’unità di controllo microprogrammatadipende esclusivamente dal contenuto della memoria di controllo(control store) detta anche memoria di microprogramma(control store) detta anche memoria di microprogramma.I bit di controllo di ogni passo sono memorizzati in una parola di memoria della control storeOgni parola di memoria viene chiamata micro-istruzioneLa sequenza di microistruzioni corrispondenti ai passi di controllo per l’esecuzione di un’istruzione ISA costituisce una microroutineL’insieme di microroutine costituisce il microprogramma
-- 2525 --
I calcolatori dove è possibile modificare il contenuto del controlstore sono detti “microprogrammabili”Vediamo un esempio di control store per l’istruzione ADD (R3), R1
Esempio di control storeEsempio di control store
Passo Comandi per ADD (R3), R1 Operazione (in RTL)
1. PCout, MARin, read, select 4, add, Zin MAR <- [PC], Z <- [PC] + 4, read
2. Zout, PCin, Vin, WMFC PC <- [Z], V<- [Z], wait
3. MDRout, IRin IR <- [MDR]4. R3out, MARin, read MAR <- [R3], read
5. R1out, Vin , WMFC V <- [R1], wait
PCin
01
00
10
1 0
10
00
00
01
10
10
10
01
00
00
00
01
μ istruz.
12
PCou
t M
AR
in
read
MD
Rou
t IR
in
V in
sele
ct
add
Z in
Z out
R1 o
ut
R1 i
n R
3 out
WM
FC
end
6. MDRout, select V, add, Zin Z <- [V] + [MDR]
7. Zout, R1in, end R1 <- [Z]
-- 2626 --
1
00000
0
00001
0
00000
0 0 1 0 0 0
0
01000
0
10010
0
10000
1
00100
0
00000
0
00010
0
00010
1
00001
0
00100
0
00001
0
01000
1
00100
2
34567
14
Pag. 14
Struttura unità di controllo Struttura unità di controllo μμprogrammataprogrammata
generatore
ingressi esterni (bus)
clock
generatoredi μ indirizzo
iniziale e di micro
salto
bit di esito (codici di cond.)
IR
μ PC
-- 2727 --
memoria di μ programma
clock μ PC
μ istruzione(ordini al processore)
Esempio di micro routineEsempio di micro routine
1. PCout, MARin, Read, select 4, Zin Add2. Zout, PCin, Vin, WMFC3. MDRout, IRin
4. Salta al microindirizzo della micro routine appropriata (decodifica IR)
..................
25.PCout, MARin, Read, select 4, Add, Zin26.Zout, PCin, Vin ,WMFC, if bit N=0 end (goto microistr. 1)27 MDR select V Add Z
-- 2828 --
27.MDRout, select V, Add, Zin28.Zout, PCin, end (goto microistr. 1)
15
Pag. 15
Formato Formato μμistruzioneistruzione (codificata)(codificata)
Per ridurre la lunghezza della microistruzione (e della relativa control store)
cerchiamo di applicare na codifica dei bit di controllo -> cerchiamo di applicare una codifica dei bit di controllo contenuti nella microistruzione suddividendola in campi di bit corrispondenti a gruppi di comandi mutuamente esclusivi
C1 C2 C3 C4 C5 C6 C7 C8 μ istruzione suddivisa in campi di bit Ci (Ci codifica un gruppo di ordini mutuamente esclusivi)
Ovviamente, occorreranno, a valle della control store, dei circuiti di decodifica per rigenerare i bit di controllo
-- 2929 --
Formato Formato μμistruzione (codificata)istruzione (codificata)
Codifica bus interno su ingresso registri MAR, MDR,
-- 3030 --
Codifica su 4 bit dei 16 comandi dell’ALU
Codifica registri in uscita su bus interno
Codifica bus interno su ingresso registri PC, IR, Z, Ri
TEMP, V
16
Pag. 16
Formato Formato μμistruzione (codificata)istruzione (codificata)
Codifica idle/read/write
Codifica selez.MUX in ingresso porta A dell’ALU
Codifica WMFC Codifica end
-- 3131 --
porta A dell ALU
Salti e calcolo del prossimo microindirizzo (1)Salti e calcolo del prossimo microindirizzo (1)
Per ottimizzare la struttura del microcodiceRiuso di parti del microcodice per scrivere le micro routine associate alla fase di esecuzione di ogni istruzione ISAassociate alla fase di esecuzione di ogni istruzione ISAAd esempio per gestire
– le varie modalità di indirizzamento– parti comuni a diverse modalità di indirizzamento
Tecnica: mascheratura del microindirizzoIl microindirizzo “generale” (o base) viene modificatomascherando alcuni bit per generare gli indirizzi corretti
-- 3232 --
mascherando alcuni bit per generare gli indirizzi corretti
17
Pag. 17
Salti e calcolo del prossimo microindirizzo (2)Salti e calcolo del prossimo microindirizzo (2)
Aumento delle prestazioniLe microistruzioni di salto non svolgono alcuna operazione utile ma pilotano solo il flusso di esecuzione del programma p p g(altrimenti governato dal micro PC)Sono cicli macchina “persi” ai fini dell’esecuzione di una istruzione ISA
Soluzione alternativa di gestione del sequenziamentoOgni microistruzione contiene il microindirizzo di quella successiva da eseguire -> inutile il registro micro PC
-- 3333 --
successiva da eseguire > inutile il registro micro PC– Il sequenziamento puro è tradotto in un micro salto alla
microistruzione successiva– I micro salti incondizionati si realizzano codificando il
microindirizzo della microistruzione cui saltare – E’ chiaro che i salti condizionati rimangono
Struttura unità di controllo Struttura unità di controllo microprogrammatamicroprogrammata
Ogni μistruzione contiene il μindirizzo di quellasuccessiva da eseguire
-> inutile il registro μPC sostituito da μMAR aggiornatoad ogni ciclo con il μindirizzo proveniente dal campo μindirizzo della μistruzione (anche per esecuzione diistruzioni in sequenza) che può essere modificatotramite i bit di mascheratura
-- 3434 --
18
Pag. 18
bit di esito (cod. di cond.)
IR
circuiti di mascheraturae decodifica
ingressi esterni (bus)
Bit di mascheratura
memoria diμ programma
μ MAR
schiera diporte OR
-- 3535 --
μ indirizzo
decodificatore di μ ordini
μ ordini (diretti al processore)
μ IRcampi di μ istruzione
controllo delle funzionidi mascheratura e
decdifica del μ indirizzo
Microindirizzo incorporato nella microistruzione
Formato Formato μμistruzione (codificata)istruzione (codificata)
C1 C2 C3 C4 C5 C6 C7 C8
μ istruzione suddivisa in campi di bit Ci (Ci codifica un gruppo di ordini mutuamente esclusivi)
C9 C10 C0
-- 3636 --
19
Pag. 19
Formato Formato μμistruzione (codificata)istruzione (codificata)
Codifica bus interno
Codifica bus interno su
-- 3737 --
Codifica bus interno su ingresso registri PC, IR, Z, Ri
ingresso registri MAR, MDR, TEMP, V
Codifica registri in uscita su bus interno
Formato Formato μμistruzione (codificata)istruzione (codificata)
Codifica su 4 bit dei 16 comandi dell’ALU
Codifica idle/read/write
Codifica selez.MUX in ingresso porta A dell’ALU
Codifica WMFC
-- 3838 --
Codifica opcode IR Codifica maschera bit del campo MODO di IR per specificare il modo di indirizzamento di Rsorgente
Codifica maschera bit 8 di IR del campo modo di IR
20
Pag. 20
Utilizzo campi C8, C9, C10Utilizzo campi C8, C9, C10
Se C8, C9, C10 inattivi: il prossimo μindirizzo è dato dal campo μindirizzo C0 della μistruzione corrente:
μprogramma avanza in modo sequenziale– μprogramma avanza in modo sequenziale(C0= μindirizzo corrente +1)
– μprogramma effettua il μsalto condizionato(C0= indirizzo di destinazione μsalto)
Se C8 o C9 o C10 attivi si effettua il μsalto condizionato secondo le modalità seguenti:
– Se C8 inattivo e C9 o C10 attivi: μsalto condizionato con i di i b di lt d t d C0 bit di h tμindirizzo base di μsalto dato da C0 + bit di mascheratura
– Se C8 attivo e C9 o C10 attivi: μsalto condizionato con μindirizzo base di μsalto dato da decodifica opcode di IR + bit di mascheratura
-- 3939 --
Esempio di memoria di controlloEsempio di memoria di controllo
C9 C10 C8C7C6C5C4C2
ind. ottale C0 C1 C3
1 0 0 1
0 0 0
0 0
0 0
0
0 0
0
00
0
000 0 0 0 0 0
000000 101
0
0
0
10000
00001100000
100
0
0
0
01
0 0
00
0
00 01
001110
10010 1
1 1 0 0 0 0 0 0
2 2 1 1 1 1 0 0 1
1 2
0
2 1
0 0 0
1 1 1 0 0 0 0 0
1 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0
0 0 10 0
0 11001
110100
0
0
10
1
0 1 1000 0 0 0 0 00 00 000 0 0 0 0 0 0 0 3 0 0 00 0 0
-- 4040 --
01
111 1 0 0 1 1 1 1 1 0
0 0 1
1 2 1 0
0 0 0
000
00
00
00
00
00 0
0000
0 00101
1103 7
7 0 0 0 0 0 0 0 0
0 1 1 1 1 110
000
1 7 0 7 0
0 0 0 0
0000 1
00
00
00
00 10
0 00 0
0000000
1 1
0 1 1 1 1 0
010010
01
21
Pag. 21
Struttura del processoreStruttura del processore
L’unità di elaborazione a tre busL’unità di elaborazione a tre bus
Costi vs prestazioniCosti vs prestazioni
La definizione della microarchitettura dipende da un compromesso tra costi e prestazioni.Incremento della prestazioni determinato da:
– tecnologia;– architettura.
Costi difficili da definire (progetto, dimensioni, produzione, resa....).
-- 4242 --
22
Pag. 22
Incremento delle prestazioni Incremento delle prestazioni
Ipotesi: definite tecnologia e ISA.Approcci microarchitetturali per migliorare pp p gprestazioni:
– riduzione del numero di cicli di clock per l’esecuzione di ogni istruzione;
– riduzione della durata del ciclo di clock semplificando l’organizzazione dell’architettura;
– sovrapposizione dell’esecuzione delle istruzioni (pipelining)
-- 4343 --
(pipelining).
Esecuzione di un’istruzioneEsecuzione di un’istruzione
L’esecuzione di ogni istruzione richiede:– lettura dell’istruzione dalla memoria;
d difi d i i d ll’i t i– decodifica dei campi dell’istruzione.
In termini di microistruzioni:– PC passa attraverso la ALU e viene incrementato;– PC viene usato per leggere la parola seguente nel programma;– PC ed ALU vengono usati per leggere gli eventuali operandi.
La ALU è utilizzata per diversi cicli di clock:– per operazioni non legate alla esecuzione di una istruzione ma
i l i
-- 4444 --
piuttosto al suo caricamento;– per caricare un operando in attesa che sia poi disponibilie il
secondo operando.Ciò comporta un notevole spreco di tempo.
23
Pag. 23
Riduzione del numero di cicli di clockRiduzione del numero di cicli di clock
Replicazione di moduli hardware per evitare conflitti di risorse.
– Soluzione 1: inserire un sommatore aggiuntivo per incrementare il PC:
• costoso in termini di area sul silicio;non si verifica un vantaggio sostanziale: incremento del PC avviene durante la fase di lettura dell’istruzione e quindi la ALU non è impegnata.
– Soluzione 2: aggiungere percorsi addizionali:
-- 4545 --
• ad esempio percorsi diretti fra alcuni registri;• aumento del numero dei segnali di controllo;• microistruzioni e microcodice più complessi.
– Soluzione 3: aggiungere un bus addizionale.
Architettura a tre busArchitettura a tre bus
Le operazioni aritmetiche richiedono:– un primo ciclo di clock per caricare un operando nel registro V;
durante tale ciclo la ALU non viene utilizzata;– durante tale ciclo la ALU non viene utilizzata;– un secondo ciclo di clock per eseguire l’operazione.
Un possibile miglioramento consiste nel rendere possibile la connessione diretta di tutti i registri con entrambi gli ingressi dati della ALU.Questa soluzione richiede l’aggiunta di un ulteriore bus. L’architettura risultante è dotata di tre bus:
– BUS A: lettura dei registri sull’operando A della ALUBUS B l d i i i ll’ d B d ll ALU
-- 4646 --
– BUS B: lettura dei registri sull’operando B della ALU– BUS C: scrittura dell’uscita della ALU sui registri
L'unità di controllo deve oportunamente essere modificata per controllare correttamente un processore dotato di tre bus.
24
Pag. 24
bus A bus B bus C
PC
banco di registri
incrementatore
decodificatoredi istruzioni
costante 4
ALU
A
B
R
MUX
-- 4747 -- linee di dato
MDR
linee di indirizzo
MAR
IR
Sequenza di controllo completa (3 bus)Sequenza di controllo completa (3 bus)
Consideriamo l’istruzione ASM: ADD R0, R1Fetch (identica per tutte le istruzioni):( p )
Decode:
Passo Comandi Operazione (in RTL)
1. PCoutB, MARinC, enable B, read, PCinc
MAR <- [PC], PC <- [PC] + 4, R = B, read
2. WMFC wait
3. MDRoutB, enableB, IRin R = B, IR <- [MDR]
-- 4848 --
– decodificare l’IR;
Execute:
4. R0outA, R1outB, Add, R1inC, goto(fetch) R1 <- [R0] + [R1]