Progetto CPU (multiciclo)

Arch. Elab. - S. Orlando 1

Progetto CPU(multiciclo)

Salvatore Orlando


Problemi con pro getto a sin golo ciclo

• Problemi del singolo ciclo– Ciclo di clock lungo– Istruzioni potenzialmente più veloci sono rallentate

• impiegano lo stesso tempo dell’istruzione più lenta

– Unità funzionali e collegamenti del Datapath sono replicati• dobbiamo poter computare in parallelo tutti i passi computazionali necessari

per l’esecuzione di qualsiasi istruzione dell’ISA

• Possibile soluzione:– datapath “multiciclo”– usiamo un ciclo più corto– istruzioni differenti impiegano un numero di cicli diversi– unità funzionali possono essere usate più volte per eseguire la stessa

istruzione ⇒ meno replicazione• basta usarle in cicli differenti

– registri aggiuntivi• usati per memorizzare i risultati parziali nell’esecuzione delle istruzioni


Esempio di riduzione del ciclo di clock

• Effettua un taglio su grafo delle dipendenze corrispondente al circuitocombinatorio, e inserisci un registro nel mezzo

• Fai lo stesso lavoro di prima in 2 cicli più veloci, invece che in singolo ciclopiù lento

elemento di memoria

Logica CombinatoriaAciclica

elemento di memoria

elemento di memoria

Logica CombinatoriaAciclica (A)

elemento di memoria

elemento di memoria

Logica CombinatoriaAciclica (B)


Datapath multiciclo

• Registri interni addizionali usati per memorizzare valori intermedi, da usare nelciclo di clock successivo per continuare l’esecuzione della stessa istruzione– IR, MDR, A, B, ALUOut

• Riuso di unità funzionali– ALU usata anche per calcolare gli indirizzo dei salti e incrementare il PC– Memoria usata sia per leggere le istruzioni e per leggere/scrivere i dati

Registri addizionali

Addr dati

PC


Suddivisione in passi del Datapth

• Nell’inserire i registri addizionali, abbiamo pensato di spezzare l’esecuzionedelle istruzioni in passi– ogni passo da eseguire in un ciclo di clock (ciclo più corto rispetto alla

CPU a ciclo singolo )– importante il bilanciamento della quantità di lavoro eseguito nei vari passi,

perché dobbiamo fissare un ciclo di clock unico• determinato sulla base del passo più lungo, ovvero più costoso dal punto di

vista computazionale

• Al termine di ogni ciclo i valori intermedi, da impiegare nei cicli successivi,sono memorizzati nei registri interni addizionali

• Register File e PC sono invece impiegati per memorizzare valori da usare perl’esecuzione di una nuova istruzione


Sequenza dei cinque passi di esecuzione

• Fetch dell’istruzione

• Decodifica dell’istruzione e Lettura dei re gs. (e Addr. Branch)

• R-type exe o Calcolo Indirizzo Memoria oCompleta Branch o Completa Jump

– dipende dal tipo di istruzione

• Accesso alla memoria o Completa R-t ype (scrittura re gs)

– dipende dal tipo di istruzione

• Write back (scrittura re g: solo LW)

OGNI PASSO ESEGUITO IN UN CICLO DI CLOCKLE ISTRUZIONI IMPIEGANO DA 3 A 5 CICLI


Inseriamo i multiplexer

Altri 2 ingressi, da sommare con PC:PC = PC + 4

PC = PC + (sign_ext(imm16) << 2)

Ulteriore ingresso:PC

MDR oppure ALUOut

PC oppure ALUout (addr, lw/sw)


Controllo

• I segnali di controllo alle varie unità funzionali e ai multiplexer non dipendonosolo dal tipo istruzione da eseguire– es.: rispetto ad una sub , l’ALU dovrà essere usata, in cicli di clock

differenti, per• PC = PC + 4; (somma)• R[rd] <– R[rs] – R[rt]; (sottrazione)

• Quindi i segnali di controllo dovranno essere diversi durante i vari passi (ciclidi clock) necessari per l’esecuzione dell’istruzione

• Il controllo sarà infatti implementato come circuito sequenziale– l’output del circuito (segnali di controllo) dipenderanno dallo stato interno

al circuito al tempo t i

– stato del circuito sequenziale = passo di esecuzione di una istruzione


Datapath e Controllo multi-ciclo


Segnali di controllo di 1 bit

