Calcolatori Elettronici A a.a. 28/29 CPU mlticiclo: Esercizi assimiliano Giacomin
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
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 2 + + 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
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 +
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 + + 8*2 + ns = 2 ns fetch lettra R.File ALU scrittra R.File T = I * 2 ns 5
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
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
: 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
Riepilogo CPI T clock 2 ns T esecz I * 2 ns T istrzione-più-costosa 2 ns 2.89 2 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
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 2 26 28 Shift left 2 ALU control PC [-28] Zero ALU ALU reslt Jmp address [-] ALUOt 2 [5 ]
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
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 2 26 28 Shift left 2 ALU control PC [-28] Zero ALU ALU reslt Jmp address [-] ALUOt 2 [5 ] 2
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
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
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
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
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 =.8 6.8 < 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
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
) 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
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
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 2 26 28 Shift left 2 ALU control PC [-28] Zero ALU ALU reslt Jmp address [-] ALUOt 2 [5 ] 2
) 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
Altra tipologia: implementazione istrzioni nove 2
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
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 2 26 28 Shift left 2 ALU control PC [-28] Zero ALU ALU reslt Jmp address [-] ALUOt 2 [5 ] 25
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: 26 25 22 6 5 Op = j-novo rs X Ttti i bit a X: don t care + PC 26
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
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
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
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 26 25 22 6 5 Op rs rt offset + (cfr. anche lw)
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 2 26 28 Shift left 2 ALU control PC [-28] Zero ALU ALU reslt Jmp address [-] ALUOt 2 [5 ]
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 2 2 26 28 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
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
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.
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
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
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