• definizione di un'architettura semplificata ispirata alle macchine RISC

LA CPU

• Contenuto della lezione

– 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

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.

Formato

Aritmetiche

Salto Incon.

Salto Condiz.

Load/Store

(F3) (F2)

(F2)

(F1)

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

Notazione

• La notazione 000000||IND si indica anche come X(IND)

• La notazione (OFFSET ₁₆ ) ¹⁶ ||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

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 di destinazione Esempio

ADD R1,R2,R3 ;R1:= R2+R3

SUB R4,R4,R2 ;R4:= R4-R2

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

Istr. di trasferimento del controllo

JMP : Jump, Salto incondizionato JAL : Jump and link

JE : Jump if equal JS : Jump on sign JR : Jump relative INT : Interrupt

RFI : Return from interrupt

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.

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 ;if R21>R4 then

; PC:= PC+ XS(OFFSET)

Altri Trasferimenti

• JR JR R17 ; PC:= R17

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

• RFI ^RFI ; PC:= R30

Fasi/Stadi di esecuzione

• IF – Instruction Fetch

• ID – Instruction decode

• EX – Execute

• ME – Memory

• WB – Write Back

Le fasi corrispondo a stadi

CAPIRE BENE COSA FANNO I DIFFERENTI STADI !

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)

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

Propagazione Aritmetiche

Propagazione LD

Propagazione ST

Propagazione JMP

Propagazione JE

Register File

Interno RF

Schema ALU

Memoria

Durata del T del clock

T _mono periodo del clock (per CPU1)

t _i tempo richiesto dal generico stadio t _mono,I richiesto dalla generica istruzione I t _mono tempo per l’esecuzione di N istruzioni

t _mono,I ⁼  ^t _i

(la somma è estesa ai soli stadi interessati dall’istruzione I)

T _mono = max t _mono,I

t _mono = N T _mono

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 per operazione di ALU

• 5 ns per la scrittura di un registro

T

= 82 ns

Per l’istruzione JMP il 57% del tempo è sprecato

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

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 per operazione di ALU

• 5 ns per la scrittura di un registro

T

= 82 ns

Per l’istruzione JMP il 57% del tempo è sprecato

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

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

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

Con riferimento a LD

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

IF

• Azioni svolte in IF: IR:= M[PC]; PC:= PC+4

(Durante IF ALU non viene utilizzata => si usa per incrementare PC)

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)

ID

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

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

EX -- Aritmetiche

ALUOut = A fALU B

EX -- LD/ST

ALUOut = A + OFFSET

EX -- JE/JS

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 di appoggio PC1 (in cui salvare il

ME

• LD: Dmem:= M[ALUout]

• ST: M[ALUout]:= B

WB

Aritmetiche LD

Manca JAL

(deve scrivere in R31 il contenuto di PC1)

CPU2 complessivo

Diagramma di stato aggregato

Comandi e selettori

• COMANDI

– 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;

…. Comandi e selettori

• SELETTORI:

– Rdest: 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.

Digramma di stato dettagliato

Diagr stato dettagliato … fetch decode…..

Diagr. Dettagliato (execute)

UC

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

...Comandi

• In = T1 + T5.LD

• M_Write = T4.ST

• Out = (T3 + T4) ST

• IR_Write = T1

• OPALU si esplicita in tre comandi ADD, SUB, ALU

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

– fALU = (T3+T4+T5) ARITM

Selettori

• Su molti periodi i selettori 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)

Considerazioni

T _multi periodo del clock per CPU2. E’ determinato dallo stadio più lento

t _i tempo richiesto dal generico stadio T _multi = max t _i

T _mono 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)

T _{mono =} t _{mono,X =}  ^t _i

DUNQUE: t _multi,X = x * T _multi >= t _mono,X = T _mono

Nel multiciclo gli stadi più veloci si devono uniformare al

Confronto monociclo multiciclo

t _multi,I = CPI _I ^* T _multi Durata istruzione I-ma

N numero di istruzioni eseguite da un programma

