Progetto CPU (multiciclo) Salvatore Orlando

Transcript

1 Progetto CPU (multiciclo) Salvatore Orlando Arch. Elab. - S. Orlando 1

2 Problemi con progetto a singolo 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 Arch. Elab. - S. Orlando 2

3 Esempio di riduzione del ciclo di clock Effettua un taglio su grafo delle dipendenze corrispondente al circuito combinatorio, e inserisci un registro nel mezzo Fai lo stesso lavoro di prima in 2 cicli più veloci, invece che in singolo ciclo più lento elemento di memoria elemento di memoria Logica Combinatoria Aciclica Logica Combinatoria Aciclica (A) elemento di memoria elemento di memoria Logica Combinatoria Aciclica (B) elemento di memoria Arch. Elab. - S. Orlando 3

4 Datapath multiciclo Addr dati Registri addizionali PC Registri interni addizionali usati per memorizzare valori intermedi, da usare nel ciclo 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 Arch. Elab. - S. Orlando 4

5 Suddivisione in passi del Datapth Nell inserire i registri addizionali, abbiamo pensato di spezzare l esecuzione delle 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 per l esecuzione di una nuova istruzione Arch. Elab. - S. Orlando 5

6 Sequenza dei cinque passi di esecuzione Fetch dell istruzione Decodifica dell istruzione e Lettura dei regs. (e Addr. Branch) R-type exe o Calcolo Indirizzo Memoria o Completa Branch o Completa Jump dipende dal tipo di istruzione Accesso alla memoria o Completa R-type (scrittura regs) dipende dal tipo di istruzione Write back (scrittura reg: solo LW) OGNI PASSO ESEGUITO IN UN CICLO DI CLOCK LE ISTRUZIONI IMPIEGANO DA 3 A 5 CICLI Arch. Elab. - S. Orlando 6

7 Inseriamo i multiplexer PC oppure ALUout (addr, lw/sw) Ulteriore ingresso: PC MDR oppure ALUOut Altri 2 ingressi, da sommare con PC: PC = PC + 4 PC = PC + (sign_ext(imm16) << 2) Arch. Elab. - S. Orlando 7

