07.la - CPU GL

Capitolo 7
La CPU
Calcolatori elettronici – Architettura e organizzazione

Copyright © 2009 – The McGraw-Hill Companies srl
Giacomo Bucci
• Contenuti
– Esame approfondito del funzionamento della CPU
• definizione di un'architettura semplificata ispirata alle macchine
RISC
• sviluppo due prototipi
– Il primo prototipo (CPU1) è costruito in modo da eseguire le
istruzioni in un solo periodo di clock
– Il secondo prototipo (CPU2) esegue istruzioni in più cicli
– Confronto delle prestazioni
– Sistema di interruzione

Giacomo Bucci
Calcolatori elettronici
Architettura di riferimento
• Gli indirizzi di memoria sono riferiti ai byte
• Istruzioni e dati occupano sempre e solo una parola
di 32 bit.
• Istruzioni e dati si trovano in memoria allineate a
indirizzi multipli di 4 (0, 4, 8, 12, ...).
• Se si escludono le istruzioni di salto, la regola di
aggiornamento del registro PC è: PC:= PC + 4
• L'unità operativa presenta 32 registri di uso generale
di 32 bit (R0,R1, …,R31).
• Repertorio di istruzioni estremamente ridotto.

Giacomo Bucci
Formato
Load/Store (F2)
Aritmetiche (F1)
Salto Incon. (F3)
Salto Condiz. (F2)

Giacomo Bucci
Semplificazione
• Si fa l’ipotesi che dentro i campi che corrispondono a

indirizzi/scostamenti ci sia l’indirizzo/lo scostamento
effettivo
– Nella realtà le cose sono diverse. Ad esempio, tenuto conto
della nostra architettura:
• conviene che campo IND del salto contenga l’indirizzo diviso
per 4 (in modo da economizzare e rendere 4 volte più grande
lo spazio indirizzato). Ovviamente, è necessario che in fase di
esecuzione il contenuto di IND venga moltiplicato per 4 (shiftato
di 2 a sinistra)
• Portare IND a 32 bit sarebbe 0000||IND||00
– Invece supporremo che portare IND a 32 bit corrisponda
all’operazione 000000||IND

Giacomo Bucci
Notazione
• La notazione 000000||IND
si indica anche come X(IND)
• La notazione (OFFSET16)16||OFFSET
indica l’azione di portare OFFSET da 16 a 32 bit,
estendendo il segno.
si indica anche come XS(OFFSET)
Assumeremo che ci sia anche l’istruzione NOP

Giacomo Bucci
Istruzioni aritmetiche tra registri
• Il campo OP contiene il codice di generica
operazione aritmetica
• Il campo fALU identifica la specifica operazione da
eseguire, per esempio: ADD, SUB, OR, MUL, etc.
• Le aritmetiche prevedono sempre due registri
sorgente e un registro di destinazione.
• I campi Rs1 e Rs2 identificano i registri sorgente
• Il campo Rd identifica il registro destinazione
Esempio
ADD R1,R2,R3 ;R1:= R2+R3
SUB R4,R4,R2 ;R4:= R4-R2

Giacomo Bucci
Istruzioni LD (Load) e ST (Store)

• Il campo Rb contiene il numero d’ordine del registro
base
• Il OFFSET contiene lo scostamento
Esempio
LD R13,100(R6) ; R13:= M[R6+100]
; R13:= M[R6+XS(OFFSET)]
ST 2000(R7),R2 ; M[R7+2000]:= R2
; M[R7+ XS(OFFSET)]:= R2

Giacomo Bucci
Istr. di trasferimento del controllo
JMP : Jump, Salto incondizionato
JAL : Jump and link, salto incondizionato e collegamento
JE : Jump if equal
JS : Jump on sign
JR : Jump relative, salto relativo a un registro
INT : Interrupt
RFI : Return from interrupt

Giacomo Bucci
Istruzioni di salto e diramazione

• Salto incondizionato
– Il campo OP contiene il codice di salto, il campo IND
(sempre positivo) contiene l’indirizzo di destinazione diviso
per 4. Esempio
JMP label ;PC:= X(IND)
JAL label ;R31:= PC; PC:= X(IND)

• Diramazione (Salto se uguale/sul segno)
– Confronto tra il contenuto dei registri RS1 e RS2 e salto in
caso di uguaglianza. Esempio
JE R1,R2,dest ;if R1=R2 then
;PC:= PC+ XS(OFFSET)
JS R4,R21,dest2

Giacomo Bucci
Altri Trasferimenti
• JR JR R17 ; PC:= R17
• INT INT 5 ;…… ; R30:= PC
• RFI RFI ; PC:= R30

