La presentazione è in caricamento. Aspetta per favore

La presentazione è in caricamento. Aspetta per favore

Calcolatori Elettronici Il Processore (2) Francesco Lo Presti Rielaborate da Salvatore Tucci.

Presentazioni simili


Presentazione sul tema: "Calcolatori Elettronici Il Processore (2) Francesco Lo Presti Rielaborate da Salvatore Tucci."— Transcript della presentazione:

1 Calcolatori Elettronici Il Processore (2) Francesco Lo Presti Rielaborate da Salvatore Tucci

2 CPU (2)2  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 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 Approccio Multiciclo

3 CPU (2)3 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 IR: Instruction Register MDR: Memory Data Register MDR: Memory Data Register A & B:Valori letti dai registri A & B:Valori letti dai registri ALUout: Registro che memorizza il risultato delle operazioni ALU ALUout: Registro che memorizza il risultato delle operazioni ALU

4 CPU (2)4 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 memoria per dati e istruzioni Una sola ALU (no adder) Una sola ALU (no adder)  Tempo di ciclo piu’ breve  Tempi di esecuzione inferiori Istruzioni usano il solo tempo (cicli) necessario alla loro esecuzione Istruzioni usano il solo tempo (cicli) necessario alla loro esecuzione

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

6 CPU (2)6 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 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) Una per il valore dell’indirizzo (16 bit, estesi in segno a 32 e traslati a sinistra)

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

8 CPU (2)8 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

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

10 CPU (2)10 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

11 CPU (2)11 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

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

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

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

15 CPU (2)15 I segnali di controllo ad 1 bit Segnale Effetto quando vale 0 Effetto quando vale 1 RegDst Registro destinazione = rt Registro destinazione = rd RegWriteNessuno 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 MemReadNessuno Lettura della locazione di memoria indicata da Address MemWriteNessuno 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 IRWriteNessuno Uscita memoria scritta in IR PCWriteNessuno Scrittura in PC: provenienza da PCSource PCWriteCondNessuno Scrittura in PC se Zero di ALU è 1

16 CPU (2)16 I segnali di controllo a 2 bit SegnaleValEffetto ALUOp00 L’ALU calcola la somma 01 L’ALU calcola la sottrazione 10 Operazione determinata dal campo funct ALUScrB00 Il secondo ingresso della ALU: proviene da reg. B 01 …: è la costante 4 10 …: il valore dei 16 bit meno sign. di IR, estesi a …: il valore dei 16 bit meno sign. di IR, estesi a 32, traslati a sinistra di 2 bit PCSource00 In PC viene scritta l’uscita della ALU (PC+4) 01 In PC viene scritto ALUOut (indirizzo di beq) 10 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)

17 CPU (2)17 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’operazione con la ALU Un accesso al banco dei registri Un accesso al banco dei registri Un accesso alla memoria Un accesso alla memoria  In questo modo, la durata del ciclo di clock sarà pari alla durata della più lenta di queste tre operazioni

18 CPU (2)18 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 A, B, MDR oppure ALUOut IR (dotato di segnale di controllo per la scrittura) 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

19 CPU (2)19  Si suddividono le istruzioni nei seguenti passi potenziali – non tutte le istruzioni le richiedono tutte 1. 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 2. 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). 3. Esecuzione, Calcolo Indirizzo di Memoria, o completamento salto (EX)  ALU esegue una delle seguenti funzioni in base al tipo di istruzione memory reference memory reference R-type R-type  branch (Istruzione Completata)  jump (Istruzione Completata) Suddivisione in Passi

20 CPU (2)20 1. Accesso in Memoria e Completamento Istruzione R (MEM)  In base al tipo di istruzione Legge dalla memoria Legge dalla memoria Scrive in memoria (Istruzione Completata) Scrive in memoria (Istruzione Completata) Scrittura nel Registro Destinazione (Istruzione Completata) Scrittura nel Registro Destinazione (Istruzione Completata) 2. 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 Suddivisione in Passi

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