Segnale Effetto se uguale a 0 Effetto se uguale a 1

RegDest Reg. dest. proviene da rt Reg. dest. proviene da rd

Reg Write Nessuno Scrittura in Reg. File

AluSrcA 1^ ingresso dell'ALU è PC 1^ ingresso dell'ALU è reg. A

MemRead Nessuno Lettura da Mem. in reg. MDR

MemWrite Nessuno Scrittura in Mem.

MemtoReg Reg. scritto proviene da ALUOut Reg. scritto proviene da MDR

IorD Addr.della Mem. proviene da PC Addr.della Mem. proviene da ALUOut

IRWrite Nessuno Scrittura in IR (proviene da Mem. )PCWrite Nessuno Scrittura in PC

PCWriteCond NessunoPC viene scritto se è anche vero che Zero = 1 (beq)

Per istruzioni di beq : PCWriteCond=1 e PCWrite=0Il segnale di scrittura di PC è infatti calcolato come:

PCWrite + (PCWriteCond ⋅ Zero)


Segnali di controllo di 2 bit

S e g na le V alore E ffetto

00 A LU c alc ola s om m a ( lw , sw , PC + … )

ALUO p 01 A LU c alc ola s ottraz ione ( beq )

10 A LU c alc ola l'operaz ione determ inata da funct

00 2^ ingres s o dell'A LU è reg . B

ALUS rcB 01 2^ ingres s o dell'A LU è costante 4

10 2^ ingres s o dell'A LU è si g n_ext(im m 16) ( lw /sw )

11 2^ ingres s o dell'A LU è si g n_ext(im m 16) << 2 ( beq )

00 In P C viene s c rit to l'us c ita dell'A LU ( PC+4 )

P CS ource 01 In P C viene s c rit to A LUOut ( beq )

10 In P C viene s c rit to PC[31-28] || si g n_ext(im m 26) << 2 ( jum p )


Passo 1: Fetch dell’istruzione

• Usa PC per prelevare l’istruzione dalla memoria e porla nell’InstructionRegister (IR)

• Incrementa PC di 4, e rimetti il risultato nel PC• Passo identico per tutte le istruzioni

• Usando la notazione RTL:IR = M[PC];PC = PC + 4;

• Durante questo passo (stesso ciclo di clock) usiamo:– Memoria– ALU

• Vediamo in dettaglio i valori dei segnali di controllo


Passo 1: Fetch dell’istruzione

• IR = M[PC];– MemRead ← 1– IRWrite ← 1– IorD ← 0

• PC = PC + 4;– ALUSrcA ← 0 ALUSrcB ← 01– ALUOp ← 00 (somma)– PCWrite ← 1 PCSource ← 00


Passo 2: Decodifica istruzione & Lettura re gistri

• Leggi i registri rs e rt , e calcola l’indirizzo del salto del beq• IR (op) viene inviato al controllo per la decodifica e la determinazione dei

passi successivi ⇒ Decodifica dell’istruzione• RTL:

A = Reg[ IR[25-21] ];B = Reg[ IR[20-16] ];ALUOut = PC + (sign-ext( IR[15-0] ) << 2);

• Passo identico per tutte le istruzioni , ma potremmo anticipare del lavoro nonnecessario.– per certe istruzioni, i due campi ( rs , rt ) potrebbero essere non significativi– calcoliamo l’indirizzo a cui saltare, come se l’istruzione fosse beq, ma il

campo imm16 potrebbe essere non significativo• Quali i vantaggi di questo lavoro anticipato?

• Durante questo passo (stesso ciclo di clock) usiamo:– Register File– ALU

• Vediamo i valori dei segnali di controllo


Passo 2: Decodifica istruzione & Lettura re gistri

• A = Reg[ IR[25-21] ];B = Reg[ IR[20-16] ]; – A e B sovrascritti per

ogni tipo di istruzioni

• ALUOut = PC + (sign-ext( IR[15-0] ) << 2)– ALUSrcA ← 0 ALUSrcB ← 11– ALUOp ← 00 (somma)


Passo 3: (dipende dall’istruzione)

• Usiamo l’ALU in dipendenza del tipo di istruzione

• Il controllo , avendo già decodificato l’istruzione letta al passoprecedente, può già decidere i se gnali da inviare al Datapath inrelazione al tipo di istruzione

• R-type exe:ALUOut = A op B;

• Calcolo Indirizzo Memoria (load/store)ALUOut = A + sign-ext( IR[15-0] );

