1 / 85

Architetture dei Calcolatori (Lettere j-z) Il Processore (2)

Architetture dei Calcolatori (Lettere j-z) Il Processore (2). Ing. Davide D’Amico. 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

ianna
Download Presentation

Architetture dei Calcolatori (Lettere j-z) Il Processore (2)

An Image/Link below is provided (as is) to download presentation Download Policy: Content on the Website is provided to you AS IS for your information and personal use and may not be sold / licensed / shared on other websites without getting consent from its author. Content is provided to you AS IS for your information and personal use only. Download presentation by click this link. While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server. During download, if you can't get a presentation, the file might be deleted by the publisher.

E N D

Presentation Transcript

  1. Architetture dei Calcolatori(Lettere j-z)Il Processore (2) Ing. Davide D’Amico

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

  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 • MDR: Memory Data Register • A & B: Valori letti dai registri • ALUout: Registro che memorizza il risultato delle operazioni ALU 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 ALU (no adder) • Tempo di ciclo piu’ breve • Tempi di esecuzione inferiori • Istruzioni usano il solo tempo (cicli) necessario alla loro esecuzione CPU (2)

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

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

  7. Una vista più dettagliata (2) Mux su primo ingresso ALU Indirizzo da PC o da ALU Mux su secondo ingresso ALU 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 CPU (2)

  9. L’unità con i segnali di controllo 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 CPU (2)

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

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

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

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

  15. I segnali di controllo ad 1 bit CPU (2)

  16. I segnali di controllo a 2 bit 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 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)

  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 • 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)

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

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

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

  22. Reg[rs] PC + 4 Reg[rt] 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) Branch Target Address CPU (2)

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

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

  25. Reg[rs] PC + 4 Reg[rt] 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) Branch Target Address CPU (2)

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

  27. Reg[rs] PC + 4 Reg[rt] 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) Branch Target Address CPU (2)

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

  29. Reg[rs] PC + 4 Reg[rt] 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) Branch Target Address CPU (2)

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

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

  32. Reg[rs] PC + 4 Reg[rt] 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) Branch Target Address CPU (2)

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

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

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

  36. Action for R-type Action for memory-reference Action for Action for Step name instructions instructions 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 Load: Reg[IR[20-16]] = MDR Memory read completion Schema Riassuntivo Implementazione Multiciclo Step 1: IF 2: ID 3: EX 4: MEM 5: WB CPU (2)

  37. 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… 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 Funct Controllo Read/Write Memorie 6 Controllo MUX Controllo 6 Controllo ALU CPU (2)

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

  39. Rete Combinatoria 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 6 Read/Write Memorie Controllo MUX Stato ALUOp 2 CPU (2)

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

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

  42. 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 Segnali di Controllo: (ID) 0 0 X 0 0 X 010 X X 0 0 3 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 0 X 1 0 X ??? X X 0 0 0 CPU (2)

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

  45. 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 Segnali di Controllo: (ID) 0 0 X 0 0 X 010 X X 0 0 3 CPU (2)

  46. 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 1 if Zero=1 X 1 0 110 X 1 X 0 0 0 CPU (2)

  47. 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 Segnali di Controllo: (ID) 0 0 X 0 0 X 010 X X 0 0 3 CPU (2)

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

  49. 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 Segnali di Controllo: (ID) 0 0 X 0 0 X 010 X X 0 0 3 CPU (2)

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

More Related