Architetture dei Calcolatori (Lettere j-z) Il Processore (2) Ing. Davide D’Amico Give qualifications of instructors: DAP teaching computer architecture at Berkeley since 1977 Co-athor of textbook used in class Best known for being one of pioneers of RISC currently author of article on future of microprocessors in SciAm Sept 1995 RY took 152 as student, TAed 152,instructor in 152 undergrad and grad work at Berkeley joined NextGen to design fact 80x86 microprocessors one of architects of UltraSPARC fastest SPARC mper shipping this Fall

Approccio Multiciclo Suddividere l’esecuzione di una istruzione in piu’ passi (steps) Fetch, Decode, Execute, Memory Access, Write Back Ogni passo richiede un ciclo di clock Istruzioni diverse possono richiedere un numero diverso di passi (cicli) I passi scelti in modo da bilanciare il carico di lavoro In modo da minimizzare la durata del ciclo di clock Assunzione: in un passo/ciclo di clock si puo’ effettuare una sola operazione tra: Accesso in memoria Accesso al banco dei registri (lettura o scrittura) Operazione ALU CPU (2)

Approccio Multiciclo Alla fine di ogni ciclo Bisogna memorizzare i valori richiesti dai cicli successivi dell’istuzione corrente Richiede l’impiego di registri addizionali interni (invisibili al programmatore): IR: Instruction Register MDR: Memory Data Register A & B: Valori letti dai registri ALUout: Registro che memorizza il risultato delle operazioni ALU CPU (2)

Approccio Multiciclo Vantaggi Unita’ funzionali che devono essere usata piu’ volte per la stessa istruzione non devono essere replicate se impiegate in passi diversi Una sola memoria per dati e istruzioni Una sola ALU (no adder) Tempo di ciclo piu’ breve Tempi di esecuzione inferiori Istruzioni usano il solo tempo (cicli) necessario alla loro esecuzione CPU (2)

Unità di elaborazione a ciclo multiplo: una vista astratta Contiene l’istruzione Dati dal primo registro Risultato della ALU Dati dalla memoria Dati dal secondo registro CPU (2)

Una vista più dettagliata Poiché le unità funzionali sono condivise, occorre aggiungere dei multiplexer ed ampliare quelli già esistenti nel ciclo singolo Unica Memoria per dati e istruzioni Si aggiunge un multiplexer per selezionare il PC o ALUOut come indirizzo della memoria da leggere/scrivere Dovendo condividere la ALU Si aggiunge un multiplexer per il primo ingresso della ALU per selezionare il registro A (primo registro) oppure il PC (per il calcolo dell’indirizzo dell’istruzione successiva) Il multiplexer a 2 vie sul secondo ingresso della ALU viene ampliato a 4 vie Una per il valore 4 (per il calcolo dell’indirizzo dell’istruzione successiva) Una per il valore dell’indirizzo (16 bit, estesi in segno a 32 e traslati a sinistra) CPU (2)

Una vista più dettagliata (2) Mux su primo ingresso ALU Indirizzo da PC o da ALU Mux su secondo ingresso ALU CPU (2)

I segnali di controllo Nell’unità a ciclo multiplo occorre cambiare anche l’insieme dei segnali di controllo Gli elementi di memoria visibili al programmatore (il PC, la memoria ed i registri) e l’IR hanno bisogno di un segnale di controllo per la scrittura La memoria ha anche bisogno di un segnale di controllo per la lettura Ciascuno dei due multiplexer a due vie aggiunti ha bisogno di un segnale di controllo a 1 bit Il multiplexer a quattro vie ha bisogno di un segnale di controllo a 2 bit CPU (2)

L’unità con i segnali di controllo CPU (2)

Implementazione dei salti Per le istruzioni di jump e branch, ci sono tre possibili sorgenti per il valore da scrivere in PC L’output della ALU, con il valore PC+4 calcolato durante la fase di fetch dell’istruzione Il registro ALUOut, dove è memorizzato l’indirizzo del branch una volta che è stato calcolato I 26 bit meno significativi dell’IR traslati a sinistra di 2 e concatenati con i 4 bit più significativi del PC incrementato, se l’istruzione è di jump CPU (2)

Implementazione dei salti: jump Prelievo dei 26 bit per jump Scelta del valore da scrivere in PC: 0: PC+4 1: indirizzo del salto condizionato 2: indirizzo di jump CPU (2)

