Calcolatori Elettronici A a.a. 2008/2009

Transcript

1 Calcolatori Elettronici A a.a. 28/29 CPU mlticiclo: Esercizi assimiliano Giacomin

2 De tipologie di esercizi standard Calcolo delle prestazioni nei sistemi a singolo ciclo e mlticiclo (e confronto) Implementazione di istrzioni nove cominciamo dalla prima Formla fondamentale prestazioni (in ogni caso) T eseczione = #istrzioni * CPI * T clock 2

3 Calcolo CPI e Prestazioni nei sistemi a singolo ciclo e mlticiclo ) Calcolo prestazioni nei sistemi a singolo ciclo CPI = T clock = ma{t a + T k } ovvero la serie più lenta di operazioni atomiche [cammino critico] T eseczione = #istrzioni * CPI * T clock = #istrzioni * T clock 2) Calcolo CPI e prestazioni nei sistemi mlti-ciclo Dato n certo carico di lavoro con freqenze relative delle istrzioni f,, f n CPI = f *CPI + f 2 *CPI f n *CPI n T clock = ma{t,,t m } [operazioni atomiche esegite in n ciclo di clock] T eseczione = #istrzioni * CPI * T clock ) Confronto di prestazioni tra sistemi diversi [s n carico/prog. determinato] T eseczione T 2 eseczione = CPI *T clock CPI 2 *T 2 clock

4 Esercizio Si ipotizzi n carico di lavoro che preveda: lw: % sw: 2% Tipo-R: 22% beq: 5% j: 7% somma virgola mob: 7% moltipl. Virgola mob: 7% Esegite secondo le fasi viste Come Tipo-R ma ALU richiede operazioni in seqenza anziché Come Tipo-R ma 8 operazioni ALU Si spponga che le operazioni atomiche che coinvolgono le nità fnzionali principali (di ci si tiene conto per il calcolo dei tempi) richiedano: Unità di memoria (lettra e scrittra): Register File (lettra e scrittra): Operazione-ALU: 2 ns ns 2 ns Confrontare le prestazioni di na implementazione a ciclo singolo vs. mlti-ciclo (vincolo di non mettere in serie de operazioni atomiche) vs. mlti-ciclo in ci sono effettate in serie (nello stesso ciclo): - operazione ALU per prodrre n valore + scrittra del valore nel Register File - lettra dalla memoria di n valore +

5 Calcolo delle prestazioni nel caso a singolo ciclo (macchina ) CPI = T eseczione = I * T clock (I è il nmero di istrzioni) T clock corrisponde all istrzione più lnga che evidentemente è la UL in virgola mobile (cfr. esercizio sl processore a singolo ciclo) T clock = *2 + ns = 2 ns fetch lettra R.File ALU scrittra R.File T = I * 2 ns 5

6 Calcolo delle prestazioni nel caso mlticiclo 2 (acchina mlti-ciclo): in n ciclo di clock NO serie di operazioni atomiche T clock = 2ns (operazione ALU oppre accesso in memoria) CPI = somma pesata dei CPI singole istrzioni con le freqenze relative = (vedi lcido segente),89 T 2 = I *.89 * 2 ns = I * 9.78 ns 6

7 2 (acchina mlticiclo): CPI per istrzione Istrzione Fetch Lettra Registri/ ALU Accesso emoria Scrittra Registri CPI Decode lw 5 sw Tipo-R beq j ADD V. OB. 7 UL V. OB. 8 CPI =.*5 +.2* +.22* +.5* +.7* +.7*7 +.7* =.89 7

8 : in n ciclo di clock ho al più: lettra memoria ALU [2 ns] + scrittra Reg.File [ ns] T clock = ns CPI = per TIPO-R, lw e virgola-mobile CPI si ridce di Istrzione Fetch Lettra Registri/ Decode ALU [ev. Scr. Reg.] Accesso emoria [ev. Scr. Reg.] CPI lw sw Tipo-R beq j ADD V. OB. 6 UL V. OB. 8 CPI =.* +.2* +.22* +.5* +.7* +.7*6 +.7* =.22 T = I *.22 * ns = I * 2.66 ns 8

9 Riepilogo CPI T clock 2 ns T esecz I * 2 ns T istrzione-più-costosa 2 ns ns I * 9.78 ns *2 = 22 ns.22 ns I * 2.66 ns * = ns Confronto delle prestazioni T = I * 2 ns T 2 = I * 9.78 ns T = I * 2.66 ns T 2 = I * 9.78 ns 2 oltre 2 volte più veloce rispetto a 2 circa. volte più veloce rispetto a NB: la ridzione di CPI non paga rispetto all amento di T clock La macchina mlticiclo con divisione eqilibrata delle fasi è la più efficiente. Notare però che l istrzione più costosa (UL in V.OB.) è più veloce nell implementazione a singolo ciclo. 9

