Calcolatori Elettronici

Transcript

1 Calcolatori Elettronici Tecniche Pipeline: Gestione delle criticità e delle eccezioni Massimiliano Giacomin 1

2 Pipeline: i problemi Idealmente, il throughput è di una istruzione per ciclo di clock! Purtroppo, in realtà esistono diverse problematiche: - Criticità strutturali: HW non può eseguire una certa combinazione di istruzioni [es: una stessa risorsa è contesa da parte di più istruzioni] - Criticità sui dati: un istruzione dipende dal risultato di un istruzione precedente che si trova ancora nella pipeline. E necessario attendere che il risultato sia pronto. - Criticità sul controllo: l istruzione successiva ad un istruzione di salto deve attendere l esecuzione della precedente, per sapere se/dove saltare. 2

3 CRITICITA STRUTTURALI E STALLO 3

4 CASO 1 - unità funzionale contesa in due stadi diversi (es: memoria) controllo P C F: fetch PC=PC+4 D: Decodifica Prelievo operandi O: esegui l operazione W: scrivi i risultati Cache istruzioni e dati I1 I2 I3 I4 I5 I6 C1 C2 C3 C4 C5 C6 C7 C8 F1 D1 O1 W1 F2 D2 O2 W2 F3 D3 O3 W3 F4 D4 O4 W4 F5 D5 O5 W5 F6 D6 O6 W6 Tempo cicli di clock istruzioni 4

5 Conflitto per tutte le istruzioni che accedono in MEM (es: I 1, I 2, I 3 ) RIMEDIO: DIVIDERE LA MEMORIA IN DUE! controllo P C F: fetch PC=PC+4 D: Decodifica Prelievo operandi O: esegui l operazione W: scrivi i risultati Cache istruzioni Cache dati NB: questa è la soluzione adottata nel MIPS didattico [cfr. Patterson & Hennessy] In questo modo nel MIPS si evitano le criticità strutturali (a parte miss) Altro effetto: aumento capacità di trasferimento cache 5

6 CASO 2 - uno stadio richiede più cicli di clock per una istruzione (realizzazione multiciclo: risparmio hw + limitazione numero di stadi) Esempio I2: mul R5,R7,R6 O richiede due cicli di clock aggiuntivi I1 I2 I3 I4 I5 I6 C1 C2 C3 C4 C5 C6 C7 C8 F1 D1 O1 W1 F2 D2 O O O2 W2 F3 D D D3 O3 F F F4 D4 W3 O4 W4 Cicli di clock istruzioni Durante il ciclo di clock 5 e 6: O non va avanti con I 2 Lo stadio D rimane per I 3 e non accetta I 4 (O impegnato da I 2 ) F rimane per I 4 e non accetta nuova istruzione 6

7 La pipeline può essere pensata come un registro a scorrimento : - al termine di ogni ciclo, ogni istruzione si sposta in avanti di uno stadio (informazioni contenute in ogni registro interstadio elaborate e memorizzate nel registro interstadio successivo) - se uno stadio richiede più cicli di clock, si dice che la pipeline entra in stallo per quel numero di cicli: l istruzione nello stadio precedente (NB: seguente nel programma!) non può entrare finché lo stadio non ha terminato il suo compito (e il registro ricomincia a scorrere ) Stadio bloccato e i precedenti non accettano nuove istruzioni - nel caso precedente stallo di 2 cicli di clock 7

8 CASO 3 - Miss di cache (fallimenti di accesso alla memoria cache) - In fase di fetch (memoria istruzioni) o di accesso alla memoria da parte di istruzioni lw e sw (memoria dati) Esempio - 3 cicli di penalità nel fetch dell istruzione I 2 I1 I2 I3 I4 I5 I6 C1 C2 C3 C4 C5 C6 C7 C8 F1 D1 O1 W1 F F F F2 D2 F3 O2 D3 W2 O3 W3 istruzioni Durante il ciclo di clock 3, 4, 5: lo stadio F non va avanti con I 2 Lo stadio D non fa alcuna operazione (no dati su cui lavorare) Lo stadio F non accetta nuove istruzioni 8

9 Stallo: concetti generali (1) 1. Durante un ciclo di clock C i, un certo stadio S non può completare la sua operazione e necessita quindi di un ciclo addizionale successivo C i+1 [es. precedenti: F per miss di cache, O per operazioni aritmetiche lunghe ] P C F S-1 S S+1 S+2 Registro interstadio S-1 / S non sovrascritto da stadio S-1 nel prossimo fronte del segnale di clock (alla fine del ciclo C i ) [Þ durante il ciclo successivo i dati in ingresso restano immutati] 9

10 Stallo: concetti generali (2) 2. Gli stadi precedenti devono mantenere nel prossimo ciclo di clock C i+1 le istruzioni correnti: l operazione nello stadio S-1 non può procedere; IDEM per tutti gli stadi precedenti S-2 F P C F S-1 S S+1 S+2 registri interstadio precedenti (incluso PC) non sovrascritti nel fronte successivo 10