Implementazione dei salti: beq In OR con PCWrite per indicare la scrittura di PC Zero (dalla ALU) AND PCWriteCond Scelta del valore in PC CPU (2)

Il controllo della ALU ALUOp come input 3 bit di controllo alla ALU come output Unità di controllo della ALU 6 bit di funct come input CPU (2)

L’unità di elaborazione multi-ciclo CPU (2)

I segnali di controllo ad 1 bit Segnale Effetto quando vale 0 Effetto quando vale 1 RegDst Registro destinazione = rt Registro destinazione = rd RegWrite Nessuno Nel registro indicato sull’ingresso Write register viene scritto il valore Write data ALUSrcA Il primo operando di ALU è PC Il primo operando di ALU è registro A MemRead Lettura della locazione di memoria indicata da Address MemWrite Scrittura della locazione di memoria indicata da Address MemtoReg Il valore in Write data (registri) viene da ALUOut Il valore in Write data (registri) viene da MDR IorD L’indirizzo proviene da PC L’indirizzo proviene da ALUOut IRWrite Uscita memoria scritta in IR PCWrite Scrittura in PC: provenienza da PCSource PCWriteCond Scrittura in PC se Zero di ALU è 1 CPU (2)

I segnali di controllo a 2 bit Segnale Val Effetto ALUOp 00 L’ALU calcola la somma 01 L’ALU calcola la sottrazione 10 Operazione determinata dal campo funct ALUScrB Il secondo ingresso della ALU: proviene da reg. B …: è la costante 4 …: il valore dei 16 bit meno sign. di IR, estesi a 32 11 …: il valore dei 16 bit meno sign. di IR, estesi a 32, traslati a sinistra di 2 bit PCSource In PC viene scritta l’uscita della ALU (PC+4) In PC viene scritto ALUOut (indirizzo di beq) In PC viene scritto l’indirizzo di jump (26 bit meno sign. di IR, traslati a sinistra di 2 bit e concatenati con i 4 bit più sign. di PC) CPU (2)

Esecuzione di una istruzione in più cicli Obiettivo: Decomporre le istruzioni in modo da bilanciare il carico di lavoro in ogni ciclo (e minimizzare la durata del ciclo di clock) Suddividiamo le istruzioni in una serie di passi Ogni passo coincide con un ciclo di clock Ogni passo comprende al più: Un’operazione con la ALU Un accesso al banco dei registri Un accesso alla memoria In questo modo, la durata del ciclo di clock sarà pari alla durata della più lenta di queste tre operazioni CPU (2)

Alla fine di ciascun ciclo di clock Tutti i valori che sono necessari al passo successivo/Istruzione Sono memorizzati in qualche componente Ad esempio Il Program Counter Il banco dei registi La memoria Uno dei registri addizionali A, B, MDR oppure ALUOut IR (dotato di segnale di controllo per la scrittura) IR è l’unico tra i registri addizionali a contenere lo stesso dato (l’istruzione) per tutti i passi di esecuzione di una istruzione CPU (2)

Suddivisione in Passi Si suddividono le istruzioni nei seguenti passi potenziali – non tutte le istruzioni le richiedono tutte Prelievo Istruzione e Incremento del PC (IF) Si preleva l’istruzione in base a PC e si salva in IR. PC e’ incrementato di 4 Decodifica Istruzione e Prelievo Registri (ID) Si leggono i registri rs e rt in caso servano Si calcola l’indirizzo di salto (nel caso l’istruzione sia di salto). Esecuzione, Calcolo Indirizzo di Memoria, o completamento salto (EX) ALU esegue una delle seguenti funzioni in base al tipo di istruzione memory reference R-type branch (Istruzione Completata) jump (Istruzione Completata) CPU (2)

Suddivisione in Passi Accesso in Memoria e Completamento Istruzione R (MEM) In base al tipo di istruzione Legge dalla memoria Scrive in memoria (Istruzione Completata) Scrittura nel Registro Destinazione (Istruzione Completata) Completamento lettura da Memoria (WB) Il dato letto dalla memoria in 4 viene scritto nel registro Destinazione (Load completato) Le istruzioni MIPS richiedono da 3 a 5 cicli di clock Jump e branch: 3 cicli Formato R, store: 4 cicli Write: 5 cicli CPU (2)

Prelievo dell’Istruzione (IF) IR = M[PC]; PC = PC + 4; 4 PC + 4 CPU (2)

