Calcolatori Elettronici

Transcript

1 Calcolatori Elettronici CPU multiciclo Massimiliano Giacomin

2 SVANTAGGI DEL PROCESSORE A SINGOLO CICLO Tutte le istruzioni lunghe un ciclo di clock T clock determinato dall istruzione più lenta Istruzioni più lente limitano le istruzioni più veloci! lunga HW non può essere riutilizzato nell esecuzione di una istruzione aumento dei costi potenzialmente breve ESEMPIO MIPS: due memorie [dati e istruzioni] tre ALU: - istruzioni aritmetiche confronto operandi in beq indirizzo lw e sw - calcolo PC+ - calcolo indirizzo di salto beq 2

3 DAL PROCESSORE A SINGOLO CICLO lunga potenzialmente breve AL PROCESSORE MULTICICLO Suddividere le istruzioni in fasi : un ciclo di clock per una fase! T esecuzione T 2 esecuzione NB: T 2 esecuzione (il caso peggiore) può in generale essere maggiore del precedente! Tuttavia, le istruzioni più lunghe sono anche meno frequenti: principio rendere più veloce l evento più frequente comporta un guadagno! 3

4 PROCESSORE MULTICICLO: CONCETTI FONDAMENTALI P C DATAPATH (schema di base) Registri temporanei (non visibili al programmatore) - memorizzano dati prodotti in un ciclo di clock e utilizzati dalla stessa istruzione nel ciclo successivo Controllo sequenziale (una fase diversa per ogni ciclo) LINEE GUIDA PER L EFFICIENZA ) T clock : la serie più lenta utilizzata in una fase (caso peggiore) Bilanciare le fasi (no serie di unità funzionali lente ) 2) Operazioni ottimistiche: utilizzo di unità funzionali libere per elaborazioni possibilmente utili

5 VANTAGGI DEL PROCESSORE MULTICICLO ) EFFICIENZA (diminuisce T clock ) 2) RIUTILIZZO DELLA STESSA UNITA FUNZIONALE NEL CORSO DELLA STESSA ISTRUZIONE diminuzione dei costi 5

6 IL CASO MIPS ASSUNZIONE FONDAMENTALE: Operazioni lente da non mettere in serie: - o in memoria (istruzioni o dati) - o al register file (lettura o scrittura) - operazioni della ALU Accesso/scrittura in un registro singolo trascurabile (o non oneroso) CONSEGUENZA: P C MEM. REG. FILE MEM. REG. FILE FETCH PRELIEVO (DECODE) EXECUTE MEM WRITE BACK 6

7 Specifica progressiva del datapath Di seguito sono schematizzate le attività che una macchina multiciclo svolge per eseguire il set ridotto di istruzioni MIPS: le fasi rispettano i vincoli posti in precedenza sulle operazioni che si possono eseguire in serie. Nello specificare le diverse attività di calcolo si sono seguite le convenzioni adottate nel testo. In particolare, sono rese visibili le risorse impegnate nel ciclo in esame. La combinazione delle immagini risulta nello schema finale del testo. DALLA SPECIFICA DEL DATAPTH EMERGE ANCHE LA SPECIFICA DEL CONTROLLO SEQUENZIALE 7

8 I ciclo:prelievo dell istruzione I ciclo: IR memoria [PC] ottimistiche: PC PC + IorD = IRWrite AluSrcA = P C indirizzo Memoria Dato scritto MemData Istruzioni [3-26] [25-2] [2-6] [5-] letto Regist ro letto Registr o scritto Dato scritto Registri Dato letto Dato letto 2 A L U AluCom zero ris [indicati i valori affermati e controlli MUX rilevanti] AluSrcB = UC ALU AluOp= [addizione] 8

9 NB: Durante il primo ciclo di clock vengono creati i due percorsi paralleli: PC_out Memoria IR PC_out ALU PC_in + vengono attivati i segnali di scrittura in IR e PC Alla fine del periodo di clock (fronte del clock): PC e IR vengono scritti; i valori sono disponibili nel ciclo di clock successivo Durante il secondo ciclo di clock IR contiene l istruzione da eseguire, PC è già stato incrementato NB: si noti che ciascun percorso contiene soltanto un elemento critico (memoria e ALU); sorgente e destinazione infatti sono registri singoli (PC e IR) 9