11 Stallo: concetti generali (3) 3. Nel ciclo successivo Ci+1 lo stadio S+1 non può ricevere dati significativi: è necessario fare in modo che sia esso sia gli stadi successivi non alterino in modo indefinito registri o memoria P C F S-1 S S+1 S+2 al fronte di clock successivo nel registro interstadio S/S+1: segnali di controllo che corrispondono a non effettuare alcuna operazione Creazione di una bolla che attraverserà tutta la pipeline, a partire da stadio S+1 fino all ultimo stadio, senza alcun effetto 11

12 Stallo: realizzazione circuitale controllo 0 P C F D S S+1... Write Write Write Unità di rilevamento criticità 12

13 Spiegazione lucido precedente Sulla base di segnali dallo stadio S: in C i rilevata necessità di stallo di un ciclo di clock Per porre la pipeline in stallo, durante il ciclo di clock C i : - i segnali Write (normalmente a 1) sono posti a 0, impedendo la scrittura dei registri interstadio precedenti Þ nel ciclo di clock C i+1 nulla cambia per gli stadi F, S - nel registro interstadio S/S+1 segnali di controllo per formare una bolla (NB: che si propagherà negli stadi successivi) Nota: stallo di n cicli di clock (istruzione in S per n+1 cicli) Durante ognuno dei primi n cicli si rileva necessità di stallo (ciclo successivo addizionale) e la pipeline viene posta in stallo sullo stadio S Durante l ultimo ciclo no stallo Þ la pipeline torna a procedere regolarmente 13

14 ESEMPIO CASO 2: stallo di due cicli con S=O (istruzione I 2 ) I1 I2 I3 I4 I5 I6 C1 C2 C3 C4 C5 C6 C7 C8 F1 D1 O1 W1 F2 D2 O O O2 W2 F3 D D D3 F F F4 O3 D4 W3 O4 Tempo cicli di clock W4 istruzioni C4 F D O W I 4 I 3 I 2 I 1 C5 I 4 I 3 I 2 B C6 I 4 I 3 I 2 B C7 I 5 I 4 I 3 I 2 14

15 ESEMPIO BIS CASO 2: stallo di due cicli con S=O (istruzione I 2 ) con pipeline a 5 stadi (F-D-O-M-W) I1 I2 I3 I4 I5 I6 C1 C2 C3 C4 C5 C6 C7 C8 F1 D1 O1 M1 W1 F2 D2 O O O2 M2 F3 D D D3 O3 F F F4 D4 W2 M3 O4 Tempo cicli di clock W3 M4 istruzioni C4 F D O M W I 4 I 3 I 2 I 1 C5 I 4 I 3 I 2 B I 1 C6 I 4 I 3 I 2 B B C7 I 5 I 4 I 3 I 2 B 15

16 Spiegazione lucido precedente L unità di rilevazione criticità sulla base dei segnali provenienti dallo stadio O rileva la necessità di mettere in stallo la pipeline (S=O) Per due cicli di clock: - Impedisce la scrittura di PC e dei due buffer F/D e D/O (attesa degli stadi di fetch, decode, execute) - Forza i segnali di controllo del buffer O/M in modo da mettere una bolla nello stadio M (impedendo nei cicli di clock successivi la scrittura di registri e memoria) 16

17 ESEMPIO CASO 3: stallo di tre cicli con S = F (istruzione I 2 ) I1 I2 I3 I4 I5 I6 C1 C2 C3 C4 C5 C6 C7 C8 F1 D1 O1 W1 F F F F2 D2 F3 O2 D3 W2 O3 W3 istruzioni C2 F D O W I 2 I 1 C3 I 2 B I 1 C4 I 2 B B I 1 C5 I 2 B B B C6 I 3 I 2 B B 17

18 Spiegazione lucido precedente L unità di rilevazione criticità sulla base dei segnali provenienti dalla cache rileva la necessità di mettere in stallo la pipeline (S=F) Fino a quando la cache non fornisce il dato (per tre cicli di clock): - Impedisce la scrittura di PC mettendo in attesa lo stadio Fetch - Forza i segnali di controllo del buffer F/D in modo da mettere una bolla nello stadio D (impedendo nei cicli di clock successivi la scrittura di registri e memoria) 18

19 NB: Stalli su più stadi controllo 0 0 P C F D S S+1 Write 1 Unità di rilevamento criticità Unità di rilevamento criticità Write 2 19

20 ORGANIZZAZIONE HW FINO A QUESTO PUNTO Unità di controllo (gestisce il controllo della pipeline ma non le criticità). Unità di rilevamento delle criticità (gestiscono le criticità, finora solo strutturali, mettendo in stallo la pipeline). In linea teorica, tutte le criticità che vedremo potrebbero essere gestite in questo modo (soltanto mediante stallo), tuttavia questo approccio è di fatto inefficiente. 20