Giacomo Bucci
Fasi di esecuzione
• IF – Instruction Fetch
• ID – Instruction decode
• EX – Execute
• ME – Memory
• WB – Write Back (aggiornamento registro destinazione)
IF ID EX ME WB

Giacomo Bucci
CPU1 (MONOCICLO)
• Esegue istruzioni in un solo periodo di clock
• Richiede che memoria Istruzioni e memoria dati
siano separate (Harvard)
– La memoria istruzioni (MI) rende sempre disponibile il suo

contenuto (quello della cella indirizzata da PC)

Giacomo Bucci
Cosa serve in CPU1

• Una sezione dedicata al prelievo delle istruzioni dalla memoria,
di cui fa parte PC.
– Ad ogni ciclo di clock PC viene incrementato (di 4) in modo da
eseguire l’istruzione successiva
• Una sezione di decodifica dell'istruzione e di prelievo del
contenuto degli eventuali registri sorgente.
• Una sezione relativa alla ALU.
• Una sezione dedicata alla lettura/scrittura nella memoria o alla
scrittura nel registro di destinazione
• L’esecuzione consiste nella propagazione dei segnali:

– Da MI fino alla scrittura nei registri o in memoria

Giacomo Bucci
Esempio : Propagazione ST

Giacomo Bucci
PC presenta il nuovo
valore e MI presenta
l’istruzione. Fino al
prossimo IF la MI
presenta sempre la
medesima istruzione

Giacomo Bucci
L’istruzione viene
decodificata e viene
asserito il comando ST e
vengono prodotti i
comandi che determinano
le azioni necessarie.
I due registri RS1 e RSd
vengono letti in RF.
Il contenuto di Rs1 va alla
ALU, quello di Rsd va
verso la MD.
L’OFFSET dell’istruzione
va alla porta ALU

Giacomo Bucci
Register File

Giacomo Bucci
Interno RF

Giacomo Bucci
La ALU effettua la
somma e calcola
l’indirizzo dove verrà
scritto il dato

Giacomo Bucci
Schema ALU

Giacomo Bucci
Il risultato del calcolo
della ALU viene
propagato fino alla porta
di indirizzi MD. Essendo
asserito il comando ST,
viene asserito il comando
M_Write che determina la
scrittura del dato.
Sul fronte finale del clock
viene incrementato il PC
(+4) usando un sommatore
distinto dalla ALU che è
impegnata sullo stesso
ciclo di clock

Giacomo Bucci
Memoria

Giacomo Bucci
Durata del T del clock

Tmono periodo del clock (per CPU1)
ti tempo richiesto dal generico stadio
tmono,I richiesto dalla generica istruzione I
tmono tempo per l’esecuzione di N istruzioni
tmono,I = ti Σ
(la somma è estesa ai soli stadi interessati dall’istruzione I)
Tmono = max tmono,I
tmono = N Tmono

Giacomo Bucci
Esempio
• 30 ns per l'accesso alla memoria (MI o MD)
• 5 ns per la decodifica dell'istruzione e per lettura dei
registri
• 12 ns un'operazione di ALU
• 5 ns per la scrittura di un registro
MI ID ALU MD WR T
Aritm 30 5 12 5 52
LD 30 5 12 30 5 82
ST 30 5 12 30 77
JE/JS 30 5 12 47
JMP 30 5 35
JAL 30 5 5 40
Tmono = 82 ns
Per l’istruzione JMP il 57% del tempo è sprecato

Giacomo Bucci
CPU1 con memoria unificata….

• Per una CPU a un solo ciclo di clock e memoria
unificata si può ricorrere a questo stratagemma:
– nella prima fase del clock si legge dalla memoria (fetch)
– nella seconda fase si esegue l’istruzione (execute)
• Comporta la presenza di un registro intermedio (IR)
su cui memorizzare l’istruzione

Giacomo Bucci
CPU2
• Memoria unica
• Più cicli di clock, esecuzione in più passi:
– IF
– ID
– EX
– ME
– WB
• Elementi necessari (per ora): PC, IR, RF, ALU
• Ottimizzare l’uso delle risorse
• Controllo maggiore

Giacomo Bucci
IF
• Azioni svolte in IF: IR:= M[PC]; PC:= PC+4
(Durante IF ALU non viene utilizzata => si usa per incrementare PC)

Giacomo Bucci
ID
• Comprende il decodificatore del codice di istruzione
• Il formato dell’istruzione consente la lettura degli
eventuali registri sorgente
• Siccome ancora la ALU non viene impiegata per
l’eventuale operazione richiesta dall’istruzione, si può
impiegarla per il calcolo dell’indirizzo di destinazione
della diramazione. A tal fine occorre un registro di
appoggio (DEST)
• Azione svolta: DEST:= PC + OFFSET