10 II ciclo:decodifica e caricamento registri ottimistiche: alimentazione registri: A registro[ir[25-2]]; B registro[ir[2-6]] calcolo indirizzo branch: AluOut PC + (sign_ext(ir[5-]) << 2) Al controllo per decodifica AluSrcA = P C Memoria Istruzioni [25-2] [2-6] [5-] Nota: non si conosce l istruzione in questo passo: tutte le operazioni ottimistiche! Nota: A,B Aluout non sono controllati (memorizzano il valore ad ogni fronte del CK) [3-26] letto A Dato A letto letto scritto Dato scritto Est. segno Registri Dato letto 2 B Shift << AluSrcB=3 L U UC ALU AluCom zero ris Alu Out AluOp= [addizione]

11 NB: si è detto che nel secondo ciclo è già disponibile l istruzione in IR. D altra parte si dice anche che non si conosce quale sia l istruzione e quindi si effettua la decodifica + le uniche operazioni svolte sono ottimistiche Ciò perché si usa il modello di Moore: uscite del sistema di controllo dipendono solo dallo stato corrente, non dagli ingressi [IR]. FETCH Uscita: - carica IR - PC + Unica transizione possibile! Questa è la decodifica DECODE Uscita: - ottimistiche Transizione dipende da IR! III ciclo caso III ciclo caso 2 Uscita:

12 III ciclo:se è branch (beq) IF ([A]= = [B]): PC [AluOut] Attenzione: si ritocca il data path e si introduce PCsource = AluSrcA = PCsource= Cond P C Memoria Istruzioni Registri A questo punto istruzione terminata! (si ricomincia dal primo ciclo prox istruzione) letto letto scritto Dato scritto Dato letto Dato letto 2 A B Shift << AluSrtcB= A L U UC ALU AluCom ris zero Alu Out AluOp= [sottrazione] 2

13 III ciclo: se è salto incondizionato (jump) PC PC[3-28]½½(IR[25-]<<) PCsource = 2 PC[3-28] 2 P C indirizzo Memoria Dato scritto MemData Istruzioni [3-26] [25-2] [2-6] [5-] IR[25-] 26 Shift << 2 28 Registri 32 A L U ris AluCom Alu Out A questo punto l istruzione è terminata! (si ricomincia dal primo ciclo prossima istruzione) UC ALU 3

14 III ciclo:per tipo R AluOut A op B AluSrcA= P C Memoria Istruzioni [3-26] [2-6] [5-] Registri A B A L U AluCom ris zero Alu Out IR[5-] Shift << 2 AluSrcB= UC ALU AluOp= [op in base a funct]

15 IV ciclo: completamento istruzioni R Reg [IR[5-]] Aluout RegDst= P C Memoria o MemData Dato scritto MDR Istruzioni [3-26] [25-2] [2-6] [5-] IR[5-] letto letto scritto Dato scritto Registri Dato letto Dato letto 2 A B A L U UC ALU zero ris Alu Out MemToReg = A questo punto l istruzione è terminata! 5