Decodifica Istruzione e Lettura Registri (ID) A = Reg[IR[25-21]]; (A = Reg[rs]) B = Reg[IR[20-15]]; (B = Reg[rt]) ALUOut = (PC + sign-extend(IR[15-0]) << 2) PC + 4 Branch Target Address Reg[rs] Reg[rt] CPU (2)

Formato R: (EX) – Esecuzione ALU ALUOut = A op B Reg[rs] Reg[rt] PC + 4 R-Type Result CPU (2)

Formato R: (MEM) – Scrittura Registro Dest. Reg[IR[15:11]] = ALUOUT R-Type Result Reg[rs] Reg[rt] PC + 4 CPU (2)

Decodifica Istruzione e Lettura Registri (ID) A = Reg[IR[25-21]]; (A = Reg[rs]) B = Reg[IR[20-15]]; (B = Reg[rt]) ALUOut = (PC + sign-extend(IR[15-0]) << 2) PC + 4 Branch Target Address Reg[rs] Reg[rt] CPU (2)

Branch: (EX) – Aggiornamento PC if (A == B) PC = ALUOut; Reg[rs] Reg[rt] Branch Target Address Branch Target Address CPU (2)

Decodifica Istruzione e Lettura Registri (ID) A = Reg[IR[25-21]]; (A = Reg[rs]) B = Reg[IR[20-15]]; (B = Reg[rt]) ALUOut = (PC + sign-extend(IR[15-0]) << 2) PC + 4 Branch Target Address Reg[rs] Reg[rt] CPU (2)

Jump: (EX) – Aggiornamento PC PC = PC[31-28] concat (IR[25-0] << 2) Reg[rs] Reg[rt] Branch Target Address Jump Address CPU (2)

Decodifica Istruzione e Lettura Registri (ID) A = Reg[IR[25-21]]; (A = Reg[rs]) B = Reg[IR[20-15]]; (B = Reg[rt]) ALUOut = (PC + sign-extend(IR[15-0]) << 2) PC + 4 Branch Target Address Reg[rs] Reg[rt] CPU (2)

Store: (EX) Calcolo Indirizzo ALUOut = A + sign-extend(IR[15-0]); Reg[rs] Reg[rt] PC + 4 Mem. Address CPU (2)

Store: (MEM) Scrittura in Memoria M[ALUOut] = B; PC + 4 Reg[rs] Reg[rt] CPU (2)

Decodifica Istruzione e Lettura Registri (ID) A = Reg[IR[25-21]]; (A = Reg[rs]) B = Reg[IR[20-15]]; (B = Reg[rt]) ALUOut = (PC + sign-extend(IR[15-0]) << 2) PC + 4 Branch Target Address Reg[rs] Reg[rt] CPU (2)

Load: (EX) Calcolo Indirizzo ALUOut = A + sign-extend(IR[15-0]); Reg[rs] Reg[rt] PC + 4 Mem. Address CPU (2)

Load: (MEM) Lettura in Memoria MDR = M[ALUOut]; PC + 4 Reg[rs] Reg[rt] Mem. Address Mem. Data CPU (2)

Load: (WB) – Scrittura nel Registro Dest. Reg[IR[20-16]] = MDR; PC + 4 Reg[rs] Reg[rt] Mem. Data Address CPU (2)

Schema Riassuntivo Implementazione Multiciclo Step Step name Action for R-type instructions Action for memory-reference Action for branches jumps Instruction fetch IR = M[PC] PC = PC + 4 Instruction A = Reg [IR[25-21]] decode/register fetch B = Reg [IR[20-16]] ALUOut = PC + (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) jump completion Memory access or R-type Reg [IR[15-11]] = Load: MDR = M[ALUOut] completion ALUOut or Store: M[ALUOut] = B Memory read completion Load: Reg[IR[20-16]] = MDR 1: IF 2: ID 3: EX 4: MEM 5: WB CPU (2)

Controllo L’Unita di Controllo deve generare: In funzione del… I segnali di controllo dell’ALU I segnali di controllo dei vari multiplexer I segnali di abilitazione alla scrittura/lettura dei diversi elementi di memoria In funzione del… Tipo di Istruzione da eseguire (Ingresso) I bit del campo opcode (e funct nel caso del formato R) dell’istruzione Step dell’istruzione  Una rete combinatoria non e’ sufficiente ad implementare il controllo multiciclo Opcode Read/Write Memorie 6 Controllo Controllo MUX Funct 6 Controllo ALU CPU (2)