10 Domanda Come deve essere modificato il DataPath per implementare? PC Address Write data emory emdata [-26] [25 2] [2 6] [5 ] register [5 ] emory data register PCWriteCond PCWrite IorD em emwrite emtoreg Otpts Control ALUOp ALUSrcB ALUSrcA RegWrite IRWrite [25 ] Op [5 ] [5 ] PCSorce RegDst 6 register register 2 Registers Write register Write data Sign etend data data 2 2 Shift left 2 A B Shift left 2 ALU control PC [-28] Zero ALU ALU reslt Jmp address [-] ALUOt 2 [5 ]

11 Si tratta di collegare direttamente in serie - ALU a Register File (per scrivere in n registro il risltato di n operazione) linea di collegamento in scita alla ALU prima del registro ALUot - emoria a Register File (per scrivere in n registro il valore letto da em) elimino il registro DR collegando direttamente memoria a Reg.File RegWrite Registri indirizzo emoria emdata Registro letto Registro letto 2 Registro scritto Dato letto Dato letto 2... ALUot Dato scritto Dato scritto

12 odificando il Datapath completo rislta: PC Address Write data emory emdata [-26] [25 2] [2 6] [5 ] register [5 ] emory data register PCWriteCond PCWrite IorD em emwrite emtoreg Otpts Control ALUOp ALUSrcB ALUSrcA RegWrite IRWrite [25 ] Op [5 ] [5 ] PCSorce RegDst 6 register register 2 Registers Write register Write data Sign etend data data 2 2 Shift left 2 A B Shift left 2 ALU control PC [-28] Zero ALU ALU reslt Jmp address [-] ALUOt 2 [5 ] 2

13 Esercizio 2: dall appello 2 settembre 26 [ pnti] Si consideri la nota implementazione dell nità di controllo secondo la tecnica mlticiclo relativamente alle istrzioni IPS lw, sw, beq, j e TIPO-R [nel compito, il datapath è riportato in na figra]. Si spponga che le operazioni atomiche che coinvolgono le nità fnzionali principali (di ci si tiene conto per il calcolo dei tempi) richiedano: Unità di memoria (lettra e scrittra): Register File (lettra e scrittra): Operazione-ALU: Si ipotizzi che il carico di lavoro preveda in ogni caso, per le istrzioni beq e j, na percentale complessiva del %: f beq + f j = % Determinare le condizioni in ci n implementazione a singolo ciclo rislta più conveniente, in termini di prestazioni, rispetto a qella mlticiclo. Rispondere alla stessa domanda spponendo che il carico di lavoro preveda per i salti (condizionati e incondizionati) na percentale complessiva del 2% (al posto del %). Come si pò gistificare intitivamente il risltato? 2 ns ns 2 ns

14 Devo confrontare prestazioni a singolo ciclo vs. mlti-ciclo: - esprimo i tempi di eseczione nei de casi e li confronto - mi aspetto che le prestazioni mlti-ciclo siano migliori, a meno che l istrzione più onerosa (la lw) non sia troppo freqente rispetto al carico di lavoro (vedi le considerazioni alla fine del precedente esercizio). Prestazioni nel caso di singolo ciclo T clock CPI = - dovto all istrzione lw: 2 ns (fetch) + ns (Reg. file) + 2 ns (ALU) + 2 ns (emoria dati) + ns (Reg. file) = 8 ns T SC = I * 8 ns (I è il nmero di istrzioni) Prestazioni nel caso mlticiclo T clock = 2 ns (dovto all operazione più lnga: accesso a memoria o ALU) CPI = f lw *5 + f sw * + f TIPO-R * + f beq * + f j * T C = I * [f lw * + f sw *8 + f TIPO-R *8 + f beq *6 + f j *6] ns

15 Caso f beq + f j = % T SC < T C se e solo se I * 8 < I * [f lw * + f sw *8 + f TIPO-R *8 + f beq *6 + f j *6] cerco di raccogliere per esprimere f beq + f j =. 8 < f lw * + f sw *8 + f TIPO-R *8 + (f beq + f j )*6 8 < f lw * + f sw *8 + f TIPO-R *8 +.*6 7. < f lw * + f sw *8 + f TIPO-R *8 E adesso? Devo cercare di ottenere na sola incognita, che potrebbe essere f lw 5