36 CPU (2)36 Schema Riassuntivo Implementazione Multiciclo 1: IF 2: ID 3: EX 4: MEM 5: WB Step Step name Action for R-type instructions Action for memory-reference instructions Action for branches Action for jumps Instruction fetchIR = M[PC] PC = PC + 4 InstructionA = Reg [IR[25-21]] decode/register fetchB = Reg [IR[20-16]] ALUOut = PC + (sign-extend (IR[15-0]) << 2) Execution, addressALUOut = A op BALUOut = A + sign-extendif (A ==B) thenPC = PC [31-28] II computation, branch/(IR[15-0])PC = ALUOut(IR[25-0]<<2) jump completion Memory access or R-typeReg [IR[15-11]] =Load: MDR = M[ALUOut] completionALUOutor Store: M[ALUOut] = B Memory read completion Load: Reg[IR[20-16]] = MDR

37 CPU (2)37 Controllo  L’Unita di Controllo deve generare:  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… 1. Tipo di Istruzione da eseguire (Ingresso)  I bit del campo opcode (e funct nel caso del formato R) dell’istruzione 2. Step dell’istruzione  Una rete combinatoria non e’ sufficiente ad implementare il controllo multiciclo Controllo Opcode Funct Controllo ALU Controllo MUX Read/Write Memorie 6 6

38 CPU (2)38 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 Controllo Opcode Funct Controllo ALU Controllo MUX Read/Write Memorie 6 6 Controllo ALUOp Controllo MUX Read/Write Memorie 2 6 Funct 6 ALU Control Controllo ALU Opcode

39 CPU (2)39 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… 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 Perche’ e’ un automa di Moore Opcode Controllo MUX Read/Write Memorie 6 ALUOp 2 Rete Combinatoria Stato Rete Combinatoria

40 CPU (2)40 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 R-type EXECalcolo Indirizzo M-Read M-Write R-Write Beq EXE (PC update)Jump EXE (PC update) Fetch Decode, Fetch Reg, beq Inizio

41 CPU (2)41 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= X 0 X

42 CPU (2)42 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= X 0 0 X 3 0 X X 010 0

43 CPU (2)43 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) 0 X X X 0 1 X ??? 0

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

45 CPU (2)45 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= X 0 0 X 3 0 X X 010 0

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

47 CPU (2)47 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= X 0 0 X 3 0 X X 010 0

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

49 CPU (2)49 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= X 0 0 X 3 0 X X 010 0

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

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

52 CPU (2)52 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= X 0 0 X 3 0 X X 010 0

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

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

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

56 CPU (2)56 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 R-type EXECalcolo Indirizzo M-Read M-Write R-Write Beq EXE (PC update)Jump EXE (PC update) Fetch Decode, Fetch Reg, beq Inizio

57 CPU (2)57 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

58 CPU (2)58 Unita’ di Controllo: Funzione di Uscita Outputs Input Values (Current State[3-0]) PCWrite PCWriteCondX X IorD0XX1X1XXXX MemRead MemWrite IRWrite MemtoRegXXXX1XX0XX PCSource00XXXXXXXXXXXXXX0110 ALUOp000000XXXXXX10XX01XX ALUSrcB011110XXXXXX00XX00XX ALUSrcA001XXX1X1X RegWrite RegDstXXXX0XX1XX

59 CPU (2)59 Unita’ di Controllo: Funzione Prossimo Stato Current State [3-0] Inst[31-26] (Op[5-0]) (R- type) (jmp) (beq) (lw) (sw) Any other illegal 0010XXXXXXXXXXXX illegal 0011XXXXXXXXXXXX0100XXXXillegal 0100XXXXXXXXXXXX0000XXXXillegal 0101XXXXXXXXXXXXXXXX0000illegal XXXXXXXXXXXXXXXXillegal XXXXXXXXXXXXXXXXillegal 1000XXXXXXXX0000XXXXXXXXillegal 1001XXXX0000XXXXXXXXXXXXillegal

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

61 CPU (2)61 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 Realizzabile tramite PLA o ROM

62 CPU (2)62 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

63 CPU (2)63  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 2 m 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 2 m xn bit Reti Combinatorie e ROM mn ROM m = 3 n = 4 Output = Contenuto celle Input = indirizzo