21 Influenza degli stalli sulle prestazioni S 1 S 2 S 3 S 4 S 5 Stallo di 1 ciclo: 1 ciclo in più rispetto a CPI=1 S 1 S 2 S 3 S 3 S 4 S 5 S 1 S 2 S 2 S 3 S 4 S 5 S 1 S 1 S 2 S 3 S 4 S 5 S 1 S 2 S 3 S 4 S 5 T esecuzione = #istruzioni * CPI * T clock CPI = CPI ideale + δ STALLI = 1 + f Iconstallo *C stallo-iconstallo Throughput pipeline = 1/CPI (espresso come istruzioni/ciclo) 1/(CPI*T clock ) (espresso come istruzioni/sec) 21

22 PIPELINE: CRITICITA SUI DATI 22

23 Esempio addi $s0, $zero, 5 # s0=5 addi $s0, $s0, 3 addi $s1, $s0, 4 # s0=s0+3 # s1=s0+4 Un dato sorgente è risultato di istruzione precedente Con multiciclo: $s1=12 Con pipeline a 5 stadi addi $s0, $s0, 3 addi $s1, $s0, 4 F D E M W F D E M W Risulta s1= 9 NB: non accade ad esempio con addi $s1, $s0, 3 addi $s2, $s0, 5 23

24 TECNICA 1: gestione dipendenze via software Esempio con pipeline a 4 stadi add $1, $2, $3 F D add W Solo dal ciclo di clock 5 è disponibile $1 aggiornato sub $2, $1, $4 F D sub W Il compilatore può gestire la dipendenza inserendo due istruzioni indipendenti tra add e sub [eventualmente due istruzioni NOP] add $1, $2, $3 F D add W NOP F D O W NOP sub $2, $1, $4 F D O W F D sub W PRELIEVO $1 aggiornato 24

25 TECNICA 2: gestione dipendenze con stallo I1: add $1, $2, $3 I2: sub $2, $1, $4.. controllo P C F: fetch PC=PC+4 ma da C3 a C5 PC= ind. I 3 D: decode Prelievo operandi O: esegui l operazione W: scrivi i risultati I1 I2 I3 I4 I5 I6 C1 C2 C3 C4 C5 C6 C7 C8 F1 D1 O1 W1 F2 D2 D2 D2 O2 W2 F3 F3 F3 D3 O3 W3 F4 D4 O4 W4 F5 D5 O5 F6 D6 Tempo cicli di clock istruzioni Rilevazione criticità: $1 non aggiornato Dato aggiornato in $1 (scritto da W1 alla fine di C4) 25

26 Realizzazione circuitale controllo 0 P C F: fetch Alimenta l istruzione D: decode Prelievo operandi O: esegui l operazione W: scrivi i risultati Write Write criticità NB: ovviamente, per gestire eventuali criticità strutturali servono tutte le opportune unità di gestione 26

27 Spiegazione lucidi precedenti Stallo in stadio Decode: istruzione dipendente preleva operandi Rilevamento criticità: - operando da prelevare operando destinazione di istruzione ancora in pipeline - sulla base di: campi istruzioni dipendente (stadio D) + registri interstadio successivi (istruzioni precedenti ancora in pipeline) Numero di cicli di stallo in D: se un istruzione ancora in pipeline deve aggiornare un operando sorgente da leggere in D l istruzione in D stalla per un (ulteriore) ciclo Þ esecuzione istruzione dipendente procede con lettura operando solo dopo che sia stato aggiornato da istruzione precedente 27

28 TECNICA 3: propagazione dei dati I1: add $1, $2, $3 I2: sub $2, $1, $4.. IDEA: quando I2 deve utilizzare $1 in O valore aggiornato già disponibile in RSLT controllo P C F: fetch PC=PC+4 D: decode Prelievo operandi SRC1 SRC2 Esegui Operaz. RSLT W: scrivi i risultati I 2 I 1 28

29 TECNICA 3: propagazione dei dati I1: add $1, $2, $3 I2: sub $2, $4, $1.. controllo POSSIBILE PROPAGARLO DA REGISTRO INTERSTADIO SUCCESSIVO! P C F: fetch PC=PC+4 D: decode Prelievo operandi SRC1 SRC2 Esegui Operaz. RSLT W: scrivi i risultati I1 I2 I3 I4 C1 C2 C3 C4 C5 C6 C7 C8 F1 D1 $2+$3 $1 F2 D2 $4 - $1 W2 F3 D3 O3 W3 F4 D4 O4 W4 Tempo in cicli di clock istruzioni SI EVITA STALLO DI DUE CICLI DI CLOCK! 29

30 Realizzazione circuitale (CON PIPELINE A 5 STADI) controllo P C F: fetch PC=PC+4 D: decode Prelievo operandi SRC1 SRC2 EX: Esegui Operazione RSLT M: accesso memoria RSL2WRIT E W: scrivi i risultati Controllo mux Unità di propagazione 30

31 Spiegazione lucido precedente Unità di propagazione: - sulla base del registro interstadio in stadio EX (dove serve il dato) e dei valori dei registri successivi (istruzioni precedenti ancora in pipeline) determina se il dato è obsoleto (ovvero: verrà sovrascritto da istruzioni precedenti ancora in pipeline) - se c è dipendenza da risolvere asserisce i segnali nei mux per propagazione: la ALU preleva operando dipendente non da SRCi, ma da RSLT - NB: tutto ciò si intende replicato per ogni ingresso della ALU Propagazione effettuata nello stadio in cui un dato è usato (EX in questo caso), non in stadi precedenti: aspettando il più possibile le istruzioni precedenti aumentano le possibilità che il dato sia stato prodotto! 31