• Completa Branchif (A == B) then PC = ALUOut;

• Completa JumpPC = PC[31-28] II (IR[25-0] << 2);



R-type exe: ALUOut = A op B;

ALUSrcA ← 1ALUSrcB ← 00ALUOp ← 10 (campo FUNCT)ALUOut riscritto ad ogni ciclo

LOAD / STORE:ALUOut = A + sign-ext( IR[15-0] );

ALUSrcA ← 1 ALUSrcB ← 10ALUOp ← 00 (somma)



Completa Branchif (A == B) then PC = ALUOut;

ALUSrcA ← 1 ALUSrcB ← 00 ALUOp ← 01 (sottr.) (sottrazione registri A e B, check salto sulla base di Zero)

Per abilitare la scrittura nel PC del valore precedentemente calcolato (ALUOut), necessari altri segnali di controllo non illustrati:

PCWrite ← 0 PCWriteCond ← 1 PCSource ← 01



Completa JumpPC = PC[31-28] II (IR[25-0] << 2);

Per abilitare la scrittura nel PC, i segnali dicontrollo, non illustrati in figura, sono:

PCWrite ← 1 PCSource ← 10



• LOAD e STORE accedono alla memoria

MDR = Memory[ALUOut];or

Memory[ALUOut] = B;

• Terminazione istruzioni R-type

Reg[ IR[15-11] ] = ALUOut;

• Durante questo passo usiamo:– Register File (Write) oppure Memoria

• Vediamo i segnali di controllo



Load: MDR = Memory[ALUOut];

IorD ← 1MemRead ← 1

Store: Memory[ALUOut] = B;

IorD ← 1MemWrite ← 1

R-type: Reg[ IR[15-11] ] = ALUOut;

RegDest ← 1RegWrite ← 1MemtoReg ← 0


Passo 5: Write-back (LOAD)

Load: Reg[ IR[20-16]]= MDR;

RegDest ← 0RegWrite ← 1MemtoReg ←1

NOTA: Le altre istruzioninon giun gono al passo 5


Riassumendo

Ste p nameAction for R -t yp e

instructionsAction for memor y -reference

instructionsAction for branches

Action for jum p s

Ins truction fe tch IR = M em ory[P C ]P C = P C + 4

Instruction decode / A = Reg [IR[25-21 ]]reg iste r fe tch/ B = Reg [IR[20-16 ]]

b ranch addr. com p. A LUOut = P C + (s ign-extend (IR[15 -0 ]) << 2)

E xecution, address A LUOut = A op B A LUOut = A + s ign-extend if (A ==B ) then P C = P C [31 -28 ] IIcom puta tion, b ranch/ (IR[15-0 ]) P C = A LUOut (IR[25-0 ]<<2 )jum p com ple tion

M em ory access or R-type Reg [IR [15-11 ]] = Load: M D R = M em ory[A LUOut]com ple tion A LUOut or

S to re : M em ory [A LUOut] = B

M em ory read com ple tion Load: Reg[IR[20-16 ]] = M D R


Alcune semplici domande

• Quanti cicli sono necessari per eseguire questo codice?

lw $t2, 0($t3)lw $t3, 4($t3)beq $t2, $t3, Label #assume notadd $t5, $t2, $t3sw $t5, 8($t3)

Label: ...

• Cosa accade durante l’8 o ciclo di esecuzione?

• In quale ciclo avviene effettivamente la somma tra $t2 e $t3 ?

55344 21

• Calcolo dell’indirizzo della 2 a lw

• Nel 16-esimo ciclo


Definizione controllo

• Possiamo implementare il controllo della CPU come un circuito sequenziale diMoore , modellabile come un automa a stati finiti

• Automa– ogni nodo corrisponde a un stato differente del circuito, in corrispondenza

di un certo ciclo di clock– gli output del controllo (segnali di controllo) dipendono dallo stato

corrente– da 3 a 5 stati devono essere attraversati (ovvero, da 3 a 5 cicli di clock)

Fetch

Inizio

Decode, Read reg, Beq

Addr. comp.

M read

R write

M write

R-type Exe

R write

Beq completam. Jump completam.


Automa completo

• Etichette interni ai nodi– corrispondono ai

segnali che il Controllodeve inviare al Datapath

• Etichette sugli archi– dipendono dagli input

del Controllo– ovvero, dal valore di del