Controllo Multiplo Ciclo: Rete Sequenziale Il controllo sara’ realizzato da una rete sequenziale Automa a Stati finiti Micropragramma Per semplificare la progettazione/circuito del controllo suddivideremo l’unita’ di controllo in Unita’ di Controllo Principale Unita’ di Controllo ALU Per il controllo dell’ALU useremo la stessa rete combinatoria vista per l’implementazione singolo ciclo Opcode Read/Write Memorie 6 Controllo Controllo MUX Funct 6 Controllo ALU Opcode Read/Write Memorie 6 Controllo Controllo MUX ALUOp 2 ALU Control Controllo ALU Funct 6 CPU (2)

Implementazione Unita’ di Controllo Principale Possiamo implementare l’Unita’ di Controllo come una rete sequenziale di Moore Stato: passo di esecuzione dell’istruzione corrente IF, ID, Ex-Formato R, Ex-beq, etc… Ingressi: Opcode Istruzione Uscite: Segnali di Controllo verso DataPath Bisogna Specificare Funzione Prossimo Stato: Stato(n+1)=F(Stato(n),Ingressi(n)) Funzione Uscita: Uscite(n)=G(Stato(n)) Perche’ e’ un automa di Moore Opcode Rete Combinatoria 6 Read/Write Memorie Stato Controllo MUX ALUOp 2 CPU (2)

Struttura dell’Automa a Stati Finiti I primi due passi sono indipendenti dall’istruzione I restanti passi sono differenziati a seconda dell’operazione Ciascuna porzione della macchina a stati finiti può essere composta da più stati Inizio Fetch Decode, Fetch Reg, beq Calcolo Indirizzo R-type EXE Beq EXE (PC update) Jump EXE (PC update) M-Read M-Write R-Write R-Write CPU (2)

Segnali di Controllo: (IF) IR = M[PC]; MemRead=1 IRWrite=1 IorD=0 PC = PC + 4; ALUSrcA=0, ALUSrcB=01 ALUOp=00 PCWrite=1, PCSource=00 1 1 X 010 X 1 1 CPU (2)

Segnali di Controllo: (ID) A = Reg[IR[25-21]]; (A = Reg[rs]) B = Reg[IR[20-15]]; (B = Reg[rt]) - A e B sempre sovrascritti (nessun segnale di controllo) ALUOut = (PC + sign-extend(IR[15-0]) << 2); ALUSrcA=0, ALUSrcB=11 ALUOp=00 X X 010 X X 3 CPU (2)

Segnali di Controllo: (EX) Formato R - ALU ALUOut = A op B; ALUSrcA=1, ALUSrcB=00 ALUOp=10 (Operation dipende da Funct) ALUOut riscritto ad ogni ciclo) X 1 X ??? X X CPU (2)

Segnali di Controllo: (MEM) Formato R – Scrittura Registro Destinazione Reg[IR[15:11]] = ALUOut; (Reg[Rd] = ALUOut) RegDest=1 ReWrite=1 MemtoReg=0 IRWrite I Instruction I jmpaddr 28 32 R I[25:0] <<2 CONCAT 5 PCWr* rs rt rd X 1 2 M U X MUX 1 X 32 RegDst IorD 5 5 1 XXX 5 ALUSrcA PC Operation M U X 1 MemWrite RN1 RN2 WN M U X 1 3 ADDR M M U X 1 Registers PCSource Memory D RD1 A Zero X RD R WD ALU ALU OUT WD RD2 B M U X 1 2 3 MemRead MemtoReg 4 RegWrite 1 E X T N D ALUSrcB immediate 16 32 <<2 X CPU (2)

Segnali di Controllo: (ID) A = Reg[IR[25-21]]; (A = Reg[rs]) B = Reg[IR[20-15]]; (B = Reg[rt]) - A e B sempre sovrascritti (nessun segnale di controllo) ALUOut = (PC + sign-extend(IR[15-0]) << 2); ALUSrcA=0, ALUSrcB=11 ALUOp=00 X X 010 X X 3 CPU (2)

Segnali di Controllo: (EX) Branch – Agg. PC if (A == B) PC = ALUOut; ALUSrcA=1, ALUSrcB=00 ALUOp=01 PCWrite=0, PCWriteCond=1, PCSource=01 1 if Zero=1 X 1 X 110 1 X CPU (2)