32 DIPENDENZA DA UNO STESSO OPERANDO PRESENTE IN PIU STADI I 5 I 4 I 3 esegui ottimistiche (alimenta operandi) SRC1 SRC2 Esegui Operazione Controllo mux RSLT Unità di propagazione Il dato da propagare è quello dell istruzione più recente, ovvero la più vicina tra quelle precedenti (I 4 ). Questa si trova nello stadio più a sinistra (il meno avanzato) Vince il dato dello stadio meno avanzato! (il rosso nel caso in figura) Es. add R2, R3, R4 add R2, R5, R6 add R4, R3, R2 I 3 I 4 I 5 dipendenze 32

33 PROPAGAZIONE IN GENERALE (A) I n-2 F D... S S W S +1 In registri interstadio successivi: istruzioni precedenti nel codice I n-1 F D... S S W S +1 I n F D... S S +1 S W Prelievo dato (obsoleto) Utilizzo dato Il dato necessario che I n usa in S è prelevato dal registro interstadio (tra i successivi) in cui è presente l istruzione che lo ha prodotto 33

34 PROPAGAZIONE IN GENERALE (B) Possono esserci più stadi in cui si utilizzano i dati, p.es. con pipeline a 5 stadi: - stadio E: operandi ALU - stadio M: valore registro da scrivere in memoria Talvolta l hardware prevede una sola unità di propagazione nel primo stadio in cui i dati vengono utilizzati (con pipeline a 5 stadi in E) un dato propagato in uno stadio S può essere utilizzato in uno stadio successivo S+i ES: add $t1, $s2, $s3 sw $t1, 20($s1) // valore $t1 propagato (sostituito) in E, // portato avanti e utilizzato in M 34

35 UN ESEMPIO ERRATO P C F: fetch alimenta istruzione D: decode Prelievo operandi SRC1 SRC2 Esegui Operazione RSLT M: accesso memoria RSL2WRIT E W: scrivi i risultati Controllo mux Unità di propagazione Esempio: add $s0, $s1, $s2 lw $s1, 10($t0) Se l istruzione nello stadio E dipende da quella che si trova nello stadio MEM (per il dato prelevato dalla memoria) sembra di poter propagare da uscita memoria Ma avrei in serie memoria e ALU!!! Allungamento del periodo di clock! 35

36 ERRORE COMUNE NEGLI ESERCIZI I valori sono propagati da un registro interstadio, MAI dall uscita di un elemento combinatorio critico : non allungare T clock! 36

37 Esempio corretto nel caso di pipeline a 5 stadi P C F: fetch alimenta istruzione D: decode Prelievo operandi SRC1 SRC2 Esegui Operazione RSLT M: accesso memoria RSL2WRIT E W: scrivi i risultati Controllo mux Unità di propagazione Esempio: add $s0, $s1, $s2 BOLLA lw $s1, 10($t0) Se l istruzione nello stadio E dipende da quella che si trova nello stadio MEM (per il dato prelevato dalla memoria) è purtroppo necessario uno stallo! (si parla di criticità carica e usa ) 37

38 Il quadro globale Unità di controllo: determina nello stadio D i segnali di controllo da assegnare al buffer interstadio D/D+1 Unità di propagazione: risolve alcune dipendenze anticipando gli operandi (posta nello stadio in cui si usano, non prima!) Unità di rilevamento delle criticità: gestisce le criticità strutturali e le criticità sui dati che non sono risolte dalla propagazione [è possibile identificarle già in stadio Decode, poiché le istruzioni precedenti sono tutte negli stadi successivi] NB: se non si usasse la propagazione l unità di rilevamento delle criticità sarebbe progettata in modo da riconoscere più criticità: si tornerebbe al caso rimedio con solo stallo. 38

39 Esempio di gestione di criticità mediante stallo e successiva propagazione Pipeline a 5 stadi [MIPS] e uso dell istruzione lw [MIPS] lw $s2, 20($s1) F D 20+$s1 Read W and $s4, $s2, $s5 F D EX(Ù) MEM W Nello stadio Decode, si rileva che l istruzione and non potrà gestire la dipendenza con la propagazione Þstallo di un ciclo di clock, poi la propagazione gestirà la dipendenza Nota: questo tipo di criticità viene chiamata carica-e-usa 39

40 Altro esempio: pipeline più lunga (6 stadi) I 1 I 2 F D O 1 O 2 O 3 W F D O 1 O 2 O 3 W Il dato è prodotto in O 3 da I 1 e utilizzato da I 2 in O 1 : con propagazione si riduce stallo di due cicli di clock ma è inevitabile stallo di 2 cicli. NB: la pipeline può essere dotata di più unità di propagazione in corrispondenza degli stadi in cui si usano i valori degli operandi per evitare alcuni cicli di stallo (VEDERE ESERCIZI) 40