16 7. < f lw * + f sw *8 + f TIPO-R *8 So che f lw + f sw + f TIPO-R + f j + f beq = f beq + f j =. f lw + f sw + f TIPO-R =.9 7. < f lw * + (f sw + f TIPO-R )*8.9 - f lw 7. < f lw * + (.9 - f lw )*8 f lw >.2/2 =. Prestazioni a singolo ciclo prevalgono qando lw ha freqenza maggiore del % (NB: corrisponde al tipo di risltato che ci aspettiamo) 6

17 Caso f beq + f j = 2% Intitivamente: cresce la freqenza delle istrzioni con tempi di eseczione inferiore ci aspettiamo che la tecnica mlticiclo prevalga ancora di più, ovvero che la percentale di f lw per ci singolo ciclo è conveniente cresca. Rifacendo i calcoli con il novo vincolo rislta: 8 < f lw * + f sw *8 + f TIPO-R *8 +.2*6 6.8 < f lw * + f sw *8 + f TIPO-R *8 con f lw + f sw + f TIPO-R = < f lw * + (.8 f lw )*8. < f lw *2 f lw >./2 =.2 In qesto caso, prestazioni a singolo ciclo prevalgono qando lw ha freqenza maggiore del 2% 7

18 Esercizio Si ipotizzi n carico di lavoro che preveda: lw: 25% sw: % Tipo-R: 52% beq: % j: 2% Si spponga che le operazioni atomiche che coinvolgono le nità fnzionali principali (di ci si tiene conto per il calcolo dei tempi) richiedano: Unità di memoria (lettra e scrittra): Register File (lettra e scrittra): Operazione-ALU: 2 ns ns ns Determinare le prestazioni mlti-ciclo (non mettere in serie de operazioni atomiche) Delineare, se possibile, na modifica al controllo e al data path in grado di migliorare l efficienza della solzione precedente (sempre nell ambito del controllo mlti-ciclo) Confrontare le prestazioni delle de solzioni ottente 8

19 ) Controllo mlti-ciclo sale T = #istrzioni * CPI * T clock T clock = 2ns (accesso in memoria) Istrzione Fetch Lettra Registri/Decode ALU Accesso emoria Scrittra Registri CPI lw 5 sw Tipo-R beq j CPI =.25*5 +.* +.52* +.* +.2* =.2 T = I *.2 * 2 ns = I * 8.2 ns 9

20 2) Solzione più efficiente Unità di memoria (lettra e scrittra): Register File (lettra e scrittra): Operazione-ALU: 2 ns ns ns Operazione ALU e accesso a Register File possono essere messe in serie (diminendo CPI) senza incrementare T clock!!! Istrzione Fetch Lettra Registri/Decode ALU Accesso emoria Scrittra Registri CPI lw 5 sw Tipo-R beq j 2

21 CPI =.25*5 +.* +.52* +.* +.2* =.6 e qindi rislta T 2 = I *.6 * 2 ns = I * 7.2 ns Ovviamente, occorre modificare leggermente il DataPath PC Address Write data emory emdata [-26] [25 2] [2 6] [5 ] register [5 ] emory data register PCWriteCond PCWrite IorD em emwrite emtoreg Otpts Control ALUOp ALUSrcB ALUSrcA RegWrite IRWrite [25 ] Op [5 ] [5 ] PCSorce RegDst 6 register register 2 Registers Write register Write data Sign etend data data 2 2 Shift left 2 A B Shift left 2 ALU control PC [-28] Zero ALU ALU reslt Jmp address [-] ALUOt 2 [5 ] 2

22 ) Confronto prestazioni T = I * 8.2 ns T 2 = I * 7.2 ns 2 è circa, volte più veloce NB: Perché non la solzione segente? Istrzione Fetch Lettra Registri/Decode ALU Accesso emoria Scrittra Registri CPI lw 5 sw Tipo-R beq j pensarci 22

23 Altra tipologia: implementazione istrzioni nove 2

24 Esercizio Si consideri il DataPath per l implementazione mlticiclo del IPS [che avete a disposizione!]. Si consideri l ipotetica istrzione assembler: j (rs) ; PC rs la qale esege n salto incondizionato all indirizzo specificato dal registro rs. Per qesta istrzione: - si dica se (e come) deve essere modificato il datapath per permetterne l implementazione rispettando il vincolo sale s elementi fnzionali; - spponendo che vi sia n codice operativo libero (non impegnato in altre istrzioni) si fornisca n possibile formato della corrispondente istrzione macchina e si specifichi come deve essere modificato il diagramma a stati finiti dell nità di controllo per implementarla; - spponendo T clock = 2ns, calcolare il tempo di eseczione della nova istrzione. 2