16 III ciclo:per tipo o a memoria AluOut [A]+ (signext([ir[5-]]) AluSrcA= P C Memoria Istruzioni [3-26] [2-6] [5-] Registri A B 2 3 A L U AluCom ris zero Alu Out SignExt Shift << 2 UC ALU AluOp= [addizione] AluSrcB= 6

17 IV ciclo: memorizza parola (sw) memoria [AluOut] B (NB: B è stato letto due volte ) IorD= MemWrite P C indirizzo Memoria Dato scritto MemData 32 Istruzioni [3-26] [25-2] [2-6] [5-] letto letto scritto Dato scritto Registri Dato letto Dato letto 2 A B A L U zero ris Alu Out MDR UC ALU A questo punto l istruzione è terminata! 7

18 IV ciclo: carica parola (lw) MDR memoria [AluOut] IorD= P C indirizzo Memoria Dato scritto MemData 32 Istruzioni [3-26] [25-2] [2-6] [5-] letto letto scritto Dato scritto Registri Dato letto Dato letto 2 A B A L U zero ris Alu Out MDR UC ALU 8

19 V ciclo: completamento lettura da memoria (lw) Reg [IR[2-6]] MDR RegDst= P C Memoria o MemData Dato scritto MDR Istruzioni [3-26] [25-2] [2-6] [5-] letto letto scritto Dato scritto Registri Dato letto Dato letto 2 A B A L U UC ALU zero ris Alu Out A questo punto istruzione terminata! MemToReg= 9

20 Da queste considerazioni risultano immediatamente: unità di elaborazione (datapath) specifica dell unità di controllo 2

21 (Op = 'LW') (Op = 'J') 2 3 address computation ALUSrcA = ALUSrcB = (Op = 'SW') 5 Start (Op = 'LW') or (Op = 'SW') Instruction fetch ALUSrcA = IorD = IRWrite ALUSrcB = PCSource = 6 7 Execution ALUSrcA = ALUSrcB = ALUOp= 8 R-type (Op = R-type) Branch ALUSrcA = ALUSrcB = ALUOp = Cond PCSource = (Op = 'BEQ') Instruction decode/ register fetch 9 ALUSrcA = ALUSrcB = Jump PCSource = NB: i segnali di controllo che in uno stato non sono nominati si intendono: - se del tipo read o write (es. IRWrite) - don t care altrimenti (es: ALUOp o ALUSrcA) IorD = MemWrite IorD = RegDst = MemtoReg = Write-back step RegDst = MemtoReg = 2

22 Realizzazione Unità di Controllo con macchina a stati finiti di Moore Funzione ω Funzione δ Unità di controllo di stato P C Memoria indirizzo Programma Istruzioni [3-26] Codice Operativo Unità di Os Servizi elaborazione 22

23 Automa con stati Þ bit per codificarli (S3-S) memorizzati con flip-flop di tipo D Codifica: assegnamento di un valore a ciascuno stato (useremo numero progressivo) Dobbiamo realizzare due funzioni logiche combinatorie: - funzione di uscita ω(s) restituisce 6 segnali di uscita - funzione di stato futuro δ(s, I) restituisce NS3 NS dove s = (S3, S2, S, S) I = (OP5,, OP) 23

24 CPU MULTICICLO: ILLUSTRAZIONI ESECUZIONE ISTRUZIONI 2

25 ESECUZIONE IN UNA CPU MULTICICLO DI UNA ISTRUZIONE DI TIPO-R 25

26 (Op = 'LW') (Op = 'J') ISTRUZIONE TIPO-R address computation 2 6 ALUSrcA = ALUSrcB = (Op = 'SW') MemWrite IorD = IorD = Write-back step RegDst = MemtoReg = Instruction fetch ALUSrcA = IorD = Start IRWrite ALUSrcB = PCSource = (Op = 'LW') or (Op = 'SW') (Op = R-type) Instruction decode/ register fetch ALUSrcA = ALUSrcB = Branch Jump Execution 8 9 ALUSrcA = ALUSrcA = ALUSrcB = ALUSrcB = ALUOp = PCSource = ALUOp= Cond PCSource = R-type RegDst = MemtoReg = (Op = 'BEQ') FETCH IR=istruz PC=PC+ 26

27 (Op = 'LW') (Op = 'J') ISTRUZIONE TIPO-R address computation 2 6 ALUSrcA = ALUSrcB = (Op = 'SW') MemWrite IorD = IorD = Write-back step RegDst = MemtoReg = Instruction fetch ALUSrcA = IorD = Start IRWrite ALUSrcB = PCSource = (Op = 'LW') or (Op = 'SW') (Op = R-type) Instruction decode/ register fetch ALUSrcA = ALUSrcB = Branch Jump Execution 8 9 ALUSrcA = ALUSrcA = ALUSrcB = ALUSrcB = ALUOp = PCSource = ALUOp= Cond PCSource = R-type RegDst = MemtoReg = (Op = 'BEQ') DECODE A=rs, B=rt ALUOut=Dest beq 27

28 (Op = 'LW') (Op = 'J') ISTRUZIONE TIPO-R address computation 2 6 ALUSrcA = ALUSrcB = (Op = 'SW') MemWrite IorD = IorD = Write-back step RegDst = MemtoReg = Instruction fetch ALUSrcA = IorD = Start IRWrite ALUSrcB = PCSource = (Op = 'LW') or (Op = 'SW') (Op = R-type) Instruction decode/ register fetch ALUSrcA = ALUSrcB = Branch Jump Execution 8 9 ALUSrcA = ALUSrcA = ALUSrcB = ALUSrcB = ALUOp = PCSource = ALUOp= Cond PCSource = R-type RegDst = MemtoReg = (Op = 'BEQ') EXECUTE ALUOut=A+B 28

29 (Op = 'LW') (Op = 'J') ISTRUZIONE TIPO-R address computation 2 6 ALUSrcA = ALUSrcB = (Op = 'SW') MemWrite IorD = IorD = Write-back step RegDst = MemtoReg = Instruction fetch ALUSrcA = IorD = Start IRWrite ALUSrcB = PCSource = (Op = 'LW') or (Op = 'SW') (Op = R-type) Instruction decode/ register fetch ALUSrcA = ALUSrcB = Branch Jump Execution 8 9 ALUSrcA = ALUSrcA = ALUSrcB = ALUSrcB = ALUOp = PCSource = ALUOp= Cond PCSource = R-type RegDst = MemtoReg = (Op = 'BEQ') WRITE-BACK rd=aluout 29

30 ESECUZIONE IN UNA CPU MULTICICLO DI UNA ISTRUZIONE LW 3

31 (Op = 'LW') (Op = 'J') ISTRUZIONE LW address computation 2 6 ALUSrcA = ALUSrcB = (Op = 'SW') MemWrite IorD = IorD = Write-back step RegDst = MemtoReg = Instruction fetch ALUSrcA = IorD = Start IRWrite ALUSrcB = PCSource = (Op = 'LW') or (Op = 'SW') (Op = R-type) Instruction decode/ register fetch ALUSrcA = ALUSrcB = Branch Jump Execution 8 9 ALUSrcA = ALUSrcA = ALUSrcB = ALUSrcB = ALUOp = PCSource = ALUOp= Cond PCSource = R-type RegDst = MemtoReg = (Op = 'BEQ') FETCH IR=istruz PC=PC+ 3

32 (Op = 'LW') (Op = 'J') ISTRUZIONE LW address computation 2 6 ALUSrcA = ALUSrcB = (Op = 'SW') MemWrite IorD = IorD = Write-back step RegDst = MemtoReg = Instruction fetch ALUSrcA = IorD = Start IRWrite ALUSrcB = PCSource = (Op = 'LW') or (Op = 'SW') (Op = R-type) Instruction decode/ register fetch ALUSrcA = ALUSrcB = Branch Jump Execution 8 9 ALUSrcA = ALUSrcA = ALUSrcB = ALUSrcB = ALUOp = PCSource = ALUOp= Cond PCSource = R-type RegDst = MemtoReg = (Op = 'BEQ') DECODE A=rs, B=rt ALUOut=Dest beq 32

33 (Op = 'LW') (Op = 'J') ISTRUZIONE LW address computation 2 6 ALUSrcA = ALUSrcB = (Op = 'SW') MemWrite IorD = IorD = Write-back step RegDst = MemtoReg = Instruction fetch ALUSrcA = IorD = Start IRWrite ALUSrcB = PCSource = (Op = 'LW') or (Op = 'SW') (Op = R-type) Instruction decode/ register fetch ALUSrcA = ALUSrcB = Branch Jump Execution 8 9 ALUSrcA = ALUSrcA = ALUSrcB = ALUSrcB = ALUOp = PCSource = ALUOp= Cond PCSource = R-type RegDst = MemtoReg = (Op = 'BEQ') EXECUTE ALUOut=A+offset 33

34 (Op = 'LW') (Op = 'J') ISTRUZIONE LW address computation 2 6 ALUSrcA = ALUSrcB = (Op = 'SW') MemWrite IorD = IorD = Write-back step RegDst = MemtoReg = Instruction fetch ALUSrcA = IorD = Start IRWrite ALUSrcB = PCSource = (Op = 'LW') or (Op = 'SW') (Op = R-type) Instruction decode/ register fetch ALUSrcA = ALUSrcB = Branch Jump Execution 8 9 ALUSrcA = ALUSrcA = ALUSrcB = ALUSrcB = ALUOp = PCSource = ALUOp= Cond PCSource = R-type RegDst = MemtoReg = (Op = 'BEQ') MEM MDR=M[ALUOut] 3

35 (Op = 'LW') (Op = 'J') ISTRUZIONE LW address computation 2 6 ALUSrcA = ALUSrcB = (Op = 'SW') MemWrite IorD = IorD = Write-back step RegDst = MemtoReg = Instruction fetch ALUSrcA = IorD = Start IRWrite ALUSrcB = PCSource = (Op = 'LW') or (Op = 'SW') (Op = R-type) Instruction decode/ register fetch ALUSrcA = ALUSrcB = Branch Jump Execution 8 9 ALUSrcA = ALUSrcA = ALUSrcB = ALUSrcB = ALUOp = PCSource = ALUOp= Cond PCSource = R-type RegDst = MemtoReg = (Op = 'BEQ') WRITE-BACK rt=mdr 35

36 ESECUZIONE IN UNA CPU MULTICICLO DI UNA ISTRUZIONE BEQ 36

37 (Op = 'LW') (Op = 'J') ISTRUZIONE BEQ address computation 2 6 ALUSrcA = ALUSrcB = (Op = 'SW') MemWrite IorD = IorD = Write-back step RegDst = MemtoReg = Instruction fetch ALUSrcA = IorD = Start IRWrite ALUSrcB = PCSource = (Op = 'LW') or (Op = 'SW') (Op = R-type) Instruction decode/ register fetch ALUSrcA = ALUSrcB = Branch Jump Execution 8 9 ALUSrcA = ALUSrcA = ALUSrcB = ALUSrcB = ALUOp = PCSource = ALUOp= Cond PCSource = R-type RegDst = MemtoReg = (Op = 'BEQ') FETCH IR=istruz PC=PC+ 37

38 (Op = 'LW') (Op = 'J') ISTRUZIONE BEQ address computation 2 6 ALUSrcA = ALUSrcB = (Op = 'SW') MemWrite IorD = IorD = Write-back step RegDst = MemtoReg = Instruction fetch ALUSrcA = IorD = Start IRWrite ALUSrcB = PCSource = (Op = 'LW') or (Op = 'SW') (Op = R-type) Instruction decode/ register fetch ALUSrcA = ALUSrcB = Branch Jump Execution 8 9 ALUSrcA = ALUSrcA = ALUSrcB = ALUSrcB = ALUOp = PCSource = ALUOp= Cond PCSource = R-type RegDst = MemtoReg = (Op = 'BEQ') DECODE A=rs, B=rt ALUOut=Dest beq 38

39 (Op = 'LW') (Op = 'J') ISTRUZIONE BEQ address computation 2 6 ALUSrcA = ALUSrcB = (Op = 'SW') MemWrite IorD = IorD = Write-back step RegDst = MemtoReg = Instruction fetch ALUSrcA = IorD = Start IRWrite ALUSrcB = PCSource = (Op = 'LW') or (Op = 'SW') (Op = R-type) Instruction decode/ register fetch ALUSrcA = ALUSrcB = Branch Jump Execution 8 9 ALUSrcA = ALUSrcA = ALUSrcB = ALUSrcB = ALUOp = PCSource = ALUOp= Cond PCSource = R-type RegDst = MemtoReg = (Op = 'BEQ') WRITE BACK rs-rt=? Æ, PC=ALUOut 39

40 PRESTAZIONI DEL PROCESSORE MULTICICLO

41 PRESTAZIONI DEL PROCESSORE MULTICICLO T CPU = I *CPI *T clock + I 2 *CPI 2 *T clock + I 3 *CPI 3 *T clock + = (I *CPI + I 2 *CPI 2 + I 3 *CPI 3 + ) * T clock = #istruzioni * (f *CPI + f 2 *CPI 2 + f 3 *CPI 3 + ) * T clock CPI CPI: clock Cycles Per Instruction numero medio di cicli di clock per istruzione: media del numero di cicli di clock che le diverse istruzioni di un programma richiedono per essere completate T CPU = #istruzioni * CPI * T clock = #istruzioni * CPI f clock NB: T medio-istruzione = CPI*T clock

42 Espressione dei CPI CPI può rappresentare il numero medio di cicli di clock delle istruzioni riferito a un programma, ma più in generale al carico di lavoro previsto (instruction mix) CPI = = n å i= n å i= (CPI I ) ( f I i i i CPIi) (I i : numero di istruzioni i eseguite) dove f i è la frequenza delle istruzioni della classe i e CPI i è il numero di cicli per le istruzioni della classe i, mentre n è il numero delle classi 2

43 Periodo di clock nei processori multiciclo P C Per ogni istruzione Per ogni ciclo di clock Valutare il cammino critico CASO PEGGIORE! T clock = max{t,,t m } [operazioni atomiche eseguite in un ciclo di clock] 3

44 CONFRONTO TRA PRESTAZIONI DI PROCESSORI I processori possono avere linguaggi diversi: valutati sullo stesso task (ruolo del compilatore) Per un processore X (e un task T) vale la relazione prestazioni x = tempo di esecuzione X Se per due processori X e Y, le prestazioni di X sono migliori di Y (per lo stesso task) si ha che prestazioni X > prestazioni Y > tempo di esecuzione X tempo di esecuzione Y tempo di esecuzione Y > tempo di esecuzione X

45 Relazione fra le prestazioni di 2 processori Se il processore X è n volte più veloce del processore Y si scriverà: prestazioni X prestazioni Y = n E quindi prestazioni X prestazioni Y tempo di esecuzione Y = = n tempo di esecuzione X (diciamo anche che Y è n volte più lento) 5

46 NB: in generale tempo di esecuzione Y = #istr Y * CPI Y * T clocky tempo di esecuzione X #istr X * CPI X * T clockx Se le macchine implementano lo stesso ISA tempo di esecuzione Y = tempo di esecuzione X CPI Y * T clocky CPI X * T clockx [vedere gli esercizi per applicazioni di queste formule] 6

47 APPENDICE Dettagli sulla realizzazione unità di controllo 7

48 Automa con stati Þ bit per codificarli (S3-S) memorizzati con flip-flop di tipo D Codifica: assegnamento di un valore a ciascuno stato (useremo numero progressivo) Dobbiamo realizzare due funzioni logiche combinatorie: - funzione di uscita h(s) restituisce 6 segnali di uscita - funzione di stato futuro f(s, I) restituisce NS3 NS dove s = (S3, S2, S, S) I = (OP5,, OP) 8

49 (Op = 'LW') (Op = 'J') CODIFICA DEGLI STATI 2 address computation ALUSrcA = ALUSrcB = Start Instruction fetch ALUSrcA = IorD = IRWrite ALUSrcB = PCSource = 6 (Op = 'LW') or (Op = 'SW') Execution ALUSrcA = ALUSrcB = ALUOp= 8 (Op = R-type) Branch ALUSrcA = ALUSrcB = ALUOp = Cond PCSource = Instruction decode/ register fetch (Op = 'BEQ') 9 ALUSrcA = ALUSrcB = Jump PCSource = 3 5 (Op = 'SW') 7 R-type IorD = MemWrite IorD = RegDst = MemtoReg = Write-back step RegDst = MemtoReg = 9

50 SPECIFICA FUNZIONE DI USCITA Tabelle di verità (dipendono solo da stato): indicati solo stati in cui esistono uscite = PCSource (PCSource PCSource) Dal diagramma di stato, si vede che: - PCSource vale nello stato 9 - PCSource vale nello stato 8 S3 S2 S S PCSource S3 S2 S S PCSource Equazioni logiche: PCSource= S3 S2 S S PCSource= S3 S2 S S IorD Dal diagramma di stato, si vede che vale negli stati 3 e 5 IorD= S3 S2 S S + S3 S2 S S S3 S2 S S IorD Altre uscite ricavate con considerazioni analoghe NB: campi Op don t care ( riga sta per 2 6 = 6 righe!) 5

51 5

52 SPECIFICA FUNZIONE DI STATO FUTURO NS: pari a quando stato futuro =, 3, 5, 7, 9 Dall analisi del diagramma di stato, si vede che ad essi si può arrivare: stato : da stato a prescindere da Op stato 3 : da stato 2 con Op = lw [] stato 5: da stato 2 con Op = sw [] stato 7: da stato 6 a prescindere da Op stato 9: da stato con Op = j [] Ciò corrisponde alla tabella di verità: OP5 OP OP3 OP2 OP OP S3 S2 S S NS X X X X X X X X X X X X NS = S3 S2 S S + OP5 OP OP2 OP OP S3 S2 S S + S3 S2 S S + OP5 OP OP3 OP2 OP OP S3 S2 S S 52

53 Con considerazioni analoghe si ricavano le altre uscite di stato futuro Abbiamo la specifica di entrambe le funzioni combinatorie Realizzazione in 2 (*2) modi alternativi: ) Tramite ROM - unica ROM per entrambe le funzioni - due ROM separate 2) Tramite porte logiche 53

54 ES: due ROM separate S3-- 6 ROM Segnali di uscita opcode S3-- 6 ROM 2 NS3-- Dimensione: 2 * * =,3 Kbit Nelle ROM ci sono comunque molti elementi duplicati: - molte combinazioni dell ingresso non si verificano (ROM le codifica tutte) p.es. ho bit per stati: 6-=6 combinazioni non si verificano - a volte le uscite non dipendono da [tutti] i valori dell ingresso. p.es. da stato si passa sempre a stato per qualunque valore di opcode, mentre ROM 2 duplica la parola NS () per 2 6 volte 5