41 L ESEMPIO DEL MIPS Scelte progettuali (non univoche) - pipeline a 5 stadi - una sola unità di propagazione verso lo stadio EX (ALU per TIPO-R, calcolo indirizzo lw e sw, confronto operandi beq) in grado di propagare i dati dai registri EX/MEM e MEM/WB Vediamo nell ordine: - unità di propagazione (quali criticità risolve?) - unità di gestione delle criticità (quali criticità deve gestire con stallo?) 41

42 Unità di propagazione verso E ForwardA EX/MEM.RegWrite MEM/WB. RegWrite sign-extend ForwardB 42

43 Spiegazione lucido precedente IF ID EX MEM WB I n I n-1 I n-2 L unità di propagazione verso lo stadio EX riceve in ingresso: - i valori dal registro ID/EX da cui può riconoscere quali operandi usa I n - i valori da EX/MEM da cui può riconoscere se I n-1 scrive in destinazione (EX/MEM.RegWrite=1) e qual è la destinazione di I n-1 (EX/MEM.RegisterRd) - i valori da MEM/WB da cui può riconoscere se I n-2 scrive in destinazione (MEM/WB.RegWrite=1) e qual è la destinazione di I n-2 (MEM/WB.RegisterRd) Se una delle due istruzioni precedenti I n-1 e I n-2 scrive in un registro destinazione pari ad un registro sorgente (di I n ) questo viene propagato dal registro interstadio 43

44 COMPLICAZIONI DA GESTIRE IF ID EX MEM WB I n I n-1 I n-2 - come visto, il dato da I n-2 (ovvero da MEM/WB) va propagato solo se non deve essere propagato anche da I n-1 (EX/MEM): l istruzione più recente vince! - COMPLICAZIONE DOVUTA AL REGISTRO $0 (ovvero $zero): nel MIPS il registro $0 può essere utilizzato come destinazione, ma il suo valore non cambia e rimane 0 (il Register File restituisce sempre valore nullo!) Se il registro interessato è $0 (l istruzione I n usa $0 come operando, una istruzione precedente scrive un valore nel registro $0) allora il propagato sarebbe sbagliato (avrei il risultato di una istruzione precedente che in generale è non nullo), quello letto da Reg. File è corretto (nullo)! 44

45 Controllo del primo ingresso della ALU ( rs ): if (EX/MEM.RegWrite and EX/MEM.RegisterRd < > 0 and EX/MEM.RegisterRd = ID/EX.RegisterRs) then ForwardA = 10 (2 10 ) Propagazione da EX/MEM if (MEM/WB.RegWrite and MEM/WB.RegisterRd < > 0 and MEM/WB.RegisterRd = ID/EX.RegisterRs and not (EX/MEM.RegisterRd = ID/EX.RegisterRs and EX/MEM.RegWrite) ) then ForwardA = 01 (1 10 ) Propagazione da MEM/WB e analogamente per il secondo ingresso ( rt ) 45

46 UNITA DI GESTIONE CRITICITA MIPS: I COMPITI Vediamo cosa succede quando un istruzione I n si trova in D: NB: - le uniche istruzioni che alterano la destinazione sono TIPO-R e lw - le istruzioni TIPO-R producono il dato nello stadio E, lw nello stadio M I n-4 F D E M W Questa e le precedenti non generano criticità! I n-3 F D E M W Risolta con propagazione sul Register File (vedi dopo)! I n-2 F D E M W Quando I n è in E, il dato è disponibile in M/W I n-1 F D E M W Tipo-R: quando I n è in E, dato è disponibile in E/M (propagazione) lw: quando I n è in E, il dato non è disponibile (si sta leggendo dalla memoria): stallo un ciclo! I n F D E M W 46

47 NB: l unità di propagazione gestisce la dipendenza rispetto a due istruzioni precedenti (infatti propago da due registri interstadio: EX/MEM e MEM/WB). Come gestire la dipendenza dall istruzione che precede di tre posizioni? Altro accorgimento usato nel MIPS: scrive $s1 I 1 F D E M W I 2 I 3 F D E M W F D E M W Scrittura Register File nella prima metà del ciclo di clock, Lettura nella seconda metà del ciclo di clock I 4 F D E M W legge $s1: dato corretto 47

48 Clock in controfase nel register file clock Scrittura MEM/WB Scrittura Register File Scrittura ID/EX Lettura R. File Assunzioni: T prop-mem/wb + T setup-rf < T clock /2 T prop-rf + T setup-id/ex < T clock /2 48

49 Unità di rilevazione criticità gestisce solo criticità carica-e-usa 49

50 Spiegazione lucido precedente Hazard Detection Unit gestisce criticità carica-e-usa : istruzione in D carica un registro che è destinazione di lw immediatamente precedente (attualmente nello stadio EX) Riconoscimento: - ID/EX.MemRead = 1 (lw è l unica che legge dalla memoria!) - ID/EX.RegisterRt = sorgente istruzione in D Eventuale stallo: - 1 ciclo di clock Realizzazione stallo (usuale): - pone bolla in ID/EX - impedisce scrittura di IF/ID e PC (per un ciclo) 50