25 j (rs) Una prima solzione: modificare il datapath aggingendo in ingresso al UX che determina il valore da scrivere in PC il registro A [che contiene rs] Il controllo è modificato di consegenza (eseczione simile a j normale) PC Address Write data emory emdata [-26] [25 2] [2 6] [5 ] register [5 ] emory data register PCWriteCond PCWrite IorD em emwrite emtoreg Otpts Control ALUOp ALUSrcB ALUSrcA RegWrite IRWrite [25 ] Op [5 ] [5 ] PCSorce RegDst 6 register register 2 Registers Write register Write data Sign etend data data 2 2 Shift left 2 A B Shift left 2 ALU control PC [-28] Zero ALU ALU reslt Jmp address [-] ALUOt 2 [5 ] 25

26 Una seconda solzione: non modificare il datapath Osservando il datapath, si vede che: - è possibile forzare la scrittra di PC con l scita del UX [ALUot ALU indirizzo j] ponendo PCWrite = consideriamo ALU (è possibile mettere in serie ALU e PC) - in ingresso alla ALU, il primo operando deve essere necessariamente A=rs; per ottenere rs in scita alla ALU, l nica possibilità è avere sign-etend(offset) [ev. shiftato di 2 bit] prchè offset= e forzare ALU ad effettare na somma: rs + sign-etend() = rs E possibile implementare l istrzione con il formato Tipo-I: Op = j-novo rs X Ttti i bit a X: don t care + PC 26

27 Vediamo il controllo con il diagramma a stati, partendo da qello originario 2 emory address comptation ALUSrcA = ALUSrcB = ALUOp = Start fetch em ALUSrcA = IorD = IRWrite ALUSrcB = ALUOp = PCWrite PCSorce = 6 (Op = 'LW') or (Op = 'SW') Eection ALUSrcA = ALUSrcB = ALUOp= 8 (Op = R-type) Branch completion ALUSrcA = ALUSrcB = ALUOp = PCWriteCond PCSorce = decode/ register fetch (Op = 'BEQ') 9 ALUSrcA = ALUSrcB = ALUOp = (Op = 'J') Jmp completion PCWrite PCSorce = Op = j-novo ALUSrcA = ALUSrcB = ALUOp = (somma) PCSorce= PCWrite (Op = 'LW') em IorD = emory access RegDst = RegWrite emtoreg = (Op = 'SW') 5 Write-back step emwrite IorD = emory access 7 RegDst = RegWrite emtoreg = R-type completion : fetch : decode e carica A = rs, B = rt : ALU: A + signet(offs) PC ALU 27

28 NB: in pratica abbiamo modificato l ltimo stato dell istrzione j in modo da selezionare l scita della ALU (che calcola l indirizzo) al posto dell sale indirizzo derivante dall offset a 26 bit. Notare che in qesto stato il cammino creato è A-IR ALU PC: come nel caso di beq, non poniamo in serie più di n elemento critico Tempo di eseczione: * 2 ns = 6 ns [come j e beq!] Notare che è possibile implementare l istrzione più generale (stesso formato Tipo-I) j offset(rs) // (il campo offset pò essere diverso da zero) dove però è più ragionevole spporre che offset sia espresso in parole di memoria! A qesto scopo, basta forzare ALUSrcB= per sommare a rs offset esteso e scalato. 28

29 Esercizio 5: dall appello lglio 25 [6 pnti] Si considerino, mostrati nelle figre riportate di segito, il datapath ed il diagramma a stati finiti che specifica l nità di controllo secondo la tecnica a mlticiclo relativamente alle istrzioni IPS lw, sw, beq, j ed alle istrzioni di tipo-r. Si vole implementare na nova istrzione del tipo: addmem rt, offset(rs) // rt rt + [rs+offset] che somma al registro rt il contento della locazione di memoria indirizzata da rs+offset, dove offset è n nmero a 6 bit con segno specificato nell istrzione macchina (cfr. le istrzioni lw e sw). Ricordando i tre formati di codifica delle istrzioni (riportati di segito) si chiede di: - riportare il formato della nova istrzione macchina - riportare, nella corrispondente figra, le modifiche necessarie al datapath - estendere il diagramma degli stati per implementare la nova istrzione 29

30 addmem rt, offset(rs) Formato devo rappresentare: - il registro rs - il registro rt - offset (a 6 bit) che va sommato a rs Sicramente verrà sato il Tipo-I Op rs rt offset + (cfr. anche lw)