8 Controllo I segnali di controllo alle varie unità funzionali e ai multiplexer non dipendono solo 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 (cicli di 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 Arch. Elab. - S. Orlando 8

9 Datapath e Controllo multi-ciclo Arch. Elab. - S. Orlando 9

10 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 PC viene scritto se è anche vero che PCWriteCond Nessuno Zero = 1 (beq) Per istruzioni di beq: PCWriteCond=1 e PCWrite=0 Il segnale di scrittura di PC è infatti calcolato come: PCWrite + (PCWriteCond Zero) Arch. Elab. - S. Orlando 10

11 Segnali di controllo di 2 bit Segnale Valore Effetto 00 ALU calcola somma (lw, sw, PC + ) ALUOp 01 ALU calcola sottrazione ( beq ) 10 ALU calcola l'operazione determinata da funct 00 2^ ingresso dell'alu è reg. B ALUSrcB 01 2^ ingresso dell'alu è costante ^ ingresso dell'alu è sign_ext(imm16) ( lw/sw ) 11 2^ ingresso dell'alu è sign_ext(imm16) << 2 ( beq ) 00 In PC viene scritto l'uscita dell'alu (PC+4 ) PCSource 01 In PC viene scritto ALUOut ( beq ) 10 In PC viene scritto PC[31-28] sign_ext(imm26) << 2 ( jump ) Arch. Elab. - S. Orlando 11

12 Passo 1: Fetch dell istruzione Usa PC per prelevare l istruzione dalla memoria e porla nell Instruction Register (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 Arch. Elab. - S. Orlando 12

13 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 Arch. Elab. - S. Orlando 13

14 Passo 2: Decodifica istruzione & Lettura registri 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 non necessario. 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 Arch. Elab. - S. Orlando 14

15 Passo 2: Decodifica istruzione & Lettura registri 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) Arch. Elab. - S. Orlando 15

16 Passo 3: (dipende dall istruzione) Usiamo l ALU in dipendenza del tipo di istruzione Il controllo, avendo già decodificato l istruzione letta al passo precedente, può già decidere i segnali da inviare al Datapath in relazione al tipo di istruzione R-type exe: ALUOut = A op B; Calcolo Indirizzo Memoria (load/store) ALUOut = A + sign-ext( IR[15-0] ); Completa Branch if (A == B) then PC = ALUOut; Completa Jump PC = PC[31-28] II (IR[25-0] << 2); Arch. Elab. - S. Orlando 16

17 Passo 3: (dipende dall istruzione) R-type exe: ALUOut = A op B; ALUSrcA 1 ALUSrcB 00 ALUOp 10 (campo FUNCT) ALUOut riscritto ad ogni ciclo LOAD / STORE: ALUOut = A + sign-ext( IR[15-0] ); ALUSrcA 1 ALUSrcB 10 ALUOp 00 (somma) Arch. Elab. - S. Orlando 17

18 Passo 3: (dipende dall istruzione) Completa Branch if (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 Arch. Elab. - S. Orlando 18

19 Passo 3: (dipende dall istruzione) Completa Jump PC = PC[31-28] II (IR[25-0] << 2); Per abilitare la scrittura nel PC, i segnali di controllo, non illustrati in figura, sono: PCWrite 1 PCSource 10 Arch. Elab. - S. Orlando 19

20 Passo 4: (dipende dall istruzione) 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 Arch. Elab. - S. Orlando 20

21 Passo 4: (dipende dall istruzione) Load: MDR = Memory[ALUOut]; IorD 1 MemRead 1 Store: Memory[ALUOut] = B; IorD 1 MemWrite 1 R-type: Reg[ IR[15-11] ] = ALUOut; RegDest 1 RegWrite 1 MemtoReg 0 Arch. Elab. - S. Orlando 21

22 Passo 5: Write-back (LOAD) Load: Reg[ IR[20-16]]= MDR; RegDest 0 RegWrite 1 MemtoReg 1 NOTA: Le altre istruzioni non giungono al passo 5 Arch. Elab. - S. Orlando 22

23 Riassumendo Step name Action for R -type instructions Action for memory-reference instructions Action for branches Action for jumps Instruction fetch IR = Memory[P C ] PC = PC + 4 Instruction decode / A = Reg [IR[25-21]] register fetch/ B = Reg [IR[20-16]] branch addr. comp. A LUOut = P C + (sign-extend (IR[15-0]) << 2) Execution, address ALUOut = A op B ALUOut = A + sign-extend if (A ==B) then PC = PC[31-28] II computation, branch/ (IR[15-0]) PC = ALUOut (IR[25-0]<<2) jum p co m ple tion Memory access or R-type Reg [IR[15-11]] = Load: M D R = Mem ory[a LUOut] completion ALUOut or Store: M emory [A LUOut] = B Memory read completion Load: Reg[IR[20-16]] = MDR Arch. Elab. - S. Orlando 23

24 Alcune semplici domande Quanti cicli sono necessari per eseguire questo codice? lw $t2, 0($t3) lw $t3, 4($t3) beq $t2, $t3, Label #assume not add $t5, $t2, $t3 sw $t5, 8($t3) Label: Cosa accade durante l 8 o ciclo di esecuzione? Calcolo dell indirizzo della 2 a lw In quale ciclo avviene effettivamente la somma tra $t2 e $t3? Nel 16-esimo ciclo Arch. Elab. - S. Orlando 24

25 Definizione controllo Possiamo implementare il controllo della CPU come un circuito sequenziale di Moore, 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) Inizio Fetch Decode, Read reg, Beq Addr. comp. R-type Exe Beq completam. Jump completam. M read R write M write R write Arch. Elab. - S. Orlando 25

26 Automa completo Etichette interni ai nodi corrispondono ai segnali che il Controllo deve inviare al Datapath Etichette sugli archi dipendono dagli input del Controllo ovvero, dal valore di del campo Op dell istruzione letta 10 stati ogni stato associato con un etichetta mnemonica, e anche con un identificatore numerico quanti bit sono necessari per il registro di stato? Arch. Elab. - S. Orlando 26

27 Componenti CPU (Datapath+Control) e Memoria CPU Operation = f(aluop, Funct) CONTROL PCWrite + (Zero PCWriteCond) PCSource RegDest ALUSrcA MemRead IorD IRWrite ALUSrcB RegWrite MemtoReg MemWrite MemRead Addr Instr/Data Memory PC (fetch) o ALUOut (sw,lw) IR (fetch) o MDR (lw) B (sw) DATA PATH Funct =IR[5:0] Op =IR[31:26] Zero Dataout Datain Nota: tra i segnali provenienti dal Datapath, solo Op è usato per selezionare il prossimo stato Arch. Elab. - S. Orlando 27

28 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 di sotto, 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... Next State Controllo Datapath Op controlli ALU 2 ns Zero PC write signal Esempio di diagramma temporale per il 3 o passo di esecuzione di un istruzione Arch. Elab. - S. Orlando 28

29 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 architettura a 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 le varie istruzioni il 5 o passo della lw, anche se usa solo il Register File (latenza 1 ns), viene comunque 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 nel passare all architettura multi-ciclo in quel caso, la scelta del ciclo singolo ci avrebbe costretto ad allungare a dismisura il ciclo di clock per eseguire l istruzione FP Arch. Elab. - S. Orlando 29

30 Circuito sequenziale che implementa il controllo Controllo a due livelli ALUOp calcolato sulla base di Op, combinato con Funct (IR[5:0]) per generare il segnale a 3 bit (Operation) da inviare all ALU PCWrite e PCWriteCond usati assieme a Zero proveniente dal Datapath, per generare il segnale a 1 bit che permette la scrittura di PC Nota blocco combinatorio per calcolare NEXT_STATE & OUTPUTS state register per memorizzare stato corrente Arch. Elab. - S. Orlando 30

31 Implem. cablata (a logica sparsa) del Controllo Blocco combinatorio all interno del circuito sequenziale che implementa il controllo della CPU può essere implementato con logica digitale a 2 livelli PLA Numero minimo di porte logiche, e quindi di transistor Implementazione ottima, ma non modificabile poca flessibilità Efficiente finché il numero di stati del circuito è abbastanza piccolo Arch. Elab. - S. Orlando 31

32 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 combinatorio necessario per implementare il controllo della CPU se l indirizzo è di m bit, possiamo indirizzare 2 m celle della ROM gli output della ROM corrispondono al contenuti delle varie celle indirizzare dai m bit dell indirizzo m ROM n Tabella di verità Tabella di verità con m variabili in input e n in output sufficiente una ROM di 2 m x n bit Arch. Elab. - S. Orlando 32

33 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 2 10 = 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 è = 20K bits (dimensione non usuale) Soluzione che spreca molte risorse, poiché molte celle della ROM (e i corrispondenti output della ROM) sono identiche o quasi identiche Poiché il circuito sequenziale è di Moore, i 16 bit dell Output (relativi ai segnali di 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) avviene indipendentemente dall Opcode per alcuni indirizzi <X, Stato > le celle sono identiche Arch. Elab. - S. Orlando 33

34 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 2 4 x16 b = 2 8 b = 0.25 Kb i 10 bits (Opcode, Stato) determinano i 4 bit del prossimo Stato ROM di 2 10 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 di prodotti 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 alla dimensione delle celle ROM (celle PLA un po più grandi) Arch. Elab. - S. Orlando 34

35 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 Control unit PLA or ROM Input Outputs PCWrite PCWriteCond IorD MemRead MemWrite IRWrite BWrite MemtoReg PCSource ALUOp ALUSrcB ALUSrcA RegWrite RegDst AddrCtl 1 State Adder Address select logic Op[5 0] Instruction registerı opcode field Arch. Elab. - S. Orlando 35

36 Sequenzializzatore in dettaglio Dispatch ROM 1 Dispatch ROM 2 Op Opcode name Value Op Opcode name Value R-format lw jmp sw beq lw sw 0010 Fetch (0) Stato++ State number Address-control action Value of AddrCtl 0 Use incremented state 3 1 Use dispatch ROM Use dispatch ROM Use incremented state 3 4 Replace state number by Replace state number by Use incremented state 3 7 Replace state number by Replace state number by Replace state number by 0 0 Arch. Elab. - S. Orlando 36

37 Microprogrammazione Rappresentazione tramite automi a stati finiti diventa improponibile quando dobbiamo 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 grafico a quello testuale: dagli automi ai microprogrammi) scopo di una microistruzione è quello di specificare (simbolicamente) i segnali di controllo da affermare nel Datapath ad un certo istante eseguire la microistruzione (Moore) avrà l effetto di affermare alcuni segnali di controllo per l esecuzione di una certa istruzione macchina ogni microistruzione dovrà specificare quale sarà la prossima microistruzione da eseguire, ovvero il prossimo stato del controllo la prossima microistruzione da eseguire potrà essere sempre univocamente determinata 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) Arch. Elab. - S. Orlando 37