51 QUADRO RIASSUNTIVO (FINO A QUESTO PUNTO) Controllo pipeline: - sul secondo stadio di decodifica [dopo lo stadio di fetch] - controllo combinatorio: IR decode Registro Interstadio (nello stadio di decodifica solo ottimistiche) Problemi: - Criticità strutturali (miss di cache + stadio richiede più cicli di clock) Þ stallo su uno stadio S (es. stadio di fetch esecuzione) Þ unità di rilevazione delle criticità (forza lo stallo) sullo stadio S Riceve segnali da: stadio S (e registro interstadio) + stadi successivi (istruzioni precedenti!) -Criticità sui dati Þ unità di propagazione dei dati: propagazione verso uno stadio S: propaga dati da uno stadio successivo (riceve info su stadio S e successivi!) NB: si propaga sempre verso lo stadio dove viene usato il dato: è così possibile aspettare più istruzioni che potrebbero produrlo Criticità rimanenti risolte attraverso stalli Þ UNITA DI PROPAGAZIONE SGRAVA UNITA RILEVAZ. CRITICITA 51

52 Il ruolo del compilatore Esempio ipotetico programma MIPS (presenza unità gest. criticità + propagazione) add $t5, $t5, $t6 lw $t2, 4($t1) add $t4, $t2, $t3 criticità carica-e-usa Se il compilatore riordina le istruzioni così lw $t2, 4($t1) add $t5, $t5, $t6 add $t4, $t2, $t3 Il risultato non cambia (la seconda add lavora su registri diversi!) ma la distanza tra le due istruzioni dipendenti ora è aumentata: la propagazione evita lo stallo!!! 52

53 ESEMPIO TIPICO La tipica configurazione di codice che deriva da istruzioni del tipo A = B + C genera uno stallo sul valore del secondo dato lw $s1, 0($t0) F D E M W $s1 lw $s2, 0($t1) add $s3, $s1, $s2 sw $s3, 0($t2) F D E M W F D F $s2 D F E D M $s3 E W M W 53

54 Ruolo del compilatore: Il compilatore può modificare la sequenza di codice per eliminare lo stallo Il compilatore cerca di evitare di fare eseguire il caricamento e immediatamente dopo usare il registro destinazione del caricamento VEDIAMO COME PARTENDO DA UN ESEMPIO 54

55 Codice di partenza a = b + c; d = e f; Þ stallo su c nell addizione [se si carica prima b, altrimenti stallo su b] Þ stallo su f nella sottrazione Supponiamo che b, c, e ed f siano nelle locazioni di memoria il cui indirizzo è rispettivamente in $t0, $t1, $t3, $t4 a e d vadano memorizzati nelle locazioni il cui indirizzo è rispettivamente in $t2 e $t5 55

56 Esecuzione senza intervento del compilatore lw $s1, 0($t0) # carica b lw $s2, 0($t1) # carica c add $s3, $s1, $s2 # somma con stallo sw $s3, 0($t2) # memorizza a lw $s4, 0($t3) # carica e lw $s5, 0($t4) # carica f sub $s6, $s4, $s5 # sottrazione con stallo sw $s6, 0($t5) # memorizza d 56

57 intervento del compilatore lw $s1, 0($t0) # carica b lw $s2, 0($t1) # carica c add $s3, $s1, $s2 # somma con stallo sw $s3, 0($t2) # memorizza a lw $s4, 0($t3) # carica e lw $s5, 0($t4) # carica f sub $s6, $s4, $s5 # sottrazione con stallo sw $s6, 0($t5) # memorizza d 57

58 Esecuzione con intervento del compilatore lw $s1, 0($t0) # carica b lw $s2, 0($t1) # carica c lw $s4, 0($t3) # carica e add $s3, $s1, $s2 # (scambiate lw e add) lw $s5, 0($t4) # carica f sw $s3, 0($t2) # scambiate lw e sw sub $s6, $s4, $s5 # sottrazione sw $s6, 0($t5) # memorizza d Con l unità di propagazione verso E, non si ha più alcuno stallo! 58

59 PIPELINE: CRITICITA SUL CONTROLLO 59

60 Criticità sul controllo L istruzione di salto viene eseguita in un certo stadio della pipeline (supponiamo il quarto): I3: Jump j. condiz. I4: I3 F D addr PC I5: I6: I4 F D O W.. F D O W I5 J branch I6 I7 F D O W F D O W Se il salto è effettuato, I4, I5, I6 vengono eseguite comunque, mentre l istruzione a cui si salta viene caricata ed eseguita successivamente Due tipi di salti: - salto incondizionato (jump) - salto condizionato o diramazione (branch) 60