Segnali di Controllo: (ID) A = Reg[IR[25-21]]; (A = Reg[rs]) B = Reg[IR[20-15]]; (B = Reg[rt]) - A e B sempre sovrascritti (nessun segnale di controllo) ALUOut = (PC + sign-extend(IR[15-0]) << 2); ALUSrcA=0, ALUSrcB=11 ALUOp=00 X X 010 X X 3 CPU (2)

Segnali di Controllo: (EX) Jump – Agg. PC PC = PC[21-28] concat (IR[25-0] << 2); - PCWrite=1, PCSource=10 1 X X X XXX 2 X X CPU (2)

Segnali di Controllo: (ID) A = Reg[IR[25-21]]; (A = Reg[rs]) B = Reg[IR[20-15]]; (B = Reg[rt]) - A e B sempre sovrascritti (nessun segnale di controllo) ALUOut = (PC + sign-extend(IR[15-0]) << 2); ALUSrcA=0, ALUSrcB=11 ALUOp=00 X X 010 X X 3 CPU (2)

Segnali di Controllo: (EX) Store – Calc. Indirizzo ALUOut = A + sign-extend(IR[15-0]); ALUSrcA=1, ALUSrcB=10 ALUOp=00 X 1 X 010 X X 2 CPU (2)

Segnali di Controllo: (MEM) Store – Scr. in Memoria Memory[ALUOut] = B; IorD=1 MemWrite=1 1 X 1 X XXX X X X CPU (2)

Segnali di Controllo: (ID) A = Reg[IR[25-21]]; (A = Reg[rs]) B = Reg[IR[20-15]]; (B = Reg[rt]) - A e B sempre sovrascritti (nessun segnale di controllo) ALUOut = (PC + sign-extend(IR[15-0]) << 2); ALUSrcA=0, ALUSrcB=11 ALUOp=00 X X 010 X X 3 CPU (2)

Segnali di Controllo: (EX) Load – Calc. Indirizzo ALUOut = A + sign-extend(IR[15-0]); ALUSrcA=1, ALUSrcB=10 ALUOp=00 X 1 X 010 X X 2 CPU (2)

Segnali di Controllo: (MEM) Load – Lett. in Memoria MDR = Memory[ALUOut]; IorD=1 MemRead=1 1 X X XXX X X 1 X CPU (2)

Segnali di Controllo: (WB) Load – Scr. Registro di Destinazione Reg[IR[20-16]] = MDR; RegDest=0 RegWrite=1 MemtoReg=0 IRWrite I Instruction I jmpaddr 28 32 R 5 I[25:0] <<2 CONCAT PCWr* X rs rt rd X 1 2 M U X MUX 1 32 RegDst XXX IorD 5 5 5 ALUSrcA PC Operation M U X 1 MemWrite RN1 RN2 WN M U X 1 3 ADDR M M U X 1 Registers PCSource Zero X Memory D RD1 A RD R WD ALU ALU WD RD2 B M U X 1 2 3 OUT MemRead MemtoReg 4 RegWrite 1 E X T N D ALUSrcB immediate 16 32 X <<2 CPU (2)

Struttura dell’Automa a Stati Finiti I primi due passi sono indipendenti dall’istruzione I restanti passi sono differenziati a seconda dell’operazione Ciascuna porzione della macchina a stati finiti può essere composta da più stati Inizio Fetch Decode, Fetch Reg, beq Calcolo Indirizzo R-type EXE Beq EXE (PC update) Jump EXE (PC update) M-Read M-Write R-Write R-Write CPU (2)

L’Automa a stati finiti completo Tutti i segnali di scrittura che non appaiono sono pari a 0 Tutti i segnali di controllo dei mux che non appaiono sono pari ad X CPU (2)

Unita’ di Controllo: Funzione di Uscita Outputs Input Values (Current State[3-0]) 0000 0001 0010 0011 0100 0101 0110 0111 1000 1001 PCWrite 1 PCWriteCond X IorD MemRead MemWrite IRWrite MemtoReg PCSource 00 XX 01 10 ALUOp ALUSrcB 11 ALUSrcA RegWrite RegDst Doesn’t show the use of don’t cares to reduce the logic! CPU (2)

Unita’ di Controllo: Funzione Prossimo Stato Current State [3-0] Inst[31-26] (Op[5-0]) 000000 (R-type) 000010 (jmp) 000100 (beq) 100011 (lw) 101011 (sw) Any other 0000 0001 0110 1001 1000 0010 illegal XXXX 0011 0101 0100 0111 CPU (2)