31 odifica al DataPath addmem rt, offset(rs) : è na sorta di lw + add PC Address Write data emory emdata [-26] [25 2] [2 6] [5 ] register [5 ] emory data register PCWriteCond PCWrite IorD em emwrite emtoreg Otpts Control ALUOp ALUSrcB ALUSrcA RegWrite IRWrite [25 ] Op [5 ] [5 ] PCSorce RegDst 6 register register 2 Registers Write register Write data Sign etend data data 2 2 Shift left 2 A B Shift left 2 ALU control PC [-28] Zero ALU ALU reslt Jmp address [-] ALUOt 2 [5 ]

32 odifica al DataPath addmem rt, offset(rs) : è na sorta di lw + add PC Address Write data emory emdata [-26] [25 2] [2 6] [5 ] register [5 ] emory data register PCWriteCond PCWrite IorD em emwrite emtoreg Otpts Control ALUOp ALUSrcB ALUSrcA RegWrite IRWrite [25 ] Op [5 ] [5 ] PCSorce RegDst 6 register register 2 Registers Write register Write data Sign etend data data 2 2 Shift left 2 A B Shift left 2 ALU control PC [-28] Zero ALU ALU reslt Jmp address [-] ALUOt 2 [5 ] Aggingiamo ingresso al UX, con label 2 per non modificare la specifica delle precedenti istrzioni 2

33 Possiamo allora effettare le stesse operazioni della lw ed aggingere in coda de stati 2 (Op = addmem ) or emory address comptation ALUSrcA = ALUSrcB = ALUOp = (Op = 'LW') emory access (Op = 'SW') 5 Start emory access fetch em ALUSrcA = IorD = IRWrite ALUSrcB = ALUOp = PCWrite PCSorce = 6 (Op = 'LW') or (Op = 'SW') 7 or (Op = addmem ) Eection ALUSrcA = ALUSrcB = ALUOp= 8 R-type completion (Op = R-type) Branch completion ALUSrcA = ALUSrcB = ALUOp = PCWriteCond PCSorce = (Op = 'BEQ') decode/ register fetch 9 ALUSrcA = ALUSrcB = ALUOp = (Op = 'J') Jmp completion PCWrite PCSorce = emtoreg= RegDst= RegWrite rt ALUOt DR [rs+offset] (Op = lw ) em IorD = RegDst = RegWrite emtoreg = Write-back step emwrite IorD = (Op = addmem ) RegDst = RegWrite emtoreg = ALUSrcA = 2 ALUSrcB = ALUOp = (somma) ALUOt DR+rt

34 Esercizio 6: dallo stesso appello [ pnti] Si consideri l esercizio risolto al pnto precedente; si assma n carico di lavoro che preveda la segente distribzione delle istrzioni: lw: 2 % sw: 2 % Tipo-R: % beq: % j: % addmem: % Si spponga che le operazioni atomiche delle nità fnzionali principali richiedano: Unità di memoria (lettra e scrittra): 2 ns Register File (lettra e scrittra): ns Operazione ALU: 2 ns Si confrontino le prestazioni (in termini di rapporto tra tempi di eseczione) di n ipotetica implementazione a singolo ciclo rispetto all implementazione mlticiclo individata al pnto precedente.

35 Singolo ciclo T clock è valtato sll istrzione più lnga; è facile rendersi conto che qesta è addmem, il ci tempo di eseczione è maggiore della lw che era già l istrzione più lnga In particolare: Fetch: 2 ns Prelievo rs: ns ALU (rs+offset): 2 ns Accesso em: 2 ns ALU(rt+[ ]): 2 ns Scrittra rt: ns ns T eseczione = #istrzioni * T clock = #istrzioni * 5

36 lticiclo T eseczione = #istrzioni * CPI * T clock T clock è valtato sll operazione più lnga esegita in n ciclo di clock; le operazioni più lnghe (accesso a memoria e so ALU) drano 2 ns T clock = 2 ns CPI va valtato sl carico di lavoro, tenendo presente che addmem ha 6 cicli: CPI =,2 * 5 +,2 * +, * +, * +, * +, * 6 =,2 QUINDI SI OTTIENE: T eseczione = #istrzioni *,2 * 2 = #istrzioni * 8, 6

37 Confronto Prestazioni Singolo Ciclo vs. lticiclo T singolo = #istrzioni * T mlti = #istrzioni * 8, Evidentemente la realizzazione mlticiclo ha prestazioni migliori. In particolare rislta: T singolo #istrzioni * = =,9 T mlti #istrzioni * 8, 7