• In realtà DEST := PC+XS(OFFSET)

Giacomo Bucci
ID DEST := PC+OFFSET
Il campo OFFSET deve essere esteso a 32 bit

[operazione XS(OFFSET)]
L’estensione non è mostrata

Giacomo Bucci
EX
• Determinata dal codice di operazione
– Aritmetiche: ALUout:= A fALU B

– LD/ST: ALUout:= A + OFFSET
– JE: ALUout:= A - B; if zero then PC:= DEST
– JS: ALUout:= A - B; if segno then PC:= DEST
– JMP: PC:= IND
– JR PC:= RF.B
– JAL PC:= IND

Giacomo Bucci
EX -- Aritmetiche
ALUOut = A fALU B

Giacomo Bucci
EX -- LD/ST
ALUOut = A + OFFSET
Qui l’estensione è mostrata

Giacomo Bucci
EX -- JE/JS

Giacomo Bucci
EX – JMP/JAL/JR
La JAL deve salvare PC in R31:

• Quando R31 viene scritto (WB) PC è già stato modificato
• Ciò impone la presenza del registro PC1 Aggiornato come PC in IF

Giacomo Bucci
ME
• LD: Dmem:= M[ALUout]
• ST: M[ALUout]:= B

Giacomo Bucci
WB
Aritmetiche LD

Giacomo Bucci
CPU2 complessivo

Giacomo Bucci
Diagramma di stato aggregato
La UC è un automa a stati finiti.

(macro)Stati: prelievo e codifica; 1 stato per ogni istruzione

Giacomo Bucci
Fasi di esecuzione
• IF – Instruction Fetch
• ID – Instruction decode IF ID EX ME WB
• EX – Execute
• ME – Memory
• WB – Write Back (aggiornamento registro destinazione)
• Ad ogni fase corrisponde uno dei 5 cicli di clock T1, T2, T3, T4, T5;
stato Si <=> ciclo di clock Ti
• T1 e T2 vengono spesi nel

macrostato: prelievo e doco-
difica.
• T3-T5 vengono spesi nel
macrostato corrisponden-
te a ciscuna istruzione.
Giacomo Bucci
Comandi e selettori
• COMANDI (= segnali di controllo che hanno effetto solo quando asseriti)
– PC_Write: Per abilitare l'ingresso a PC;

– PC1_Write: per abilitare l'ingresso a PC1;
– M_Read: per leggere la memoria;
– In: per mettere il bus dei dati in ingresso;
– M_Write: per scrivere in memoria;
– Out: per mettere il bus dati in uscita;
– IR_Write: per scrivere nel registro IR;
– R_Write: per scrivere nel registro di destinazione;
– DEST_Write: per scrivere in DEST;

Giacomo Bucci
CPU2 complessivo

Giacomo Bucci
…. Comandi e selettori
• SELETTORI (= segnali ai blocchi di selezione)
– Rsorg: per selezionare il registro di destinazione;
– Dsorg: per selezionare la provenienza a D di RF;
– INDsorg: per selezionare la provenienza dell'indirizzo di
memoria;
– PCsorg: per selezionare la provenienza dell'ingresso a PC
– ALUsorgA: per selezionare la provenienza dell'ingresso A di
ALU;
– ALUsorgB: per selezionare la provenienza dell'ingresso B di
ALU;
– OPALU: per selezionare la funzione di ALU.

Giacomo Bucci
CPU2 complessivo

Giacomo Bucci
Giacomo Bucci
Digramma di stato dettagliato

Giacomo Bucci
Diagr stato dettagliato …fetch decode…..

Giacomo Bucci
Diagr. Dettagliato (execute)

Giacomo Bucci
Stato di Prelievo, IF
Azioni previste: IR <- M[PC]; PC <- PC + 4
• Comandi da asserire durante T1 (stato S1)
– M_Read: per leggere la memoria;
– In: per mettere il bus dei dati in ingresso;
– PC_Write: Per abilitare l'ingresso a PC;
– PC1_Write: per abilitare l'ingresso a PC1;
– IR_Write: per scrivere nel registro IR;
• Valori assunti dai Selettori
– INDsorg=1: per trasmettere alla memoria il contenuto del PC;
– PCsorg=0: per selezionare PC+4, prodotto dalla ALU, come ingresso al
PC
– ALUsorgA=0: per selezionare il PC come ingresso A di ALU;
– ALUsorgB=0: per selezionare la costante 4 come ingresso B di ALU;
– OPALU=ADD: per selezionare la funzione di ALU.