Diagramma a blocchi della CPU (Datapath e Control) e Memoria CONTROLLO Registro di Stato Operation=f(ALUOp,funct) PCWrite+(Zero*PCWriteCond) IorD IRWrite PCSoruce RegDst ALUSrcA/B MemtoReg MemWr MemRd RegWr Opcode ALU Zero A Funct ALUOut Register file IR B DATAPATH Addr PC MDR Memoria CPU (2)

Implementazione dell’unità di controllo dall’Automa a Stati Finiti La macchina a stati finiti può essere implementata usando Un registro temporaneo che memorizza lo stato corrente Un blocco di logica combinatoria che determina i segnali e lo stato futuro Realizzabile tramite PLA o ROM CPU (2)

Implementazione Controllo Tramite PLA Blocco combinatorio della rete sequenziale puo’ essere implementato con logica digitale a 2 livelli PLA Numero minimo di porte logiche # celle= #ingresso*#termini prodotto+#uscite*termini prodotto 10*17+20*17=510 celle PLA Non modificabile Poco flessibile Soluzione efficiente per piccoli circuiti CPU (2)

Reti Combinatorie e ROM ROM (Read Only Memory) I valori delle varie celle di memoria sono fissati Le ROM possono essere usate per implementare Tabelle di Verita’=Reti Combinatorie Se l’indirizzo e’ di m-bit, possiamo indirizzzare 2m celle della ROM Le uscite della ROM corrispondono ai contenuti della varie celle indirizzate dai m bit dell’indirizzo Tabella di Verita’ con m variabili in ingresso e n di output Sufficiente una ROM di 2mxn bit Input = indirizzo Output = Contenuto celle m n ROM 0 0 0 0 0 1 1 0 0 1 1 1 0 0 0 1 0 1 1 0 0 0 1 1 1 0 0 0 1 0 0 0 0 0 0 1 0 1 0 0 0 1 1 1 0 0 1 1 0 1 1 1 0 1 1 1 m = 3 n = 4 CPU (2)

Implementazione del Controllo tramite ROM Rete combinatoria dell’unita’ di controllo ha: 10 linee in ingresso 6 bit opcode 4 bit stato Indirizzo=<Opcode,Stato> 20 linee di output 16 bit di segnali di controllo 4 bit di stato Realizzazione ROM richiede 210x20=20Kbits Soluzione inefficiente 16 bit di uscita (segnali di controllo) dipendono solo dai 4 bit dello stato Automa di Moore  indirizzi <XXX,Stato>, al variare di XXX i 16 bit relativi alle linee di controllo sono identici Per molti stati le transizioni non dipendono dall’opcode  Per molti indirizzi <XXX,Stato>, al variare di XXX i contenuti delle celle spesso sono identici Stato __Uscita (Linee di Controllo) 0000 1001010000001000 0001 0000000000011000 0010 0000000000101000 0011 0011000000000000 0100 0000001000000010 0101 0010100000000000 0110 0000000001000100 0111 0000000000000011 1000 0100000010100100 1001 1000000100000000 CPU (2)

Implementazione del Controllo tramite ROM Implementare separatamente le tabelle di verita’ delle funzioni F (uscita) e G (prossimo stato) F: 4 bit di stato determinano le 16 uscite (di controllo) ROM di 24x16b=0.25Kb G: 10 bit (4 stato+6 opcode) determinano il prossimo stato ROM di 210x4b=4Kb Totale 4.25Kbit >> numero celle PLA PLA ottimizza la rete grazie ai molti DON’T CARE Data la struttura degli automi di Moore, la dimensione della ROM e’ dominata dalla funzione G 4Kb vs 0.25Kb Stato __Uscita (Linee di Controllo) 0000 1001010000001000 0001 0000000000011000 0010 0000000000101000 0011 0011000000000000 0100 0000001000000010 0101 0010100000000000 0110 0000000001000100 0111 0000000000000011 1000 0100000010100100 1001 1000000100000000 Si puo’ semplificare l’implementazione sfruttando la struttura di G? CPU (2)

Altro Stile di Implementazione Implementare F come prima Per G osservare che: Spesso la funzione stato successivo e’: Stato(n+1)=Stato(n)+1 0->1 IF->ID 3->4 lw(MEM)->lw(WB) 6->7 f. R(EX)->f. R(MEM) o semplicemente a fine istruzione: Stato(n+1)=0 Tuttavia alcune volte Stato(n+1)=G(Stato(n),Opcode) Stato 1 e 2 CPU (2)