38 Formato microistruzione Field name Value Signals active Comment Add ALUOp = 00 Cause the ALU to add. ALU control Subt ALUOp = 01 Cause the ALU to subtract; this implements the compare for branches. Func code ALUOp = 10 Use the instruction's function code to determine ALU control. SRC1 PC ALUSrcA = 0 Use the PC as the first ALU input. A ALUSrcA = 1 Register A is the first ALU input. B ALUSrcB = 00 Register B is the second ALU input. SRC2 4 ALUSrcB = 01 Use 4 as the second ALU input. Extend ALUSrcB = 10 Use output of the sign extension unit as the second ALU input. Extshft ALUSrcB = 11 Use the output of the shift-by-two unit as the second ALU input. Read Read two registers using the rs and rt fields of the IR as the register numbers and putting the data into registers A and B. Write ALU RegWrite, Write a register using the rd field of the IR as the register number and Register RegDst = 1, the contents of the ALUOut as the data. control MemtoReg = 0 Write MDR RegWrite, Write a register using the rt field of the IR as the register number and RegDst = 0, the contents of the MDR as the data. MemtoReg = 1 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 the lord = 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 contents PCWriteCond 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. Arch. Elab. - S. Orlando 38

39 Microprogramma relativo alla nostra CPU 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 Label ALU control SRC1 SRC2 Register control Memory PCWrite control Seq uencing Fetch Add PC 4 Read PC ALU Seq Add PC Extshft Read Dispatch 1 Mem1 Add A Extend Dispatch 2 LW 2 Read ALU Seq W rite MDR Fetch SW2 Write ALU Fetch R form at1 Func code A B Seq W rite ALU Fetch BEQ1 Subt A B ALUOut-cond Fetch JUMP1 Jump address Fetch Un implementazione diversa di questa stessa ISA avrebbe lo stesso microcodice? Cosa dovrebbe un microassembler? Arch. Elab. - S. Orlando 39