p _I frazione di istruzioni di tipo I nel programma

t _multi tempo di esecuzione del programma

t _multi = N  ^p _{I *} ^t _multi,I ^{) = N}  ^p _{I *} ^CPI _I ^{* T} _multi ⁾

t _mono = N * T _mono

Confronto monociclo multiciclo

t _mono /t _multi = T _mono /  ^p _{I *} ^CPI _I ^{* T} _multi ⁾

• 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

CPI

^* T

<= T

– 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.

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

..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). !!!

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.

Aumento della granularità del clock

• Portare T a 12 (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

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;

• Con il precedente mix si ha una durata media pari a

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%

Anticipazione e compattazione

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 = 60 ns;

– JMP/JR: 30 + 30 = 60 ns;

– JAL 30 + 30 = 60 ns;

• Con il precedente mix si ha una durata media pari a

0,45*60 + 0,25*120 + 0,10*90 + 0,12*60 + 0,06*60 + 0,02*60= ????81,60 ns

• Miglioramento = 100 * (136,20-???60)/136,20 = 40,09%

• Quasi la stessa velocità di CPU1

Anticipazione, compattazione e clock fine

• T = 5 ns

– aritmetiche: 5*6 + 5*3 + 5 = 5 ns;

– LD: 5*6 + 5*3 + 5 * 6 + 5= 80 ns;

– ST: 5*6 + 5*3 + 5 * 6= 75 ns;

– JE, JS: 5*6 + 5 *3 + 5*3 = 60 ns;

– JMP/JR: 5*6 + 5 = 35 ns.

– JAL 5*6 + 5 = 35 ns;

• Con il precedente mix si ha una durata media pari a

0,45*50 + 0,25*80 + 0,10*75 + 0,12*60 + 0,06*35 + 0,02*35= 60,00 ns

• Miglioramento = 100 * (136,20-60,00)/136,20 = 55,95%

• Miglioramento rispetto a CPU1 = 100 * (82-60)/82 = 26,83%

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

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

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.

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)

Trattamento INT

Ramo INT

Deve essere aggiunto il ramo di

esecuzione di

INT

TABIR in Memoria

Ramo INT (TABIR in Memoria)

Ramo INT

Ipotesi ci si fa in 1 clock

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

Possibile fenomeno di metastabilità

• Se ci si basasse solo su IINTR (che per natura è asincrono)

• Occorre sincronizzare la richiesta di interruzione!!!

Sincronizzazione INTR

• IRQ è sincronizzato rispetto all’ultimo clock (di ogni

istruzione)

Interruzione esterna….

Per l’ingesso a SEL

Per l’ingesso

a IR

resettare Per

IS

Resettare IS (su T2)

Su T2 AND IRQ

Resettare IS (su T2)

Se capitasse che IINTR viene asserito entro T2, il fronte

Su T2 AND IRQ

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

TABIR in Memoria

Interruzione esterna:

– su INTA (T2) il mondo esterno presenta sul bus dati il selettore di interruzione esterna (equivale a NInt)

– NInt viene presentato all’esterno come indirizzo di memoria, viene asserito M_Read e quel che

viene letto viene copiato in PC.

– Se TABIR non parte da 0 ci vuole un registro di

CPU per rilocarla (tenere l’indirizzo di base).

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 .

ISTRUZIONE RFI

• RFI

• L’istruzione deve:

– effettuare PC R30

– asserire SIE

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 (asserisce RIE)

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

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

LD R1,x(R0) JAL FATT

ST y(R0), R1

Entrando in FATT

•se R1= 0 : R1 <- 1; JR 31

•se R1>= 1 : chiamare FATT

passando R1-1

La chiamata si fa con JAL;

…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

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 ;parametro (Rx) ADDI R29,R29,4

ST (R29),&1 endmacro

macro POP &1

LD &1,(R29) ADDI R29,R29,-4

Cresce verso gli indirizzi

più alti

FATT Ha un difetto: in ingresso non 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

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.