Implementazione con un Sequenzializzatore Inserire: Contatore Incremento Stato Logica selezione prossimo stato Per i “salti” Aggiungere un segnale di controllo AddrCtrl che controlla come si determina il prossimo stato: Stato(n)+1 In base a Stato(n)+Opcode CPU (2)

Sequenzializzatore in dettaglio Rom CPU (2)

Sequenzializzatore: Contenuto della Memoria di Controllo Stato Uscita Linee di Controllo AddrCtl 0000 1001010000001000 11 0001 0000000000011000 01 0010 0000000000101000 10 0011 0011000000000000 11 0100 0000001000000010 00 0101 0010100000000000 00 0110 0000000001000100 11 0111 0000000000000011 00 1000 0100000010100100 00 1001 1000000100000000 00 Funzione G Funzione F CPU (2)

Microprogrammazione Unita’ di Controllo e’ la parte piu’ complessa del Processore DataPath ha struttura regolare Controllo di un set completo ISA ha centinaia/migliaia di stati Rappresentazione Grafica dell’Unita’ di Controllo estramamente complessa Necessita’ Strumento Progettuale piu’ Efficace: Microprogrammazione Obiettivo: Impiegare una Rappresentazione Simbolica dell’Unita’ di Controllo – Microprogramma Richiama il formato di un programma La logica di controllo si ottiene sintetizzando il microprogramma con prodotti CAD CPU (2)

Microprogrammazione Idea: Considerare i segnali di controllo che devono essere affermati ad un certo passo come una (micro)istruzione da far eseguire dal DataPath “Eseguire” una microistruzione significa affermare i segnali di controllo specificati dalla microistruzione Microistruzione specifica: I segnali di controllo da affermare La prossima microistruzione Microistruzione corrisponde ad uno Stato dell’Automa di Controllo Microprogramma: Sequenza di Microistruzioni in forma simbolica Stato Uscita Linee di Controllo AddrCtl 0000 1001010000001000 11 0001 0000000000011000 01 0010 0000000000101000 10 0011 0011000000000000 11 0100 0000001000000010 00 0101 0010100000000000 00 0110 0000000001000100 11 0111 0000000000000011 00 1000 0100000010100100 00 1001 1000000100000000 00 microistruzione CPU (2)

Microprogrammazione: Formato Microistruzioni Rappresentazione simbolica delle microistruzioni Etichetta, Campo1, Campo2, Campo3,…, Sequenza Etichetta specifica locazione (in memoria) della microistruzione Sequenza specifica come scegliere la prossima microistruzione Segnali di controllo sono raggruppati in Campi (field) Segnali di uno stesso campo hanno funzioni tra loro collegate Progettazione Formato Microistruzioni Individuare Segnali di Controllo Raggruppare i segnali in Campi Segnali che svolgono funzioni fra loro collegate Ordinare i Campi Creare una Tabella del Formato Microistruzioni che mostri Nomi dei campi Valori assumibili da ciascun campo e relativa funzione svolta Relativi impostazioni dei segnali di controllo CPU (2)

Campi Microistruzioni (Passi 1-3) Campo Segnali di Controllo Funzione ALU control ALUOp Operazione compiuta da ALU; risultato in ALUOut SRC1 ALUSrcA Provenienza primo operando ALU SRC2 ALUSrcB Provenienza secondo operando ALU Register control RegWrite, RegDest, MemtoReg Lettura o scrittura dei registri nel banco e provenienza dei valori in caso di scrittura Memory MemRead,MemWrite, IorD Lettura o scrittura della memoria e provenienza dei dati; in caso di lettura specifica il registro di destinazione PCWrite control PCWrite, PCSource, PRWriteCond Modalità di aggiornamento di PC Sequencing AddrCtl Modalità di scelta dell’istruzione successiva CPU (2)

Campi Istruzione (Passo 4) -1 CPU (2)

Campi Istruzione (Passo 4) -2 CPU (2)

Microprogramma di Controllo Completo Dispatch ROM 1 Op Opcode name Value Dispatch ROM 2 000000 R-format Rformat1 Op Opcode name Value 000010 jmp JUMP1 100011 lw LW2 000100 beq BEQ1 101011 sw SW2 100011 lw Mem1 101011 sw Mem1 CPU (2)