Giacomo Bucci
Stato di Decodifica, ID
La decodifica avviene automaticamente attraverso una
semplice rete combinatoria; quello che si fa è calcolare
l’indirizzo di destinazione per un’eventuale istruzione JE/JS
Azioni previste: DEST <- PC + OFFSET
• Comandi da asserire durante T2 (stato S2)

– DEST_Write: Per memorizzare in DEST l’ind. di destinazione
dell’eventuale JE/JS;
• Valori assunti dai Selettori
– ALUsorgA=0: per selezionare il PC come ingresso A di ALU;
– ALUsorgB=2: per selezionare il campo OFFSET dell’eventuale
istruzione JE/JS come ingresso B di ALU;
– OPALU = ADD: per selezionare la funzione di ALU.
Giacomo Bucci
Istruzioni Aritmetiche
Azioni previste: ALUout = A fALU B
• Comandi da asserire durante T3 (stato S3A) : nessuno

• Valori assunti dai Selettori durante T3 (stato S3A)
– ALUsorgA=1: per selezionare l’uscita A di RF come ingresso A di
ALU;
– ALUsorgB: per selezionare l’uscita B di RF come ingresso B di ALU;
– OPALU: per selezionare la funzione di ALU.
• In T4 tutto come in T3
• Comandi da asserire durante T5 (stato S5A)
– R_Write:per scrivere nel registro destinazione
• Valori assunti dai Selettori durante T5 (stato S5A)
– Rsorg = 0 per scrivere nel registro Rd indicato nell’istruzione
– Dsorg = 0 per selezionare la provenienza da ALU del dato
– JAL=0 per selezionare la provenienza da ALU del dato
Giacomo Bucci
Stato di Decodifica, ID
Dare forma algebrica ai comandi

Giacomo Bucci
Comandi
• Comandi: espressioni trovate come somme di
prodotti tra i periodi e i codici
• Esempio: R_Write deve essere asserito su

– T5 per le aritmetiche, per la LD e per la JAL:
R_Write= T5 . Aritm + T5 . LD + T5.JAL = T5
(la semplificazione è possibile perché su T5 ci sono solo queste tre)
• Esempio: M_Read:
– Su T1 per tutte le istruzioni
– Su T4 e T5 per LD
M_Read= T1 + T4 . LD + T5 .LD

Giacomo Bucci
...Comandi
• In = T1 + T5.LD
• M_Write = T4.ST
• Out = (T3 + T4) ST
• IR_Write = T1
• OPALU si esplicita in tre comandi ADD, SUB, fALU

– ADD = T1 + T2 + T3 (LD+ST) +T4 (LD+ST)+ T5 LD
– SUB = T3 (JE+JS)
– fALU = (T3+T4+T5) ARITM

Giacomo Bucci
Selettori
• Su molti periodi sono ininfluenti (cond.

indifferenza)
Esempio: Dsorg:
– su T1, T2, T3 e T4 è indifferente perché Rwrite è
disasserito.
– Deve essere 1 su S5L e 0 su S5A e S5JAL
– Dunque basta tenere Dsorg a 1 su T5 in presenza di LD e a
0 in tutti gli altri casi. Ovvero Dsorg = T5 . LD
• Selettori a due vie o più di 2 vie (codifica)

Giacomo Bucci
Considerazioni
Tmulti periodo del clock per CPU2. E’ determinato dallo
stadio più lento
τi tempo richiesto dal generico stadio
Tmulti = max τi
Tmono periodo del clock di CPU1. E’ determinato
dall’istruzione più lenta (L’istruzione più lenta è indicata con X;
con x si indica il numero di stadi che attraversa)
Tmono = τmono,X = Σ τi (somma sugli x stadi attraversati)
DUNQUE: τmulti,X = x* Tmulti >= τmono,X = Tmono

Nel multiciclo gli stadi più veloci si devono uniformare al
più lento!!!!

Giacomo Bucci
Confronto monociclo - multiciclo
CPIi = numero di cicli di clock richiesto per una
istruzione di tipo i
τmulti,I = CPIi * Tmulti Durata istruzione di tipo i
N numero di istruzioni eseguite da un programma
pi frazione di istruzioni di tipo i nel programma
tmulti tempo di esecuzione del programma
tmulti = N Σ(pi * τmulti,I ) = N Σ(pi * CPIi * Tmulti)
tmono = N * Tmono
Giacomo Bucci
Confronto monociclo multiciclo
tmono /tmulti = Tmono / Σ(pi * CPIi * Tmulti)
• Multiciclo fornisce migliori prestazioni se:

– L'architettura consente di evitare il passaggio da tutti gli
stadi, in modo che ci siano istruzioni a ridotto numero di
clock, per le quali valga
= CPIi * Tmulti <= Tmono
– Il mix di istruzioni nel programma (coefficienti pi) sia tale da

far in modo che il peso delle istruzioni del punto precedente
sia superiore allo spreco di tempo dovuto all'aver uniformato
al clock la velocità dei differenti stadi.

Giacomo Bucci
Prestazioni
• Assunzioni:
– 30 ns accesso memoria
– 5 ns decodifica istruzioni e lettura registri
– 12 ns operazione ALU
– 5 ns scrittura registro
Ne deriva T= 30 ns
• Durata istruzioni:
– Aritm: 150 ns
– LD 150 ns
– ST 120 ns
– JE/JS : 90 ns
– JMP/JR: 90 ns
– JAL 150 ns

Giacomo Bucci
..Prestazioni
• Mix istruzioni (assunzione):
– istruzioni aritmetiche: 45%
– istruzioni LD: 25%
– istruzioni ST: 10%
– istruzioni JE/JS: 12%
– istruzioni JMP: 6%
– istruzioni JAL: 2%
• Tempo medio per istruzione:
0,45*150 + 0,25*150 + 0,10*120 + 0,12*90 + 0,06*90 + 0,02*150= 136,2 ns
Un tempo superiore del 66,10% al caso monociclo (82 ns). !!!
MI ID ALU MD WR T
Aritm 30 5 12 5 52
LD 30 5 12 30 5 82
ST 30 5 12 30 77
JE/JS 30 5 12 47
JMP 30 5 35
JAL 30 5 5 40

Giacomo Bucci
Miglioramenti
Criteri:
• Anticipare per quanto possibile le operazioni, in modo
da ridurre il numero medio di clock per istruzione;
• Scegliere un periodo di clock più breve, introducendo
eventualmente degli stati di attesa per le fasi più
lunghe, in modo da ottimizzare il tempo medio per
istruzione;
E’ l’accesso alla memoria che determina T. Dunque
conviene scomporre l’accesso a M in più cicli.
• Compattare fasi distinte e aggiustare
opportunamente il clock.

Giacomo Bucci
Aumento della granularità del clock

• Portare T a 12 ns (tempo di ALU)
=> un accesso alla memoria richiede 3 cicli
– aritmetiche: 12 * 3 + 12 + 12 + 12 + 12 = 84 ns;
– LD: 12 * 3 + 12 + 12 + 12 * 3 + 12= 108 ns.
– ST: 12 * 3 + 12 + 12 + 12 * 3= 96 ns;
– JE/JS: 12 * 3 + 12 + 12= 60 ns;
– JMP/JR: 12 * 3 + 12 + 12= 60 ns;
– JAL 12 * 3 + 12 + 12 + 12 + 12= 84 ns;
• Con il precedente mix si ha una durata media pari a
0,45*84 + 0,25*108 + 0,10*96 + 0,12*60 + 0,06*60 + 0,02*84= 86,88 ns
• Miglioramento = 100 * (136,20 - 86,88)/136,20 = 36,21%
100*(86,88 - 82)/82 =5,95 % più lenta di CPU1
Nota: Ci sono sprechi in tutte le fasi (eccetto ALU) in particolare
nell’accesso alla memoria (6 ns)
Giacomo Bucci
Ulteriore incremento della granularità
• Portare T a 5 ns
=> un accesso alla memoria richiede 6 cicli
– aritmetiche: 5*6 + 5*3 + 5*3 + 5 + 5= 70 ns;

– LD: 5*6 + 5*3 + 5*3 + 5 * 6 + 5= 95 ns;
– ST: 5*6 + 5*3 + 5*3 + 5 * 6= 90 ns;
– JE, JS: 5*6 + 5*3 + 5*3= 60 ns;
– JMP/JR: 5*6 + 5*3 + 5 = 50 ns.
– JAL 5*6 + 5*3 + 5 + 5 + 5= 60 ns;
0,45*70 + 0,25*95 + 0,10*90 + 0,12*60 + 0,06*50 + 0,02*60= 75,75 ns
• Miglioramento = 100 * (136,20-75,65)/136,20 = 44,46%
• Miglioramento rispetto a CPU1 = 100 * (82-75,65)/82 = 7,74%

Giacomo Bucci
Anticipazione e compattazione