64 CPU (2)64 Implementazione del Controllo tramite ROM  Rete combinatoria dell’unita’ di controllo ha:  10 linee in ingresso 6 bit opcode 6 bit opcode 4 bit stato 4 bit stato Indirizzo= Indirizzo=  20 linee di output 16 bit di segnali di controllo 16 bit di segnali di controllo 4 bit di stato 4 bit di stato  Realizzazione ROM richiede 2 10 x20=20Kbits  Soluzione inefficiente  16 bit di uscita (segnali di controllo) dipendono solo dai 4 bit dello stato Automa di Moore Automa di Moore  indirizzi, 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, al variare di XXX i contenuti delle celle spesso sono identici Stato __Uscita (Linee di Controllo)

65 CPU (2)65 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 2 4 x16b=0.25Kb ROM di 2 4 x16b=0.25Kb  G: 10 bit (4 stato+6 opcode) determinano il prossimo stato ROM di 2 10 x4b=4Kb ROM di 2 10 x4b=4Kb  Totale 4.25Kbit >> numero celle PLA PLA ottimizza la rete grazie ai molti DON’T CARE 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 4Kb vs 0.25Kb Stato __Uscita (Linee di Controllo) Si puo’ semplificare l’implementazione sfruttando la struttura di G?

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

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

68 CPU (2)68 Sequenzializzatore in dettaglio Rom

69 CPU (2)69 Sequenzializzatore: Contenuto della Memoria di Controllo Stato Uscita Linee di Controllo AddrCtl Funzione F Funzione G

70 CPU (2)70 Microprogrammazione  Unita’ di Controllo e’ la parte piu’ complessa del Processore  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

71 CPU (2)71 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 microistruzione

72 CPU (2)72 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  Campo x rappresenta un gruppo di segnali di controllo che realizzano una particolare funzione Segnali di uno stesso campo hanno funzioni tra loro collegate Segnali di uno stesso campo hanno funzioni tra loro collegate

73 CPU (2)73 Campi Microistruzione per il Processore Multi-Ciclo 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,Mem Write, 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

74 CPU (2)74 I valori dei campi Etichettastringa Indica l’etichetta (label) dell’istruzione Add ALU deve sommare SubSubSubSub ALU deve sottrarre Func codeFunc codeFunc codeFunc code ALU deve usare funct per l’operazione ALU control PC PC è il primo operando della ALU A Registro A è il primo operando della ALU SRC1 SRC2B Registro B è il secondo operando della ALU 4 Il valore 4 è il secondo operando della ALU Extend Uscita esten. segno è il sec. operando della ALU Extshift Uscita shift è il secondo operando della ALU

75 CPU (2)75 I valori dei campi (2) Read Legge i due registri usando IR, output in A e B Write ALU Scrive usando rd come registro e ALUOut come dato Write MDR Scrive usando rt come registro e MDR come dato Register control Read PC Legge la memoria usando PC, risultato in IR e MDR Read ALU Write ALU Scrive la memoria usando ALUOut e B Legge la memoria usando ALUOut, risultato in MDR Memory ALU Scrive uscita della ALU in PC ALUout-cond Jump address Scrive in PC l’indirizzo di salto preso dall’istruzione Se Zero vale 1, scrive in PC il valore di ALUOut PCWrite control Seq Vai alla microistruzione successiva Fetch Dispatch i Usa la tabella di Dispatch per indicare la prossima istr. Vai alla prima microistruzione Sequencing