61 TECNICA 1: salto ritardato Gestione interamente al software (compilatore): no unità di gestione criticità! In pratica, il comportamento è quello schematizzato nel lucido precedente L istruzione è caratterizzata da uno o più intervalli di ritardo del salto ( branch delay slot ) ovvero posti che il compilatore deve riempire con istruzioni che devono sempre essere eseguite. Il numero di branch delay slot corrisponde allo stadio in cui viene eseguito il salto (1 per il secondo stadio, 2 per il terzo, ecc.). Maggiore è il numero di slot, più difficile è il compito del compilatore: in mancanza di istruzioni, è sempre possibile usare l istruzione NOP. 61

62 SALTO INCONDIZIONATO Esempio: supponiamo aggiornamento del PC nel terzo stadio (O) I3: lw R1, 100(R3) I4: add R2, R2, R3 I5: sub R4, R5, R6 I6: j I110.. Riordino I3: lw R1, 100(R3) I4: j I110 I5: add R2, R2, R3 I6: sub R4, R5, R6.. I4: j I110 I5 F D PC W F D O W jump I6 F D O W F D O W I110 62

63 SALTO CONDIZIONATO Esempio: supponiamo che si abbia un solo slot.. Dest: add $s2, $s1, $s3 sub $s4, $s2, $s1 beq $s1, $zero, Dest.. Riordino.. Dest: add $s2, $s1, $s3 beq $s1, $zero, Dest sub $s4, $s2, $s1.. Questa strategia non è applicabile se le istruzioni che precedono la diramazione modificano le condizioni su cui si basa il test di diramazione, ad esempio:.. Dest: add $s7, $s1, $s3 sub $s4, $s2, $s1 beq $s4, $zero, Dest mul $s5, $s2, $s1.... Dest: add $s7, $s1, $s3 beq $s4, $zero, Dest mul $s5, $s2, $s1.. [in tal caso la condizione di salto deve essere successiva a sub] 63

64 TECNICA 2: stallo nella pipeline SALTO INCONDIZIONATO Esempio: aggiornamento PC nel quarto stadio I3: Jump I10 I4: I5: I6:.. F D addr PC F F F F stallo stallo stallo J D O W F D O W I10 I11 Realizzazione nel modo visto (con S = F e riconoscimento del salto posto in stadio ID) Write P C F Gestione criticità controllo ID Riconoscimento J Se un istruzione jump in pipeline è in stadio S scritturapc : - BOLLA - no scrittura PC a meno che jump non sia in S scritturapc 64

65 NB: per limitare il numero di bolle [cicli di stallo della pipeline] è bene che l esecuzione del salto [aggiornamento PC] sia fatto in uno stadio quanto più possibile anticipato. Meglio se il numero degli stadi della pipeline è limitato! In ogni caso, anche anticipando l esecuzione del salto nello stadio ID, rimane comunque uno stallo: F PC O W J stallo F D O W SALTO CONDIZIONATO E ovviamente possibile utilizzare la stessa tecnica; tuttavia, poiché il salto potrebbe non essere effettuato (e quindi eseguite le istruzioni seguenti) si utilizzano tecniche di predizione. 65

66 TECNICA 3: Predizione di salto non effettuato Salto condizionato: si continuano a prelevare le istruzioni successive. Condizione di salto indica salto non effettuato : tutto procede normalmente. Condizione di salto indica salto effettuato : - istruzioni già in pipeline (stadi precedenti a esecuzione salto) scartate - si procede con il fetch indirizzo di destinazione. ESEMPIO (verifica + calcolo indirizzo nel terzo stadio) +4 P C NOP F NOP ID branch condizione di salto EX destinazione 66

67 ESEMPIO (supponendo che il salto sia eseguito nel terzo stadio) 40 beq $1, $3, 7 44 and $12, $2, $5 F D E M W F D E M W 48 or $13, $6, $2 F D E M W 52 add $14, $2, $ lw $4, 50($7) Se il salto viene effettuato, le istruzioni 44 e 48 vanno scartate, si introduce un ritardo di 2 cicli di clock Decisione relativa al salto 67

68 Questo si può indicare nel diagramma con cicli di purge (P) 40 beq $1, $3, 7 44 and $12, $2, $5 F D E M W F P E M W 48 or $13, $6, $2 P D E M W 52 add $14, $2, $ lw $4, 50($7) F D E M W 68

69 COMMENTI: SALTO RITARDATO VS STALLO Stallo introduce cicli di clock persi talvolta evitabili con salto ritardato Þ Salto ritardato è sempre più efficiente rispetto allo stallo! Salto ritardato richiede collaborazione tra hardware e software (il compilatore deve riordinare istruzioni tenendo presente dettagli hardware) Þ Richiede collaborazione progettisti HW e SW Þ Salto ritardato utilizzabile per processori RISC di nuova generazione, impraticabile se si vuole mantenere la compatibilità con software pre-esistente (non compilato per tener conto del salto ritardato). ES. Intel: introdotta la pipeline dal 486 Con l avvento delle pipeline superscalari e dinamiche (non viste in questo corso) aumenta il numero di slot [in un ciclo cominciano l esecuzione più istruzioni] ed il salto ritardato è difficilmente gestibile. Sono più efficaci le tecniche di predizione del salti 69