Giacomo Bucci
Anticipazione e compattazione
• Mantenendo T = 30 ns
– aritmetiche: 30 + 30 = 60 ns;
– LD: 30 + 30 + 30 + 30 = 120 ns;
– ST: 30 + 30 + 30 = 90 ns;
– JE/JS: 30 + 30 + 30 = 90 ns;
– JMP/JR: 30 + 30 = 60 ns;
– JAL 30 + 30 = 60 ns;
0,45*60 + 0,25*120 + 0,10*90 + 0,12*90 + 0,06*60 + 0,02*60= 81,60 ns
• Miglioramento = 100 * (136,20-81,60)/136,20 = 40,09%
• Quasi la stessa velocità di CPU1

Giacomo Bucci
Anticipazione, compattazione e clock fine
• T = 5 ns
– aritmetiche: 5*6 + 5 + 5*3 + 5 = 55 ns;

– LD: 5*6 + 5 + 5*3 + 5 * 6 + 5= 85 ns;
– ST: 5*6 + 5 + 5*3 + 5 * 6= 80 ns;
– JE, JS: 5*6 + 5 + 5*3 + 5*3 = 65 ns;
– JMP/JR: 5*6 + 5 = 35 ns.
– JAL 5*6 + 5 + 5 + 5= 40 ns;
0,45*55 + 0,25*85 + 0,10*80 + 0,12*65 + 0,06*35 + 0,02*40= 64,76 ns
• Miglioramento = 100 * (136,20-64,76)/136,20 = 52,50%
• Miglioramento rispetto a CPU1 = 100 * (82-64,76)/82 = 21,10%

Giacomo Bucci
Giacomo Bucci