campo Opdell’istruzione letta

• 10 stati– ogni stato associato

con un’etichettamnemonica, e anchecon un identificatorenumerico

– quanti bit sononecessari per il registrodi stato ?


Componenti CPU (Datapath+Control) e Memoria

• Nota: tra i segnali provenienti dal Datapath, solo Op è usato per selezionare ilprossimo stato

RegWrite

PCSource

ALUSrcB MemtoReg

ALUSrcA

ZeroDATA PATH

CONTROL

RegDest

MemRead

Instr/DataMemory

Addr

CPU

IR (fetch) o MDR (lw)

MemRead

MemWrite

IorD

PCWrite + (Zero · PCWriteCond)

Funct =IR[5:0]

Operation = f(AluOp, Funct)

Op =IR[31:26]

B (sw)

DatainDataout

PC (fetch) o ALUOut (sw,lw)

IRWrite


Dimensionamento ciclo di clock

• Ipotizziamo gli stessi costi precedenti (in ns) per le varie componenti– Mem. Istr/Dati: 2 ns Reg. File: 1 ns ALU: 2 ns– non li usiamo mai in sequenza ⇒ possiamo ipotizzare un ciclo di 2 ns

• Più in dettaglio, per determinare il ciclo ci clock, consideriamo il diagramma disotto, che si riferisce al 3 o passo della BEQ

– poiché il controllo è di Moore, l’output (controlli) dipende solo dallo stato (veloce)• decodifica del controllo dell’ALU più complessa (2 livelli):

Operation = f(AluOp, Funct)– l’input del controllo, importante per la transizione di stato, è Op

• Op è un campo del registro IR del Datapath (non necessario calcolarlo)

– il segnale di Zero è importante nel caso di BEQ ...

Controllo

Datapath ALU

2 ns

Next State

Op

cont

rolli

Zer

o

PC

writ

e

sign

al

Esempio di dia grammatemporale per il 3 o passodi esecuzione di un’istruzione


Costo istruzioni

• Per le varie istruzioni, possiamo impiegare un numero differente di cicli– introduciamo il concetto di CPI (no. di cicli per istruzione)

• Quant’è il CPI delle varie istruzioni rispetto all’architettura multi-ciclo ?– R-type, sw: 4 cicli (tempo: 8 ns)– lw: 5 cicli (tempo: 10 ns)– beq, jump: 3 cicli (tempo: 6ns)

• Nota che l’istruzione di lw impiega ben 10 ns invece degli 8 ns dell’architetturaa singolo ciclo– purtroppo ciò è dovuto alla necessità di fissare il ciclo di clock abbastanza

lungo da permettere l’esecuzione di uno qualsiasi dei passi previsti per levarie istruzioni

– il 5o passo della lw, anche se usa solo il Register File (latenza 1 ns), vienecomunque eseguito in un ciclo di clock da 2 ns

• Abbiamo ottenuto un risparmio solo per le istruzioni di beq e jump– se avessimo considerato istruzioni molto più lunghe (come quelle FP), non

avremmo osservato questa apparente decadimento di prestazione nelpassare all’architettura multi-ciclo

– in quel caso, la scelta del ciclo singolo ci avrebbe costretto ad allungare adismisura il ciclo di clock per eseguire l’istruzione FP


Circuito sequenziale che implementa il controllo

• Nota– blocco combinatorio per calcolare NEXT_STATE & OUTPUTS– state register per memorizzare stato corrente

• Controllo a due livelli– ALUOp calcolato sulla base

di Op, combinato con Funct(IR[5:0]) per generare ilsegnale a 3 bit ( Operation ) dainviare all’ALU

• PCWrite e PCWriteCond usatiassieme a Zero proveniente dalDatapath, per generare il segnalea 1 bit che permette la scrittura diPC


Implem. cablata (a lo gica sparsa) del Controllo

• Blocco combinatorio all’internodel circuito sequenziale cheimplementa il controllo della CPUpuò essere implementato conlogica digitale a 2 livelli– PLA

• Numero minimo di porte logiche,e quindi di transistor

• Implementazione ottima, ma nonmodificabile– poca flessibilità

• Efficiente finché il numero di statidel circuito è abbastanza piccolo


Circuiti combinatori e ROM

• ROM = "Read Only Memory"– i valori delle varie celle di memoria sono fissate in anticipo