40 Implementazione del microprogramma Microprogramma Rappresentazione alternativa 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) e output del circuito sequenziale Storicamente, le implementazioni del controllo microprogrammato impiegano ROM per memorizzare microistruzioni incrementatore esplicito e logica di sequenzializzazione per determinare la prossima microistruzione Label della microistruzione Registro di controllo Contatore di microprogramma Arch. Elab. - S. Orlando 40

41 Microprogrammazione: 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 Arch. Elab. - S. Orlando 41

42 Eccezioni e interruzioni Il progetto del controllo del processore si complica a causa della necessità di considerare, durante l esecuzione delle istruzioni, il verificarsi di eventi inattesi, quali: interruzioni ed eccezioni Eccezione evento sincrono, generato all interno del processore, e provocato da problemi nell esecuzione di un istruzione es.: overflow, istruzione non valida Interruzione evento asincrono, che giunge dall esterno del processore segnale che giunge da un unità di I/O, utilizzato per comunicare alla CPU il verificarsi di certi eventi es.: la terminazione di un operazione di I/O la cui esecuzione era stata richiesta in precedenza dalla CPU Processore Control Datapath Interruzione I/O Memoria Arch. Elab. - S. Orlando 42

43 Gestione di eccezioni e interruzioni Il controllo di ogni processore deve essere predisposto per gestire il verificarsi di eventi inattesi Tutti i processori, quando si verifica un evento di eccezione/interruzione, la gestiscono 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 dai programmi (es.: invocazione routine di I/O) nel MIPS abbiamo l istruzione syscall esecuzione della syscall interpretata dal controllo come una particolare eccezione interna Arch. Elab. - S. Orlando 43

44 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 identificatore numerico del tipo di eccezione/interruzione verificatosi. L handler accederà al registro interno per determinare la causa dell eccezione/interruzione 2 interruzioni vettorizzate: esistono handler diversi per eccezioni/interruzioni differenti. Il controllo della CPU deve scegliere l handler corretto, saltando all indirizzo corretto. A questo scopo, viene predisposto un vettore di indirizzi, uno per ogni tipo di eccezioni/interruzioni, da indirizzare tramite il codice numerico dell eccezione/interruzione Nel MIPS viene adottata la 1 a soluzione, usando un registro, denominato Cause, per memorizzare il motivo dell eccezione/interruzione Il PC corrente viene invece salvato nel registro EPC Arch. Elab. - S. Orlando 44

45 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 valida 0 = istruzione non valida 1=overflow saltare ad una routine del SO (exception/interrupt handler) ad un indirizzo fisso: 0xC 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 sempre effettuato prima di saltare all interrupt handler salvataggio garantito dal microcodice approccio CISC Arch. Elab. - S. Orlando 45

46 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 transire nello 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 Datapath durante 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 0xC in PC Il prossimo stato sarà il Fetch (ma della prima istruzione dell handler) Arch. Elab. - S. Orlando 46

47 Nuovo controllo Invalid Instruction Overflow Arch. Elab. - S. Orlando 47

48 Nuovo Datapath Nuovo ingresso per PC (ind. Interrupt handler): 0xC EPC viene caricato con il risultato dell ALU, che calcola PC- 4 Cause viene caricato con 0, oppure con 1. Arch. Elab. - S. Orlando 48