76 CPU (2)76 Scelta della microistruzione successiva Le microistruzioni sono memorizzate in una ROM o PLA  Possiamo assegnare degli indirizzi alle microistruzioni Diverse possibilità per scegliere la microistruzione successiva 1. Passare alla microistruzione seguente Il campo Sequencing viene messo al valore Seq Il campo Sequencing viene messo al valore Seq 2. Passare alla microistruzione che inizia l’esecuzione della prossima istruzione MIPS La prima microistruzione ha un’etichetta Fetch La prima microistruzione ha un’etichetta Fetch Il campo Sequencing viene messo al valore Fetch Il campo Sequencing viene messo al valore Fetch 3. Passare alla microistruzione a seconda di valori indicati in input all’unità di controllo Si usa una tabella di Dispatch (solitamente una ROM) Si usa una tabella di Dispatch (solitamente una ROM) Il campo Sequencing viene messo al valore Dispatch i Il campo Sequencing viene messo al valore Dispatch i –i è un valore che viene passato alla tabella di Dispatch che restituisce la prossima istruzione a seconda del valore dei 6 bit del campo Op che vengono passati all’unità di controllo

77 CPU (2)77 I primi due passi (prelievo e decodifica)  Incremento del Program Counter e scrittura ALU dell’incremento  Lettura istruzione indicata da PC (in IR)  Salto alla microistruzione indicata dalla tabella di Dispatch Label ALU control SRC1SRC2 Register control Memory PCWrite control Sequencing FetchAddPC4 Read PC ALUSeq AddPCExtshiftRead Dispatch 1

78 CPU (2)78 Le etichette del Dispatch  Servono a differenziare i 4 tipi di istruzioni  Una specie di switch  Esistono 4 etichette  Mem1  Rformat1  BEQ1  JUMP1  Le informazioni sono memorizzate in una ROM Dispatch ROM 1 OpOpcode nameValue R-formatRformat jmp JUMP beq BEQ lw Mem sw Mem1

79 CPU (2)79 Istruzioni di accesso alla memoria  Calcolo indirizzo  Dispatch 2 per determinare prossima micro-istruzione  Due passi per l’istruzione lw ()  Un passo per l’istruzione sw Label ALU control SRC1SRC2 Register control Memory PCWrite control Sequencing Mem1AddAExtend Dispatch 2 LW2 Read ALU Seq Write MDR Fetch SW2 Write ALU Fetch Dispatch ROM 2 OpOpcode nameValue lw LW sw SW2

80 CPU (2)80 Istruzioni di tipo R  Operazione indicata dal campo funct  Scrittura nel registro del risultato dell’operazione  Torna alla microistruzione con label Fetch Label ALU control SRC1SRC2 Register control Memory PCWrite control Sequencing Rformat1FuncABSeq Write ALU Fetch

81 CPU (2)81 Istruzione di branch  Effettua la sottrazione tra A e B  Il risultato non interessa, serve soltanto la linea Zero  Scrittura del PC calcolato nel passo precedente solamente se la linea Zero della ALU è pari ad 1  Torna alla microistruzione con label Fetch Label ALU control SRC1SRC2 Register control Memory PCWrite control Sequencing BEQ1SubAB ALUOut- cond Fetch

82 CPU (2)82 Istruzione di jump  Scrittura del PC con il nuovo indirizzo  Torna alla microistruzione con label Fetch Label ALU control SRC1SRC2 Register control Memory PCWrite control Sequencing JUMP1 Jump address Fetch

83 CPU (2)83 Dispatch ROM 1 OpOpcode nameValue R-formatRformat jmp JUMP beq BEQ lw Mem sw Mem1 Dispatch ROM 2 OpOpcode nameValue lw LW sw SW2 Microprogramma di Controllo Completo

84 CPU (2)84 Codifica Microistruzioni

85 CPU (2)85 Codifica Microistruzioni

86 CPU (2)86 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

87 CPU (2)87 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 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 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)

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

89 CPU (2)89  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 Computer general purpose Microprogrammazione: Pro e Contro

90 CPU (2)90 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

91 CPU (2)91 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 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 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

92 CPU (2)92 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 Istruzione non definita: Cause = 0 Overflow aritmetico: Cause = 1 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 è ( ) 16  Modifichiamo il multiplexer in ingresso a PC da tre a quattro vie PCSource = 11 per abilitare l’indirizzo di eccezione PCSource = 11 per abilitare l’indirizzo di eccezione

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

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


Scaricare ppt "Calcolatori Elettronici Il Processore (2) Francesco Lo Presti Rielaborate da Salvatore Tucci."

Presentazioni simili


Annunci Google