• ROM usata per memorizzare una tabella di verità = il circuito combinatorionecessario per implementare il controllo della CPU– se l’indirizzo è di m bit, possiamo indirizzare 2m celle della ROM– gli output della ROM corrispondono al contenuti delle varie celle

indirizzare dai m bit dell’indirizzo

• Tabella di verità con m variabili in input e n in output– sufficiente una ROM di 2m x n bit

m n

0 0 0 0 0 1 10 0 1 1 1 0 00 1 0 1 1 0 00 1 1 1 0 0 01 0 0 0 0 0 01 0 1 0 0 0 11 1 0 0 1 1 01 1 1 0 1 1 1

ROM

Tabella di verità


Implementazione del controllo tramite ROM

• Quanti sono gli input del blocco combinatorio interno al controllo ?– 6 bit per Opcode , 4 bit per lo Stato– < Opcode , Stato >= 10 linee di indirizzo– 210 = 1024 indirizzi differenti

• Quanti sono gli output ?– 16 bit per i vari segnali di controllo del Datapath– 4 bit per lo Stato– 20 bit in output

• ROM è 210 × 20 = 20K bits (dimensione non usuale)

• Soluzione che spreca molte risorse, poiché molte celle della ROM (e icorrispondenti output della ROM) sono identiche o quasi identiche

• Poiché il circuito sequenziale è di Moore , i 16 bit dell’Output (relativi ai segnalidi controllo) dipendono solo dallo Stato– per gli indirizzi < X, Stato > le celle della ROM sono quasi identiche

• Da certi Stati , la transizione (i 4 bit di Output del Next State) avvieneindipendentemente dall’ Opcode– per alcuni indirizzi < X, Stato > le celle sono identiche


ROM vs. PLA

• Spezziamo la tabella di verità in due parti (OUTPUTS e NEXT_STATE)

– i 4 bit di Stato determinano i 16 Outputs ⇒ ROM di 24x16 b = 28 b = 0.25 Kb

– i 10 bits ( Opcode , Stato ) determinano i 4 bit del prossimo Stato ⇒ ROM di210 x 4 b = 4 Kb

– Totale: ROM di 4.25 Kb (invece di 20 Kb)

• La PLA risulta sempre più piccola

– molti prodotti sono condivisi

– i DON’T CARE sono tutti considerati attentamente per ridurre il numero diprodotti o il numero di fattori in ogni prodotto

• Il numero di celle PLA (porte AND e OR) sono:

– (#inputs × #product-terms) + (#outputs × #product-terms)

– nel nostro caso: (10x17)+(20x17) = 460 celle PLA

• Dimensione (in spazio e numero di transistor) delle celle PLA è simile alladimensione delle celle ROM (celle PLA un po’ più grandi)


Un altro stile di implementazione

• Spesso NEXT_STATE corrisponde a current state + 1– vedi, rispetto al nostro automa, le transizioni di stato 0→1, 3→4 o 6→7

AddrCtl

Outputs

PLA or ROM

State

Address select logic

Op[

5–0]

Adder

Instruction registerıopcode field

1

Control unit

Input

PCWritePCWriteCondIorD

MemtoRegPCSourceALUOpALUSrcBALUSrcARegWriteRegDst

IRWrite

MemReadMemWrite

BWrite


Sequenzializzatore in detta glio

State number Address-control action Value of AddrCtl0 Use incremented state 31 Use dispatch ROM 1 12 Use dispatch ROM 2 23 Use incremented state 34 Replace state number by 0 05 Replace state number by 0 06 Use incremented state 37 Replace state number by 0 08 Replace state number by 0 09 Replace state number by 0 0

Dispatch ROM 1 Dispatch ROM 2Op Opcode name Value Op Opcode name Value

000000 R-format 0110 100011 lw 0011000010 jmp 1001 101011 sw 0101000100 beq 1000100011 lw 0010101011 sw 0010 Fetch (0)

Stato++


Micropro grammazione

• Rappresentazione tramite automi a stati finiti diventa improponibile quandodobbiamo trattare un numero elevato di stati– un foglio non basta più se si considerano tutte le istruzioni MIPS (> 100) e

il numero di cicli necessari per i le istruzioni più complesse (oltre 20 cicli)• Microprogrammazione

– idea prese in prestito dal campo della programmazione (dallo stile graficoa quello testuale: dagli automi ai microprogrammi)

– scopo di una microistruzione è quello di specificare (simbolicamente) isegnali di controllo da affermare nel Datapath ad un certo istante

– eseguire la microistruzione (Moore) avrà l’effetto di affermare alcunisegnali di controllo per l’esecuzione di una certa istruzione macchina

– ogni microistruzione dovrà specificare quale sarà la prossimamicroistruzione da eseguire, ovvero il prossimo stato del controllo

• la prossima microistruzione da eseguire potrà essere sempre univocamentedeterminata

– es. sempre la successiva secondo l’ordine lessicografico del micoprogramma,oppure una determinata altra microistruzione

• la scelta della prossima microistruzione potrà dipendere dagli input ( Op code )


Formato microistruzione

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

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 = 0

Write MDR RegWrite, Write a register using the rt field of the IR as the register number andRegDst = 0, the contents of the MDR as the data.MemtoReg = 1

Read 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 = 1

Write ALU MemWrite, Write memory using the ALUOut as address, contents of B as thelorD = 1 data.

ALU PCSource = 00 Write the output of the ALU into the PC.PCWrite

PC write control ALUOut-cond PCSource = 01, If the Zero output of the ALU is active, write the PC with the contentsPCWriteCond of the register ALUOut.

jump address PCSource = 10, Write the PC with the jump address from the instruction.PCWrite

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


Micropro gramma relativo alla nostra CPU

• Un’implementazione diversa di questa stessa ISA avrebbe lo stesso microcodice?

• Cosa dovrebbe un microassembler ?

Labe lALU

con tro l SRC 1 SRC 2Reg is te r con tro l M em or y

PC Write con tro l Se q uenc in g

F e tc h A d d P C 4 R e ad P C A L U S e qA d d P C E xts hf t R e ad D is p atc h 1

Me m 1 A d d A E xte nd D is p atc h 2L W 2 R e ad A L U S e q

W rite MD R F e tc hS W 2 W rite A L U F e tc hR fo rm at1 F unc c o d e A B S e q

W rite A L U F e tc hB E Q 1 S ub t A B A L UO ut-c o nd F e tc hJ UMP 1 J um p ad d re s s F e tc h

• Microprogramma completo della nostra semplice unità di controllo– nota che per la corretta sequenzializzazione delle istruzioni, in 2 casi

rimanda ad una specifica tabella di smistamento


Implementazione del micropro gramma

• Microprogramma ≡ Rappresentazionealternativa all’automa a stati finiti– rappresenta il comportamento di

un circuito sequenziale• Per l’implementazione, possibili tutte

le alternative viste per gli automi– PLA o ROM– circuiti distinti per calcolare

sequenzializzazione (NEXT_STATE) eoutput del circuito sequenziale

• Storicamente, le implementazioni delcontrollo microprogrammatoimpiegano

– ROM per memorizzare microistruzioni– incrementatore esplicito e logica di

sequenzializzazione per determinare laprossima microistruzione

– Label della microistruzione ≡Registro di controllo ≡Contatore di microprogramma


Micropro grammazione: pro e contro

• Specifica del controllo tramite microprogramma

– Pro

• semplice da progettare e scrivere

• possiamo progettare l’architettura e il codice assieme

• Implementazione del controllo tramite ROM off-chip (macchine anni ‘60-’70)

– Pro

• Firmware (=Microcodice memorizzato nella ROM) facile da modificare

– basta sostituire la ROM

• stesso Datapath può emulare altre ISA

– Contro

• Eccessiva lentezza, considerando che oggi

– controllo implementato sullo stesso chip del processore (microprocessori)

– la ROM non è più (come un tempo) più veloce della RAM

• fetch di una microistruzione per inviare i controlli al Datapath sarebbe

costoso come effettuare il fetch di una istruzione macchina

– non c’e’ più necessità di riprogettare ISA, correggere errori, o apportare cambi al

microcodice


Eccezioni e interruzioni

• Il progetto del controllo del processore si complica a causa della necessità diconsiderare, durante l’esecuzione delle istruzioni, il verificarsi di eventiinattesi , quali:– interruzioni ed eccezioni

• Eccezione

– evento sincrono , generato all’ interno del processore, e provocato daproblemi nell’esecuzione di un’istruzione

• es.: overflow, istruzione non valida

Control

Datapath

Processore

Memoria

I/OInterruzione

• Interruzione– evento asincrono , che giunge

dall’ esterno del processore– segnale che giunge da un’unità di

I/O, utilizzato per comunicare allaCPU il verificarsi di certi eventi

• es.: la terminazione diun’operazione di I/O la cuiesecuzione era stata richiesta inprecedenza dalla CPU


Gestione di eccezioni e interruzioni

• Il controllo di ogni processore deve essere predisposto per gestire il verificarsidi eventi inattesi

• Tutti i processori, quando si verifica un evento di eccezione/interruzione , lagestiscono secondo lo schema seguente:– interruzione dell’esecuzione del programma corrente– salvataggio di parte dello stato di esecuzione corrente (almeno PC)– salto ad una routine del codice che costituisce il Sistema Operativo (SO)

• il SO è stato caricato in memoria al momento del boot del sistema• il salvataggio dello stato del programma interrotto serve al SO per poter

riprenderne eventualmente l’esecuzione, successivamente e se necessario

• Nota che le routine del SO possono essere invocate esplicitamente daiprogrammi (es.: invocazione routine di I/O)– nel MIPS abbiamo l’istruzione syscall

– esecuzione della syscall interpretata dal controllo come una particolareeccezione interna


Gestione di eccezioni e interruzioni

• Problema:– l’handler del SO deve essere in grado di capire quale evento si è verificato

• Soluzioni alternative:1 il controllo della CPU, prima di saltare all’ handler predisposto dal SO (ad

un indirizzo fisso), deve salvare in un registro interno un identificatorenumerico del tipo di eccezione/interruzione verificatosi.L’handler accederà al registro interno per determinare la causadell’eccezione/interruzione

2 interruzioni vettorizzate : esistono handler diversi pereccezioni/interruzioni differenti. Il controllo della CPU deve sceglierel’handler corretto, saltando all’indirizzo corretto.A questo scopo, viene predisposto un vettore di indirizzi, uno per ogni tipodi eccezioni/interruzioni, da indirizzare tramite il codice numericodell’eccezione/interruzione

• Nel MIPS viene adottata la 1 a soluzione, usando un registro, denominatoCause, per memorizzare il motivo dell’eccezione/interruzione

• Il PC corrente viene invece salvato nel registro EPC


Gestione eccezioni nel MIPS

• Il Controllo (ma anche il Datapath corrispondente) deve essere progettato per– individuare l’evento inatteso– interrompere l’istruzione corrente– salvare il PC corrente (nel registro interno EPC = Exception PC)– salvare la causa dell’interruzione nel registro Cause

• consideremo solo le eccezioni di overflow e istruzione non valida0 = istruzione non valida 1=overflow

– saltare ad una routine del SO ( exception/interrupt handler ) ad un indirizzofisso: 0xC0000000

• Il MIPS non salva nessun altro registro oltre PC– è compito dell’handler salvare altre porzioni dello stato corrente del

programma (es. tutti i registri generali), se necessario• approccio RISC

– esistono CPU dove questo salvataggio esteso dello stato viene sempreeffettuato prima di saltare all’interrupt handler

• salvataggio garantito dal microcodice• approccio CISC


Rilevamento eccezione

• Overflow– segnale che arriva al controllo dall’ALU

• Istruzione non valida– controllo lo deve rilevare sulla base del campo op dell’istruzione

• Dobbiamo aggiungere 2 nuovi stati al nostro automa– a partire dallo stato Instruction Decode , dobbiamo poter transire nel nuovo

stato Invalid Instruction• solo se giunge un Op non valido

– a partire dallo stato R-type Completion , dobbiamo poter anche transirenello stato Overflow

• solo se giunge un segnale di overflow dal Datapath (ALU)• questa transizione si potrebbe anticipare allo stato Execution

– Problema : next state da calcolare in base ad un segnale calcolato dal Datapathdurante lo stesso ciclo di clock

• I nuovi stati che gestiscono le eccezioni dovranno occuparsi– di salvare in EPC il PC corrente (ovvero PC - 4)– di salvare 0/1 in Cause– di memorizzare 0xC0000000 in PC

• Il prossimo stato sarà il Fetch (ma della prima istruzione dell’ handler )


Nuovo controllo

InvalidInstruction

Overflow


Nuovo Datapath

• Nuovo ingresso per PC (ind. Interrupt handler): 0xC0000000• EPC viene caricato con il risultato dell’ALU, che calcola PC- 4• Cause viene caricato con 0, oppure con 1.

Progetto CPU (multiciclo)

Documents

Transcript of Progetto CPU (multiciclo)