Implementazione Il Microprogramma e’ una rappresentazione alternativa di un automa a stati finiti Implementabile secondo lo schema con sequenzializzatore visto prima dove ROM<-> Memoria Microcodice Stato<-> Contatore di Microprogramma CPU (2)

Unita’ di Controllo Microprogrammata Il Processore “interpreta” le istruzioni macchina in memoria Legge istruzioni in memoria (scritte in L2) Ne simula il comportamento passo passo “eseguendo” una sequenza di microistruzioni (in L1) L’Unita’ di Controllo genera i segnali di controllo e determina il sequenziamento Il Datapath realizza le operazioni ed il trasferimento fra registri secondo i segnali di controllo Il Microprogramma dell’Unita’ di Controllo (scritto in L1) e’ l’interprete del linguaggio macchina (L2) CPU (2)

Controllo Microprogrammato Riassunto Metodi Alternativi per Specificare ed Implementare l’Unita’ di Controllo Automa a Stati Finiti Rappresentazione Iniziale Microprogramma Funzione pross. Stato in forma esplicita Controllo del Sequenziamento Contatore+ Tabelle di dispatch Rappresentazione Logica Equazione booleane Tabelle di Verita’ Implementazione PLA ROM Controllo Cablato Controllo Microprogrammato CPU (2)

Microprogrammazione: Pro e Contro Vantaggi nella Progettazione Semplicita’ nella progettazione e scrittura Design congiunto dell’architettura e del microprogramma Vantaggi nell’Implementazione Facile da modificare (implementazione su off-chip ROM – anni ’60-’70) Permette l’emulazione di altre ISA Svantaggi dell’Implementazione Controllo e’ oggi sullo stesso chip del processore ROM e’ oggi (relativamente) lenta rispetto alle altre memorie Non c’e’ piu’ necessita’ di cambiare il microprogramma di controllo Computer general purpose CPU (2)

Eccezioni La gestione delle eccezioni e degli interrupt è una delle parti più difficili del controllo Eccezione: un evento non atteso, interno al processore, che interrompe l’esecuzione del programma Esempi: overflow aritmetico, istruzione non definita Interrupt: un evento non atteso, esterno al processore, che interrompe l’esecuzione del programma Esempi: richiesta di un dispositivo di I/O, malfunzionamento hardware Nella terminologia MIPS: interrupt  eccezione Nella terminologia IA-32: non c’è distinzione tra interrupt ed eccezione CPU (2)

Gestione delle eccezioni Quando avviene un’eccezione occorre Salvare nel registro EPC (Exception Program Counter) l’indirizzo dell’istruzione che ha causato l’eccezione Trasferire il controllo al sistema operativo a qualche indirizzo specifico per la gestione dell’eccezione Il sistema operativo, dopo aver eseguito le azioni necessarie, può terminare il programma o continuarne l’esecuzione usando EPC per determinare da dove riprendere l’esecuzione Oltre a EPC, il sistema operativo deve conoscere la ragione dell’eccezione; esistono due meccanismi Registro di stato (Cause register nel MIPS): contiene un campo che indica la causa dell’eccezione Interrupt vettorializzato: l’indirizzo a cui trasferire il controllo è determinato dalla causa dell’eccezione Consideriamo due tipi di eccezioni nell’implementazione a ciclo multiplo Esecuzione di un’istruzione non definita Overflow aritmetico CPU (2)

Gestione delle eccezioni (2) Per gestire le eccezioni nel MIPS occorre aggiungere nell’unità di elaborazione Registro EPC a 32 bit Registro Cause a 32 bit Istruzione non definita: Cause = 0 Overflow aritmetico: Cause = 1 Aggiungiamo due segnali di controllo per abilitare la scrittura dei registri EPC e Cause: EPCWrite e CauseWrite Aggiungiamo un altro segnale di controllo per settare il bit meno significativo del registro Cause: IntCause Occorre scrivere in PC l’indirizzo di eccezione (punto di ingresso del sistema operativo per gestire le eccezioni) Nel MIPS, l’indirizzo di eccezione è (8000 0180)16 Modifichiamo il multiplexer in ingresso a PC da tre a quattro vie PCSource = 11 per abilitare l’indirizzo di eccezione CPU (2)

L’unità a ciclo multiplo con la gestione delle eccezioni Indirizzo di eccezione EPC: usiamo ALU per sottrarre 4 a PC CPU (2)

La macchina a stati finiti con la gestione delle eccezioni CPU (2)