70 COMMENTI: TECNICHE DI PREDIZIONE COMPLESSE Tecniche di predizione dei salti condizionati (salto eseguito o no) - salto eseguito: unità di fetch carica istruzioni a partire da ind. destinazione - salto non eseguito: unità di fetch carica a partire da ind. successivo Esecuzione speculativa istruzioni: - predizione corretta: non ci sono cicli di penalità - predizione errata: si scartano istruzioni entrate in pipeline da non eseguire, penalità di uno o più cicli di clock Due possibili tipologie di tecniche: - PREDIZIONE STATICA: realizzata dal compilatore - PREDIZIONE DINAMICA: realizzata dal processore (predizione a runtime sulla base della storia passata : diramazione può avere predizioni diverse nel corso dell esecuzione) 70

71 PIPELINE: GESTIONE DELLE ECCEZIONI 71

72 Gestione delle eccezioni nel caso di controllo con pipeline: PROBLEMI: Nel momento in cui avviene un eccezione, ci saranno più istruzioni nella pipeline... Quale istruzione è responsabile dell eccezione? Cosa fare delle istruzioni precedenti ancora presenti in pipeline? Cosa fare delle istruzioni successive già presenti nella pipeline? La gestione può essere diversa a seconda delle tipologie di causa: 1. Eccezioni interne [chiamata S.O. Overflow o istruzione indefinita ] 2. Interruzioni esterne da parte dei sistemi I/O [Malfunzionamento HW può essere rilevato da eccezione interna o esterna] 72

73 Vediamo la gestione delle eccezioni interne: In questo caso l istruzione responsabile dell eccezione è chiaramente definita - l eccezione avviene in uno stadio specifico S [p.es. overflow: stadio EX istruzione indefinita: stadio D] E necessario passare il controllo ad una routine di servizio, ma anche prevedere la gestione di più istruzioni nella pipeline: - l istruzione responsabile dell eccezione deve essere immediatamente interrotta ed eliminata [non deve modificare i registri] - le istruzioni che seguono l istruzione responsabile [negli stadi precedenti S] devono essere eliminate: completare la loro esecuzione sarebbe dannoso dopo il verificarsi di un eccezione - le istruzioni che precedono l istruzione responsabile [negli stadi seguenti S] devono essere completate: la routine di servizio deve conoscere lo stato che precede l esecuzione dell istruzione responsabile dell eccezione [vedi esempio nel lucido seguente] 73

74 addi $s1, $s1, 100 add $s1, $s2, $s1 Valore di $s1 usato da add [via propagazione!] Overflow aritmetico: add interrotta nello stadio EX Dipende anche dal valore di $s1: la routine di servizio potrebbe dover conoscere il valore. Ma questo, quando add è nello stato EX, è stato propagato dalla addi ma non è ancora stato scritto nel register file dalla addi [che si trova in M]. E necessario allora lasciare che le istruzioni precedenti vengano eseguite; ciò non significa ritardare la chiamata alla routine di servizio: le istruzioni della routine di servizio sono caricate in pipeline normalmente! QUINDI - eliminare (segnali a reg. interstadio) istruzione responsabile e seguenti - scrivere in opportuni registri la causa e l indirizzo dell istruzione interrotta - modificare PC: caricamento prima istruzione routine di servizio 74

75 Realizzazione (schema astratto) Causa Indirizzo routine di servizio controllo Write EPC NOP P C F N O P controllo... N O P P C S N O P S+1 75

76 NOTE AL LUCIDO PRECEDENTE: - il concetto fondamentale è che le istruzioni fino a S sono scartate, quelle in stadi successivi continuano e i registri EPC, Causa, PC sono aggiornati opportunamente - l introduzione di un valore NOP in un registro interstadio si intende ottenuta comandando un opportuno MUX [vedi p.es. i dettagli nella specifica realizzazione proposta dal Patterson] Analogamente, la scrittura dell indirizzo della routine di servizio nel PC avviene comandando opportunamente il MUX uno dei cui ingressi è collegato a valore costante corrispondente all indirizzo stesso - nell esempio si usa un registro di causa, ma è facile immaginare la modifica per interruzioni vettorizzate (p.es. basta usare un MUX opportuno verso PC, i diversi ingressi corrispondono ai diversi indirizzi delle routine di servizio) 76

77 L esempio del MIPS (per la gestione dell overflow aritmetico) (NB: gestione eccezioni demandata all unità di controllo) 77

78 PROBLEMA: In uno stesso ciclo di clock più eccezioni da diversi stadi, con cause diverse - Si assegna una priorità alle eccezioni: servita quella a priorità più alta (di solito istruzione più vecchia = stadio più avanzato) - Il registro Causa può mantenere tutte le eccezioni che si verificano in un ciclo di clock: quando è stata servita la prima, sono disponibili le informazioni sulle altre Per le interruzioni esterne: - È possibile attribuire l interruzione all istruzione più conveniente, tipicamente completando tutte le istruzioni già entrate nella pipeline (altrimenti dovrei scartarle e avrei dei cicli di penalità inutili!) - Per i malfunzionamenti hardware: trattati come le interruzioni esterne se di natura esterna, altrimenti come le interruzioni interne! 78