Giacomo Bucci
Interruzioni
• Esterne:
– usate per gestire le operazioni di I/O.
– asincrone rispetto all'esecuzione del programma
• Eccezioni:
– causate da situazioni anomale (overflow nelle operazioni
aritmetiche, tentativo di esecuzione di un codice operativo
non permesso, fallimento nell’accesso alla memoria virtuale
– sincrone rispetto all'esecuzione del programma ma non
predicibili
• Trappole:
– generate da apposite istruzioni (ad esempio, INT del
processore 8086). Sono una specie di istruzioni di salto con
l'effetto di portare la macchina in opportune modalità di
funzionamento
– sincrone e predicibili

Giacomo Bucci
Atomicità dell’interruzione
• IE: flip-flop di abilitazione del (sistema di) interruzione
– Architettura 8086: due istruzioni STI e CLI (asseriscono SIE
e RIE rispettivamente)
– Servizio interruzione equivale a RIE
– RFI equivale a SIE

Giacomo Bucci
Interruzioni su CPU2
• IPOTESI
– Linea INTR per le interruzioni esterne
– Eccezioni filtrate da IE (come le interruzioni esterne)
– Istruzioni INT per le interruzioni software
– La logica di CPU salva il solo PC in R30 (qualunque sia il
tipo di interruzione)
• la responsabilità di salvare gli eventuali registri che potrebbero
essere modificati dalla routine di servizio è lasciata al
programmatore.
– Le interruzioni sono vettorizzate:
• in CPU c’è la tabella TABIR (un blocco di registri di 32 bit)
identificati attraverso il numero di interruzione.

Giacomo Bucci
Interruzioni Software
• Istruzione INT
• Essa determina:
– R30 PC;
– PC TABIR[NInt];
– Asserzione RIE;
• Occorre prevedere
– Un percorso da TABIR a PC (ulteriore ingresso al Mux del
PC)
– La selezione di R30 come registro di destinazione
– (per le interruzioni esterne servirà anche un registro (SEL)
su cui appoggiare il selettore di interruzione)

Giacomo Bucci
Trattamento INT
Servirà più
avanti

Giacomo Bucci
Ramo INT
Deve essere
aggiunto il
ramo di
esecuzione di
INT
SWrite può essere anticipato a T2,

il resto può essere anticipato a T3

Giacomo Bucci
Interruzioni esterne
• Ipotesi:
– quando IINTR è asserita la logica, terminata l’istruzione
corrente, passa al servizio dell’interruzione;
– La logica di CPU asserisce INTA verso l’esterno, generando
un ciclo INTA sul bus; la logica esterna presenta il selettore
sul bus dei dati in modo che possa essere letto sullo stesso
ciclo INTA (INTA è una specie di Read);
– INTR resta asserita almeno fino al momento in cui viene
asserito INTA
• Occorre prevedere un ramo nel diagramma di stato,

ma la cosa non è tanto scontata!!
• Si può sfruttare l’istruzione INT

Giacomo Bucci
Possibile fenomeno di metastabilità

• Se ci si basasse solo su IINTR (che per natura è
asincrono)
• Occorre sincronizzare la richiesta di interruzione!!!

Giacomo Bucci
Sincronizzazione INTR
• IRQ è sincronizzato rispetto all’ultimo clock (di ogni
istruzione)

Giacomo Bucci
Interruzione esterna….

Giacomo Bucci
…Interruzione esterna
RIE
Dsorg=0
Rsorg=3
R_Write
X_VI

Giacomo Bucci
Attenzione!!!
• Nelle espressioni dei comandi e selettori attivi su T1
e T2 occorre tenere conto di IRQ
– In precedenza si aveva
DEST_Write = T2
– deve essere cambiata in
DEST_Write = T2 IRQ
– Si ha anche
INTA = T2 IRQ

Giacomo Bucci
Più realistico
• Abbiamo assunto che TABIR fosse in CPU

• TABIR deve stare in Memoria. Non c’è nessuna
difficoltà concettuale
• Istruzione INT:
– NInt viene presentato all’esterno come indirizzo di memoria,
viene asserito M_Read e quel che viene letto viene copiato
in PC.
• Interruzione esterna:
– su INTA il mondo esterno presenta sul bus dati il selettore
di interruzione esterna (equivale a NInt)
– segue il passo precedente dell’istruzione INT.

Giacomo Bucci
Eccezioni
• Il selettore viene prodotto dalla logica di CPU
– Es: page fault, divisione per zero
– Occorre aggiungere la logica relativa alla provenienza del
selettore
• Filtrate attraverso IE come le interruzioni esterne
• Occorre stabilire una priorità rispetto alle interruzioni
esterne
• Complicazioni. Esempio:
– Page Fault. L’istruzione non si conclude, genera eccezione.
Successivamente deve essere rieseguita.

Giacomo Bucci
ISTRUZIONE RFI
• RFI
• L’istruzione deve:
– effettuare PC R30
– asserire SIE

Giacomo Bucci
Discussione
• La nostra architettura
– salva in R30 (non ha stack)
– non prevede una parola di stato (è stato salvato solo PC!!!)
• TABIR non sta in CPU ma in memoria

– Il selettore deve essere usato per leggere in memoria (in
TABIR) il vettore di interruzione
• Interruzioni annidate
– Istruzione STI: set interrupt (asserisce SIE)
– Istruzione CLI: clear interrupt (disasserisce SIE)

Giacomo Bucci
Interruzioni annidate
• Nella nostra architettura (mancanza di stack) sono
difficili da attuare
RSERV … ;entrata
ST SAVR(R0),R30 ;salva R30 in mem.
STI ;riabilta interr.
…
LD R30,SAVR(R0) ;riprende R30
RFI
Può arrivare un’interruzione tra
queste istruzioni: si perde R30
Prima del LD ci vuole CLI

Giacomo Bucci
Incidentalmente
• Come si fa con la nostra macchina una procedura

ricorsiva?
• L’esempio classico è il fattoriale: fatt(x) = x * fatt(x-1)
– 0! = 1 per definizione
Chiamante Entrando in FATT

•se R1= 0 : R1 <- 1; JR 31
LD R1,x(R0)
JAL FATT •se R1>= 1 : chiamare FATT
passando R1-1
ST y(R0), R1
La chiamata si fa con JAL;

ma prima deve essere salvato R1

Giacomo Bucci
…Una procedura ricorsiva
• Ogni volta che viene chiamato FATT dall’interno di

FATT stessa occorre salvare il valore precedente di x
(R1)
• Per trattare la ricorsività è necessario lo stack
• Costruzione dello stack:

– Stabilire una convenzione per cui un registro (R29) viene
sacrificato a fare solo da SP.
– R29 viene inizializzato dal SO e successivamente modificato
solamente attraverso due operazioni PUSH Rx e POP Rx
• Ricorriamo al concetto di “macro” dell’assembler

Giacomo Bucci
Le due macro push e pop
• Per brevità assumiamo

– che il repertorio preveda l’operazione ADDI (ADD Immediate:
somma l’operando immediato al registro sorgente ) e
l’operazione JNE (salta se non zero)
– che R0 contenga sempre 0
macro PUSH &1 ;paramtro (Rx)

ADDI R29,R29,4
ST (R29),&1
endmacro
Cresce verso gli indirizzi
più alti
macro POP &1
LD &1,(R29)
ADDI R29,R29,-4
endmacro

Giacomo Bucci
Ha un difetto: in ingresso non
FATT controlla se x<0
FATT PUSH R31 ;salviamo il ritorno

JNE R1,R0,NonZ
ADDI R1,R0,1 ;R1<- 1
POP R31 ;riprendiamo il ritorno
JR R31 ;uscita
;
NonZ PUSH R1 ;salva x corrente
ADDI R1,R1,-1 ;R1<- x-1
JAL FATT ;Da FATT si esce
; ;con R1 = fatt(x-1)
POP R2 ;R2<- x
MUL R1,R1,R2 ;R1<- x*fatt(x-1)
POP R31 ; ripristino ritorno
JR R31

Giacomo Bucci
Registri riservati
• R31 dalla logica di CPU per JAL

• R30 dalla logica di CPU per salvataggio PC
nelle interruzioni
• R29 per convenzione software al fine della
costruzione dello stack
• Praticamente i tre registri sopra descritti non sono

utilizzabili da parte del programmatore.

Giacomo Bucci

07.la - CPU GL

Caricato da

Informazioni sul documento

Titolo originale

Copyright

Formati disponibili

Condividi questo documento

Condividi o incorpora il documento

Opzioni di condivisione

Hai trovato utile questo documento?

Questo contenuto è inappropriato?

Copyright:

Formati disponibili

07.la - CPU GL

Caricato da

Copyright:

Formati disponibili

Capitolo 7

Calcolatori elettronici – Architettura e organizzazione

Calcolatori elettronici – Architettura e organizzazione

Calcolatori elettronici – Architettura e organizzazione

Salto Incon. (F3)

Salto Condiz. (F2)

Calcolatori elettronici – Architettura e organizzazione

• Si fa l’ipotesi che dentro i campi che corrispondono a

Calcolatori elettronici – Architettura e organizzazione

Assumeremo che ci sia anche l’istruzione NOP

Calcolatori elettronici – Architettura e organizzazione

Calcolatori elettronici – Architettura e organizzazione

Istruzioni LD (Load) e ST (Store)

Calcolatori elettronici – Architettura e organizzazione

Calcolatori elettronici – Architettura e organizzazione

Istruzioni di salto e diramazione

JAL label ;R31:= PC; PC:= X(IND)

Calcolatori elettronici – Architettura e organizzazione

• INT INT 5 ;…… ; R30:= PC

• RFI RFI ; PC:= R30

Calcolatori elettronici – Architettura e organizzazione

Calcolatori elettronici – Architettura e organizzazione

– La memoria istruzioni (MI) rende sempre disponibile il suo

Calcolatori elettronici – Architettura e organizzazione

Cosa serve in CPU1

• L’esecuzione consiste nella propagazione dei segnali:

Calcolatori elettronici – Architettura e organizzazione

Calcolatori elettronici – Architettura e organizzazione

Calcolatori elettronici – Architettura e organizzazione

Calcolatori elettronici – Architettura e organizzazione

Calcolatori elettronici – Architettura e organizzazione

Calcolatori elettronici – Architettura e organizzazione

Calcolatori elettronici – Architettura e organizzazione

Calcolatori elettronici – Architettura e organizzazione

Calcolatori elettronici – Architettura e organizzazione

Calcolatori elettronici – Architettura e organizzazione

Durata del T del clock

Tmono = max tmono,I

Calcolatori elettronici – Architettura e organizzazione

Calcolatori elettronici – Architettura e organizzazione

CPU1 con memoria unificata….

Calcolatori elettronici – Architettura e organizzazione

Calcolatori elettronici – Architettura e organizzazione

Calcolatori elettronici – Architettura e organizzazione

• Azione svolta: DEST:= PC + OFFSET

Calcolatori elettronici – Architettura e organizzazione

Il campo OFFSET deve essere esteso a 32 bit

L’estensione non è mostrata

– Aritmetiche: ALUout:= A fALU B

Calcolatori elettronici – Architettura e organizzazione

Calcolatori elettronici – Architettura e organizzazione

Qui l’estensione è mostrata

Calcolatori elettronici – Architettura e organizzazione

Calcolatori elettronici – Architettura e organizzazione

La JAL deve salvare PC in R31:

Calcolatori elettronici – Architettura e organizzazione

Calcolatori elettronici – Architettura e organizzazione

Calcolatori elettronici – Architettura e organizzazione

Calcolatori elettronici – Architettura e organizzazione

La UC è un automa a stati finiti.

Calcolatori elettronici – Architettura e organizzazione

• T1 e T2 vengono spesi nel

• COMANDI (= segnali di controllo che hanno effetto solo quando asseriti)

– aritmetiche: 56 + 53 + 5*3 + 5 + 5= 70 ns;

– aritmetiche: 56 + 5 + 53 + 5 = 55 ns;