Prozessorarchitektur. Dynamische Ablaufplanung. M. Schölzel

Transkript

1 Prozessorarchitektur Dynamische Ablaufplanung M. Schölzel

2 Inhalt HW-Architekturen zur Implementierung dynamischer Ablaufplanung: Scoreboard Tomasulo-Algorithmus

3 Inhalt HW-Architekturen zur Implementierung dynamischer Ablaufplanung: Scoreboard Tomasulo-Algorithmus

4 Scoreboard Scoreboard erlaubt: In-order Ausgabe, out-of-order Ausführung und out-of-order Abschluss von Operationen Entwickelt für die Gleitkommapipeline der CDC66 Ein Prozessor hatte parallel arbeitende Ausführungseinheiten (erster superskalarer Prozessor) Supercomputer CDC66 Erstes Exemplar wurde 965 ans CERN ausgeliefert Schnellster Supercomputer der Welt bis 969 mit 3 Millionen Gleitkommaoperationen pro Sekunde Zum Vergleich: Core i7 mit 4 Kernen und 3.2 GHz schafft bis zu 5 Milliarden Gleitkommaoperationen pro Sekunde (theoretisch) Quelle: Wikipedia

5 Architektur für Scoreboard Eigenschaften: Mehrere Ausführungseinheiten, die parallel arbeiten können Ausführungseinheiten haben keine Pipeline; unterschiedlich lange Ausführungsdauer möglich Ein Befehl pro Takt kann geholt und ausgegeben werden (CPI < nicht möglich) Takt Takt 2 Takt 3 Takt 4 Execute Fetch Befehle aus Speicher/Cache holen Decode Befehle dekodieren und Speicherplatz der Operanden bestimmen Execute n Write Back Ergebnis zurückschreiben Operanden aus Speicherplatz lesen und verarbeiten

6 Problem der RAW-Hazards Read-After-Write-Hazard (RAW-Hazard) ist ein Datenhazard in der Pipeline Problem: Entsteht durch Flussabhängigkeit von Operation A zu Operation B, wenn bei Ausgabe von B das Ergebnis von A noch nicht zurückgeschrieben wurde Auflösen des Hazards: B muss warten, bis Ergebnis von A zurückgeschrieben Konsequenz der in-order-ausgabe: Alle B nachfolgenden Operationen müssen ebenfalls warten Takt Takt 2 Takt 3 Takt 4 Execute Op Fetch B Decode Op A A wartet auf Ausgabe Write Back Execute n

7 Problem der RAW-Hazards Read-After-Write-Hazard (RAW-Hazard) ist ein Datenhazard in der Pipeline Problem: Entsteht durch Flussabhängigkeit von Operation A zu Operation B, wenn bei Ausgabe von B das Ergebnis von A noch nicht zurückgeschrieben wurde Auflösen des Hazards: B muss warten, bis Ergebnis von A zurückgeschrieben Konsequenz der in-order-ausgabe: Alle B nachfolgenden Operationen müssen ebenfalls warten Takt Takt 2 Takt 3 Takt 4 Execute Op Fetch C Decode Op B A wurde ausgegeben und B wartet auf Ausgabe Op Execute A 2 Execute n Write Back

8 Problem der RAW-Hazards Read-After-Write-Hazard (RAW-Hazard) ist ein Datenhazard in der Pipeline Problem: Entsteht durch Flussabhängigkeit von Operation A zu Operation B, wenn bei Ausgabe von B das Ergebnis von A noch nicht zurückgeschrieben wurde Auflösen des Hazards: B muss warten, bis Ergebnis von A zurückgeschrieben Konsequenz der in-order-ausgabe: Alle B nachfolgenden Operationen müssen ebenfalls warten Takt Takt 2 Takt 3 Takt 4 Execute Op Fetch C Decode Op B B kann nicht ausgegeben werden, weil B auf Ergebnis von A warten muss (Flussabhängigkeit von A nach B angenommen) Execute Op 2 A Execute n Write Back

9 Problem der RAW-Hazards Read-After-Write-Hazard (RAW-Hazard) ist ein Datenhazard in der Pipeline Problem: Entsteht durch Flussabhängigkeit von Operation A zu Operation B, wenn bei Ausgabe von B das Ergebnis von A noch nicht zurückgeschrieben wurde Auflösen des Hazards: B muss warten, bis Ergebnis von A zurückgeschrieben Konsequenz der in-order-ausgabe: Alle B nachfolgenden Operationen müssen ebenfalls warten Takt Takt 2 Takt 3 Takt 4 Execute Op Fetch C Decode Op B B kann nicht ausgegeben werden, weil B auf Ergebnis von A warten muss. A schreibt jetzt Ergebnis in Registerbank. Execute n Write Op A Back

10 Problem der RAW-Hazards Read-After-Write-Hazard (RAW-Hazard) ist ein Datenhazard in der Pipeline Problem: Entsteht durch Flussabhängigkeit von Operation A zu Operation B, wenn bei Ausgabe von B das Ergebnis von A noch nicht zurückgeschrieben wurde Auflösen des Hazards: B muss warten, bis Ergebnis von A zurückgeschrieben Konsequenz der in-order-ausgabe: Alle B nachfolgenden Operationen müssen ebenfalls warten Takt Takt 2 Takt 3 Takt 4 Op B Execute Op Fetch D Decode Ergebnis von A ist in Registerbank vorhanden. B kann somit ausgegeben werden und liest bei der Ausgabe das Ergebnis als Operand Execute n Write Back

11 Lösung für RAW-Hazard Separate Pipeline-Phase zum Lesen der Operanden (RO) Ausgabe immer noch in-order Operationen warten jetzt in RO-Phase auf Operanden und können out-of-order zur Ausführung gebracht werden RO Execute Op Fetch B Decode Op A Annahme wie im vorigen Beispiel: es ex. Flussabhängigkeit von A nach B. RO2 RO3 ROn Execute n Write Back

12 Lösung für RAW-Hazard Separate Pipeline-Phase zum Lesen der Operanden (RO) Ausgabe immer noch in-order Operationen warten jetzt in RO-Phase auf Operanden und können out-of-order zur Ausführung gebracht werden RO Execute Op Fetch C Decode Op B A wurde ausgegeben RO2 Op RO3 A Write Back ROn Execute n

13 Lösung für RAW-Hazard Separate Pipeline-Phase zum Lesen der Operanden (RO) Ausgabe immer noch in-order Operationen warten jetzt in RO-Phase auf Operanden und können out-of-order zur Ausführung gebracht werden Op RO B Execute Op Fetch D Decode B wurde in-order ausgegeben und kann jetzt auf Ergebnis von A warten RO2 RO3 ROn Op Execute A 2 Execute n Write Back

14 Lösung für RAW-Hazard Separate Pipeline-Phase zum Lesen der Operanden (RO) Ausgabe immer noch in-order Operationen warten jetzt in RO-Phase auf Operanden und können out-of-order zur Ausführung gebracht werden Op RO B Execute Op Fetch E Decode Op D Die B nachfolgenden Operationen werden nicht mehr blockiert: wurde ausgegeben. Op RO2 C RO3 ROn Execute Op 2 A Execute n Write Back

15 Lösung für RAW-Hazard Separate Pipeline-Phase zum Lesen der Operanden (RO) Ausgabe immer noch in-order Operationen warten jetzt in RO-Phase auf Operanden und können out-of-order zur Ausführung gebracht werden Op RO B Execute Fetch Op F Decode Op E RO2 RO3 Write Op A Back C wird out-of-order ausgeführt (überholt B) und A schreibt Ergebnis in Registerbank. Op ROn D Execute n

16 Lösung für RAW-Hazard Separate Pipeline-Phase zum Lesen der Operanden (RO) Ausgabe immer noch in-order Operationen warten jetzt in RO-Phase auf Operanden und können out-of-order zur Ausführung gebracht werden RO Op B Execute Op Fetch G Decode Op F RO2 Op RO3 E Op Execute C 2 Write Back B kann Ergebnis von A aus der Registerbank lesen und zur Ausführung gebracht werden. Op ROn D Op D Execute n

17 Bisher erreicht Dynamische Ablaufplanung in Pipeline integriert In-order Ausgabe beibehalten Out-of-order Verarbeitung ermöglicht Out-of-order-Abschluss möglich wegen out-of-order Verarbeitung und unterschiedlich langer Ausführungszeiten Operationen müssen in Fetch-/Decode-Phase nicht angehalten werden, weil vorderste Operation auf Operanden wartet Ein Problem gelöst zwei neue Probleme erzeugt

18 Problem : WAW-Hazard Ursprüngliche Reihenfolge der Operationen: A, B, C, D, E, Was passiert, wenn B und C das gleiche Zielregister R haben? C schreibt vor B in Register R; dadurch Ausgabeabhängigkeit von B nach C verletzt (= Write-after-Write-Hazard) RO Op B C wird out-oforder ausgeführt Execute Op Fetch G Decode Op F RO2 Op RO3 E Op Execute C 2 Write Back Op ROn D Op D Execute n

19 Problem 2: WAR-Hazard Ursprüngliche Reihenfolge der Operationen: A, B, C, D, E, Was passiert, wenn C ein Register R schreibt, das B liest? C schreibt in R bevor B aus R lesen kann; dadurch Gegenabhängigkeit von B nach C verletzt (= Write-After-Read-Hazard) Op RO B Execute Fetch Op F Decode Op E RO2 RO3 Execut e 2 C wird out-oforder ausgeführt Execute Op 2 A Write Back Op ROn D Execute n

20 Scoreboard Scoreboard erlaubt dynamische Ablaufplanung und verhindert WAR- und WAW-Hazards Befehlsverarbeitung in 5 Schritten: Fetch Issue Read Operands (RO) Execute (EX) Write-Back (WB) Fetch Issue RO EX WB Superskalarer Datenpfad Execute Ein Befehl pro Takt wird ausgegeben Sinnvoll deshalb nur für lang laufende Befehle in der EX-Phase Registerbank Scoreboard

21 Scoreboard: Fetch-Phase Höchstens einen Befehl pro Takt aus dem Speicher holen und in stellen Scoreboard überwacht, dass Platz ist und Befehle in weitergereicht werden Fetch Issue RO EX WB Execute Op A wurde aus Speicher gelesen Op A Registerbank Scoreboard

22 Scoreboard: Fetch-Phase Höchstens einen Befehl pro Takt aus dem Speicher holen und in stellen Scoreboard überwacht, dass Platz ist und Befehle in weitergereicht werden Fetch Issue RO EX WB Execute wird gefüllt Op B Op A Registerbank Scoreboard

23 Scoreboard: Fetch-Phase Höchstens einen Befehl pro Takt aus dem Speicher holen und in stellen Scoreboard überwacht, dass Platz ist und Befehle in weitergereicht werden Fetch Issue RO EX WB Execute ist gefüllt. Ausgabe von Op A kann erfolgen Op B Op A Registerbank Scoreboard

24 Scoreboard: Issue-Phase Höchstens ein Befehl pro Takt wird ausgegeben: Vordersten Befehl (Op A) aus holen und an Ausführungseinheit übergeben Scoreboard überwacht, dass Passende Ausführungseinheit für A frei ist Fetch Issue RO EX WB Keine Operation mit demselben Zielregister wie Op A in RO-, EXoder WB-Phase ist Dadurch Verhinderung von WAW-Hazards Op B Op A Registerbank Execute Es darf Operationen in RO-, EX- oder WB-Phase geben, die Quelloperanden für A berechnen Scoreboard

25 Scoreboard: Issue-Phase (Beispiel : Befehlsausgabe) Übergabe von Op A an Ausführungseinheit 2 wurde vorgenommen Gleichzeitig wurde Op D aus Speicher geholt und Op B und sind in nachgerückt Fetch Issue RO EX WB Execute Op D Op B Op A Registerbank Scoreboard

26 Scoreboard: Issue-Phase (Beispiel 2: Pipeline-Stall bei WAW-Hazard) Wenn Op A (oder Op B oder ) dasselbe Register schreibt wie Op D, dann wird die Ausgabe von Op D und allen nachfolgenden Operationen blockiert Grund: Op D könnte Op A (oder Op B oder ) bei Ausführung überholen Ausgabe weiterer Operationen erst möglich, wenn Op A (oder B oder C) abgeschlossen ist Fetch Op F Op E Op D Issue RO Registerbank Op B EX Execute Op A WB Beispiel: add r <- r2, r3 sub r <- r4, r // Op A // Op D Scoreboard

27 Scoreboard: Issue-Phase (Beispiel 3: Befehlsübergabe bei Flussabhängigkeit) Wenn Op B (oder Op A oder ) ein Register R schreibt, das von Op D gelesen wird, dann darf Op D in RO-Phase übergeben werden (vorausgesetzt es gibt keinen WAW-Hazard) Grund: Op D wartet in RO-Phase, bis der Wert in Register R zur Verfügung steht Ausgabe weiterer Operationen ist dadurch möglich Fetch Issue RO EX Execute WB Pipeline blockiert nicht Op F Op E Op D Registerbank Op B Op A Beispiel: add r <- r2, r3 sub r5 <- r, r // Op B // Op D Scoreboard

28 Scoreboard: Issue-Phase (Beispiel 3: Befehlsübergabe bei Flussabhängigkeit) Wenn Op B (oder Op A oder ) ein Register R schreibt, das von Op D gelesen wird, dann darf Op D in RO-Phase übergeben werden (vorausgesetzt es gibt keinen WAW-Hazard) Grund: Op D wartet in RO-Phase, bis der Wert in Register R zur Verfügung steht Ausgabe weiterer Operationen ist dadurch möglich Fetch Issue RO EX Execute WB Pipeline blockiert nicht Op G Op F Op E Registerbank Op B Op D Beispiel: add r <- r2, r3 sub r5 <- r, r // Op B // Op D Scoreboard

29 Scoreboard: RO-Phase Operation wartet in RO-Phase, bis alle Quelloperanden verfügbar sind Scoreboard überwacht wann Quelloperanden in der Registerbank bereitstehen Fetch Issue RO EX WB erlaubt dann der Operation das Lesen der Operanden aus der Registerbank und Execute danach die Übergabe der Operation in die EX-Phase Op G Op F Op E Registerbank Op B Op D Scoreboard

30 Scoreboard: RO-Phase (Beispiel 4: Warten auf Operanden) Op D wartet auf Ergebnis von Op B Fetch Issue RO EX WB Execute Op G Op F Op E Registerbank Op B Op D Beispiel: add r <- r2, r3 sub r5 <- r, r // Op B // Op D Scoreboard

31 Scoreboard: RO-Phase (Beispiel 4: Warten auf Operanden) Op D wartet immer noch Fetch Issue RO EX WB Execute Op G Op F Op E Registerbank Op B Op D Beispiel: add r <- r2, r3 sub r5 <- r, r // Op B // Op D Scoreboard

32 Scoreboard: RO-Phase (Beispiel 4: Warten auf Operanden) Ergebnis von Op B ist berechnet, aber noch nicht in die Registerbank geschrieben Ein Bypass könnte jetzt bereits ein Starten von Op D ermöglichen Fetch Issue RO EX WB Execute Op G Op F Op E Registerbank Op B Op D Beispiel: add r <- r2, r3 sub r5 <- r, r // Op B // Op D Scoreboard

33 Scoreboard: RO-Phase (Beispiel 4: Warten auf Operanden) Op B hat Ergebnis in Registerbank zurückgeschrieben Im nächsten Takt darf Op D in die EX-Phase übergeben werden und kann dabei Ergebnis von B aus der Registerbank lesen Fetch Issue RO EX WB Execute Beispiel: add r <- r2, r3 sub r5 <- r, r // Op B // Op D Op G Op F Op E Op D Registerbank Ergebnis von B Scoreboard

34 Scoreboard: RO-Phase (Beispiel 4: Warten auf Operanden) Op D hat Ergebnis von B gelesen und ist in der EX-Phase Fetch Issue RO EX WB Execute Beispiel: add r <- r2, r3 sub r5 <- r, r // Op B // Op D Op G Op F Op E Registerbank Ergebnis von B Op D Scoreboard

35 Scoreboard: EX-Phase Ausführung: EU (Execution Unit) beginnt Verarbeitung der Operation, sobald die Operanden gelesen wurden Fetch Issue RO EX WB Execute Op G Op F Op E Registerbank Op D Scoreboard

36 Scoreboard: EX-Phase Ende der Verarbeitung wird dem Scoreboard mitgeteilt Operation ist dann in der WB-Phase Fetch Issue RO EX WB Execute Op G Op F Op E Registerbank Op D Scoreboard

37 Scoreboard: WB-Phase Ergebnis einer Operation wartet in WB-Phase, bis Scoreboard das Zurückschreiben in Register R zulässt Ausführungseinheit kann solange keine neuen Operationen ausführen Zurückschreiben wird verzögert, wenn eine andere Operation in RO-Phase noch den alten Wert aus R lesen muss Dadurch Verhinderung von WAR-Hazards Fetch Issue RO Registerbank EX Execute Op A WB Out-of-order-Abschluss einer Operation möglich Scoreboard

38 Scoreboard: WB-Phase (Beispiel 5: Abschluss verzögern) Ausführung von Op A dauert sehr lange Op B wartet deshalb in der RO-Phase auf Wert in R3 hat Op A und Op B überholt in der Ausführung Fetch Issue RO EX WB Bei sofortigem Schreiben des Ergebnisses von C in R2 würde Op B den neuen Wert lesen ein WAR-Hazard wäre entstanden kann Ergebnis erst zurückschreiben, wenn Op B seine Operanden gelesen hat Op B Registerbank Execute Op A Beispiel: lw r3,(r5) // Op A add r <- r2, r3 // Op B sub r2 <- r4, r // Scoreboard

39 Scoreboard: WB-Phase (Beispiel 6: out-of-order-abschluss) Beispiel wie eben, aber ohne Gegenabhängigkeit von Op B zu Abschluss von ist möglich Abschluss damit out-of-order Fetch Issue RO EX WB Execute Op A Registerbank Op B Beispiel: lw r3,(r5) // Op A add r <- r2, r3 // Op B sub r5 <- r4, r // Scoreboard

40 Scoreboard: Bottlenecks Neben den Daten-Hazards müssen Ressourcen-Hazards durch das Scoreboard vermieden werden Mögliche Ressourcen-Hazards: Anzahl der Operationen, deren Ausführung pro Takt gestartet werden kann, ist durch Anzahl der Leseports in der Registerbank beschränkt Fetch Issue RO EX WB Anzahl der Operationen, die pro Takt abgeschlossen werden können, ist durch Anzahl der Schreibports in der Registerbank beschränkt Registerbank Execute Op A Op B Scoreboard

41 Bisher betrachtet Gewünschtes Verhalten der Pipeline Aufgaben des Scorboards Jetzt Betrachtung der Implementierung des Scorboards

42 Implementierung des Scoreboards Fetch Issue RO EX WB Execute Registerbank Scoreboard Scoreboard protokolliert Zustand der Pipeline in drei Tabellen: Instruktionsstatus Status der Ausführungseinheiten Registerergebnisstatus

43 Tabelle Instruktionsstatus EU Instr RO EX WB 2 m Aufbau der Tabelle für m Ausführungseinheiten: Eine Zeile für jede Ausführungseinheit (EU) Eine Spalte für die der EU k zugewiesene Operation A Schreibweise: Instr[k] = A mit k Î {,, m} Eine Spalte für jede Phase RO, EX, WB Befindet sich eine Operation in Pipeline-Phase x von EU k, dann wird der zugehörige Eintrag auf gesetzt, sonst ist er Schreibweise: x[k] mit x Î {RO, EX, WB} und k Î {,, m} Protokollierung in welcher Verarbeitungsphase sich eine Operation gerade befindet

44 Beispiel Fetch Issue RO EX WB Execute Op A Registerbank Op B Execute 4 Scoreboard EU Instruktion RO EX WB Op A Op B RO[] = EX[] = WB[] =

45 Tabelle Status der Ausführungseinheiten EU Busy Op Fi Fj Fk Qj Qk Rj Rk 2 m Für x Î {,, m} Busy[x] =, falls EU x belegt (d.h. RO[x] = oder EX[x] = oder WB[x] = ) Op[x] ist die auszuführende Operation in der EU x (z.b. add, sub,) Fi[x] ist das Zielregister der ausgeführten Operation Fj[x] und Fk[x] sind die Quellregister der ausgeführten Operation Qj[x] und Qk[x] sind die Nummern der Ausführungseinheiten, die die Werte für Fj[x] bzw. Fk[x] erzeugen, falls diese noch nicht berechnet wurden Rj[x] und Rk[x] zeigen den Zustand der Quelloperanden der an x ausgegebenen Operation an: wird noch berechnet; Nummer der EU, die den Operanden berechnet, kann in Qi bzw. Qj gefunden werden Operand steht in Register bereit; Registernummer kann in Fj bzw. Fk gefunden werden 2 wird nicht benötigt oder wurde bereits gelesen

46 Tabelle Registerergebnisstatus R R R2 R3 R4 R5 R6 Rn s s s2 s3 s4 s5 s6 sn si =, wenn keine Operation in der Pipeline ist (RO, EX, WB-Phase), die den Wert von Ri berechnet si = x, wenn die Operation, die der Ausführungseinheit x zugeordnet ist, den Wert für Ri berechnet Schreibweise: RegResult[i] = si Verwendung als Look-Up-Tabelle, um festzustellen, welche EU gerade den Wert eines Quellregisters berechnet

47 Issue-Phase Für vorderste Operation in sei: opc die auszuführende Operation (add, sub, mul, ) src, src2 die zwei Quelloperanden dst das Zielregister Ausgabe der Operation an Ausführungseinheit x Î {,,m}, falls busy[x] = und x kann Operation ausführen RegResult[dst] = Bei der Ausgabe werden die Tabellen wie folgt aktualisiert: busy[x] := ; Op[x] := opc; Fi[x] := dst; Fj[x] := src; Fk[x] := src2 Qj[x] := RegResult[src]; Qk[x] := RegResult[src2] Rj[x] := if src vorhanden then if RegResult[src] = then else else 2 Rk[x] := if src2 vorhanden then if RegResult[src2] = then else else 2 RegResult[dst] := x RO[x] := ;

48 Scoreboard: Issue-Phase (Beispiel : Ausgabe ohne Abhängigkeiten) Fetch Op B Op A Issue RO Registerbank EX Execute WB Prüfen, ob Op A ausgegeben werden kann: Freie passende EU Zielregister darf nicht beschrieben werden Scoreboard Execute 4 add r <- r2, r3 sub r4 <- r5, r // Op A // Op B EU Busy Op Fi Fj Fk Qj Qk Rj Rk Instr RO EX WB R R R2 R3 R4 R5 R6 R7 R8 R9 R prüfen

49 Scoreboard: Issue-Phase (Beispiel : Ausgabe ohne Abhängigkeiten) Fetch Op D Op B Issue Op A RO Registerbank EX Execute WB Op A wurde ausgegeben Tabellen im Scoreboard aktualisiert Scoreboard Execute 4 add r <- r2, r3 sub r4 <- r5, r // Op A // Op B EU Busy Op Fi Fj Fk Qj Qk Rj Rk Instr RO EX WB add r r2 r3 Op A R R R2 R3 R4 R5 R6 R7 R8 R9 R

50 Scoreboard: Issue-Phase (Beispiel 2: Ausgabe bei Flussabhängigkeit) Fetch Op D Op B Issue Op A RO Registerbank EX Execute WB Prüfen, ob Op B ausgegeben werden kann Op B liest Zielregister von Op A Scoreboard Execute 4 add r <- r2, r3 sub r4 <- r5, r // Op A // Op B EU Busy Op Fi Fj Fk Qj Qk Rj Rk Instr RO EX WB add r r2 r3 Op A R R R2 R3 R4 R5 R6 R7 R8 R9 R prüfen

51 Scoreboard: Issue-Phase (Beispiel 2: Ausgabe bei Flussabhängigkeit) Fetch Issue RO Op A EX Execute WB Op B wurde ausgegeben Op E Op D Op B Registerbank Tabellen im Scoreboard aktualisiert Rk = heißt: Operand 2 wird noch berechnet Scoreboard Execute 4 add r <- r2, r3 sub r4 <- r5, r // Op A // Op B EU Busy Op Fi Fj Fk Qj Qk Rj Rk Instr RO EX WB add r r2 r3 2 2 Op A 2 sub r4 r5 r Op B R R R2 R3 R4 R5 R6 R7 R8 R9 R 2

52 Scoreboard: Issue-Phase (Beispiel 3: WAW-Hazard) Fetch Issue RO EX WB Prüfen, ob ausgegeben werden kann Op E Op D Op B Registerbank Op A Execute WAW-Hazard wird erkannt Situation der Ausgabeabhängigkeit kann auch durch Interrupt entstehen Scoreboard Execute 4 add r <- r2, r3 sub r4 <- r5, r and r <- r8, r9 // Op A // Op B // EU Busy Op Fi Fj Fk Qj Qk Rj Rk Instr RO EX WB add r r2 r3 2 2 Op A: 2 sub r4 r5 r Op B R R R2 R3 R4 R5 R6 R7 R8 R9 R 2 Hazard erkannt prüfen

53 Phase RO Annahme: Max. eine Operation kann an EX-Phase übergeben werden (z.b. durch beschränkte Anzahl an Leseports) Für ein x Î {,,m} kann Op[x] Operanden lesen, falls: RO[x] = (Rj[x] = oder Rj[x] = 2) und (Rk[x] = oder Rk[x] = 2) Aktualisiere Tabelleneinträge wie folgt: Rj[x] := 2; Rk[x] := 2; Qj[x] := ; Qk[x] := ; RO[x] := ; EX[x] := ;

54 Scoreboard: RO-Phase (Beispiel 4: auf Operanden warten) Fetch Issue RO Op A EX Execute WB Op B kann RO-Phase erst verlassen, wenn Rk auf gesetzt wird Op E Op D Op B Registerbank Rk wird auf gesetzt, wenn Op A Ergebnis zurückgeschrieben hat Scoreboard Execute 4 add r <- r2, r3 sub r4 <- r5, r // Op A // Op B EU Busy Op Fi Fj Fk Qj Qk Rj Rk Instr RO EX WB add r r2 r3 2 2 Op A 2 sub r4 r5 r Op B R R R2 R3 R4 R5 R6 R7 R8 R9 R 2 Hazard erkannt prüfen

55 Scoreboard: RO-Phase (Beispiel 4: auf Operanden warten) Fetch Issue RO EX Execute Op A WB Op B kann RO-Phase erst verlassen, wenn Rk auf gesetzt wird Op E Op D Op B Registerbank Rk wird auf gesetzt, wenn Op A Ergebnis zurückgeschrieben hat Scoreboard Execute 4 add r <- r2, r3 sub r4 <- r5, r // Op A // Op B EU Busy Op Fi Fj Fk Qj Qk Rj Rk Instr RO EX WB add r r2 r3 2 2 Op A 2 sub r4 r5 r Op B R R R2 R3 R4 R5 R6 R7 R8 R9 R 2 Hazard erkannt prüfen

56 Scoreboard: RO-Phase (Beispiel 4: auf Operanden warten) Fetch Issue RO EX Execute WB Op B kann RO-Phase erst verlassen, wenn Rk auf gesetzt wird Op E Op D Op B Registerbank Rk wird auf gesetzt, wenn Op A Ergebnis zurückgeschrieben hat Scoreboard Execute 4 add r <- r2, r3 sub r4 <- r5, r // Op A // Op B EU Busy Op Fi Fj Fk Qj Qk Rj Rk Instr RO EX WB 2 sub r4 r5 r Op B R R R2 R3 R4 R5 R6 R7 R8 R9 R 2 Hazard erkannt prüfen

57 Scoreboard: RO-Phase (Beispiel 4: auf Operanden warten) Fetch Issue RO EX Execute WB Op B wird in EX-Phase übergeben Op E Op D Registerbank Op B Scoreboard Execute 4 add r <- r2, r3 sub r4 <- r5, r // Op A // Op B EU Busy Op Fi Fj Fk Qj Qk Rj Rk Instr RO EX WB 2 sub r4 r5 r 2 2 Op B R R R2 R3 R4 R5 R6 R7 R8 R9 R 2

58 Phase EX Ausführungseinheit x beginnt mit der Verarbeitung der Operation, wenn EX[x] = Ausführungseinheit x schreibt Ergebnis in Pipelineregister und signalisiert Scoreboard, dass die EX-Phase abgeschlossen ist: Aktualisierung der Tabellen: EX[x] := ; WB[x] := ;

59 Scoreboard: EX-Phase (Beispiel 5) Fetch Issue RO Op A EX Execute WB Op A ist an Beginn der EX-Phase Op E Op D Op B Registerbank Operanden wurden bereits gelesen Scoreboard Execute 4 add r <- r2, r3 sub r4 <- r5, r // Op A // Op B EU Busy Op Fi Fj Fk Qj Qk Rj Rk Instr RO EX WB add r r2 r3 2 2 Op A 2 sub r4 r5 r Op B R R R2 R3 R4 R5 R6 R7 R8 R9 R 2

60 Scoreboard: EX-Phase (Beispiel 5) Fetch Issue RO EX Op A Execute WB Op A ist an Beginn der EX-Phase Op E Op D Op B Registerbank Execute 4 Scoreboard Operanden wurden bereits gelesen Op A verbleibt mehrere Takte in der EX-Phase add r <- r2, r3 sub r4 <- r5, r // Op A // Op B EU Busy Op Fi Fj Fk Qj Qk Rj Rk Instr RO EX WB add r r2 r3 2 2 Op A 2 sub r4 r5 r Op B R R R2 R3 R4 R5 R6 R7 R8 R9 R 2

61 Scoreboard: EX-Phase (Beispiel 5) Fetch Issue RO EX Execute Op A WB Am Ende der EX-Phase steht das Ergebnis zum Zurückschreiben bereit Op E Op D Op B Registerbank Scoreboard Execute 4 add r <- r2, r3 sub r4 <- r5, r // Op A // Op B EU Busy Op Fi Fj Fk Qj Qk Rj Rk Instr RO EX WB add r r2 r3 2 2 Op A 2 sub r4 r5 r Op B R R R2 R3 R4 R5 R6 R7 R8 R9 R 2

62 Phase WB Annahme: Max. eine Operation kann pro Takt abgeschlossen werden Operation von Ausführungseinheit x Î {,,n} wird abgeschlossen, falls WB[x] = und "y Î {,,n} mit y ¹ x: (Fj[y] ¹ Fi[x] oder Qj[y] = x oder Rj[y] = 2) und (Fk[y] ¹ Fi[x] oder Qk[y] = x oder Rk[y] = 2) Aktualisiere Tabelleneinträge wie folgt: "y Î {,,n} mit y ¹ x: if Qj[y] = x then Rj[y] := if Qk[y] = x then Rk[y] := RegResult[Fi[x]] := ; busy[x] := WB[x] :=

63 Scoreboard: WB-Phase (Beispiel 6: WB bei Flussabhängigkeit) Fetch Issue RO Op A EX Execute WB Op B liest Register, das Op A schreibt Op E Op D Op B Registerbank Op B wartet deshalb auf Ergebnis von Op A in RO- Phase Scoreboard Execute 4 add r <- r2, r3 sub r4 <- r5, r // Op A // Op B EU Busy Op Fi Fj Fk Qj Qk Rj Rk Instr RO EX WB add r r2 r3 2 2 Op A 2 sub r4 r5 r Op B R R R2 R3 R4 R5 R6 R7 R8 R9 R 2

64 Scoreboard: WB-Phase (Beispiel 6: WB bei Flussabhängigkeit) Fetch Issue RO EX Execute Op A WB Op A schreibt gleiches Register, wie von Op B gelesen Op E Op D Op B Registerbank Aber: Op B wartet auf Op A, also Flussabhängigkeit und keine Gegenabhängigkeit Scoreboard Execute 4 add r <- r2, r3 sub r4 <- r5, r // Op A // Op B EU Busy Op Fi Fj Fk Qj Qk Rj Rk Instr RO EX WB add r r2 r3 2 2 Op A 2 sub r4 r5 r Op B R R R2 R3 R4 R5 R6 R7 R8 R9 R 2 Hazard erkannt prüfen

65 Scoreboard: Issue-Phase (Beispiel 6: WB bei Flussabhängigkeit) Fetch Issue RO EX Execute WB Op B kann RO-Phase erst verlassen, wenn Rk auf gesetzt wird Op E Op D Op B Registerbank Rk wurde auf gesetzt, weil Op A Ergebnis zurückgeschrieben hat Scoreboard Execute 4 add r <- r2, r3 sub r4 <- r5, r // Op A // Op B EU Busy Op Fi Fj Fk Qj Qk Rj Rk Instr RO EX WB 2 sub r4 r5 r Op B R R R2 R3 R4 R5 R6 R7 R8 R9 R 2 Hazard erkannt prüfen

66 Scoreboard: WB-Phase (Beispiel 7: RAW-Hazard auflösen) Fetch Issue RO EX WB Op B wartet auf Ergebnis von Op A Registerbank Execute Op A schreibt Register, das von Op B gelesen wird Gegenabhängigkeit; muss warten Unterschied zu vorigem Beispiel: Op B wartet nicht auf Ergebnis von (erkennbar an Qj = ) Op B Scoreboard Execute 4 lw r3,(r5) // Op A add r <- r2, r3 // Op B sub r2 <- r4, r // EU Busy Op Fi Fj Fk Qj Qk Rj Rk Instr RO EX WB lw r3 r5-2 2 Op A 2-3 sub r2 r4 r 4 add r r2 r3 Op B R R R2 R3 R4 R5 R6 R7 R8 R9 R 4 3 Hazard erkannt prüfen

67 Scoreboard: WB-Phase (Beispiel 7: RAW-Hazard auflösen) Fetch Issue RO EX Execute Op A WB Op A schreibt r3, das auch von Op B gelesen wird Op B Registerbank Execute 4 Scoreboard Op B wartet aber auf Ergebnis von EU ; also Flussabhängigkeit Op A kann abgeschlossen werden lw r3,(r5) // Op A add r <- r2, r3 // Op B sub r2 <- r4, r // EU Busy Op Fi Fj Fk Qj Qk Rj Rk Instr RO EX WB lw r3 r5-2 2 Op A 2-3 sub r2 r4 r 4 add r r2 r3 Op B R R R2 R3 R4 R5 R6 R7 R8 R9 R 4 3 Hazard erkannt prüfen

68 Scoreboard: WB-Phase (Beispiel 7: RAW-Hazard auflösen) Fetch Issue RO Registerbank EX Execute WB Durch den Abschluss von Op A wird Rk[4] auf gesetzt, weil Operand jetzt in r3 vorhanden Damit kann Op B ihre Operanden lesen Op B Execute 4 Scoreboard lw r3,(r5) // Op A add r <- r2, r3 // Op B sub r2 <- r4, r // EU Busy Op Fi Fj Fk Qj Qk Rj Rk Instr RO EX WB sub r2 r4 r 4 add r r2 r3 Op B R R R2 R3 R4 R5 R6 R7 R8 R9 R 4 3 Hazard erkannt prüfen

69 Scoreboard: WB-Phase (Beispiel 7: RAW-Hazard auflösen) Fetch Issue RO EX WB Op B liest Operanden Registerbank Execute Rj[4] und Rk[4] werden auf 2 gesetzt Damit kann in R2 schreiben Op B Scoreboard Execute 4 lw r3,(r5) // Op A add r <- r2, r3 // Op B sub r2 <- r4, r // EU Busy Op Fi Fj Fk Qj Qk Rj Rk Instr RO EX WB sub r2 r4 r 4 add r r2 r3 2 2 Op B R R R2 R3 R4 R5 R6 R7 R8 R9 R 4 3 Hazard erkannt prüfen

70 RAW vs. WAR Flussabhängigkeit liegt in WB-Phase vor: Zielregister der Operation A in WB-Phase ist identisch mit Quellregister einer Operation B in RO-Phase Gegenabhängigkeit liegt in WB-Phase vor: Zielregister der Operation A in WB-Phase ist identisch mit Quellregister einer Operation B in RO-Phase Aber: Op B wartet auf Ergebnis von Op A, weil Op B nach Op A ausgegeben wurde Aber: Op B wartet nicht auf Ergebnis von Op A, weil Op B vor Op A ausgegeben wurde

71 Performanceprobleme vom Scoreboard Bei WAW-Hazard ist Fetch-Phase komplett blockiert Ausführungseinheiten bleiben ungenutzt Bei WAR-Hazard ist Ausführungseinheit blockiert, bis Schreiben erlaubt wird Ausführungseinheit kann nicht genutzt werden Lösung dieser Probleme durch Tomasulo-Algorithmus

72 Inhalt HW-Architekturen zur Implementierung dynamischer Ablaufplanung: Scoreboard Tomasulo-Algorithmus

73 Tomasulo-Algorithmus Eingeführt 967 für die Gleitkommaeinheiten der IBM36/9 von Robert Tomasulo IBM 36/9 hatte Gleitkommaeinheiten mit Pipelines (für den Algorithmus konzeptionell identisch mit superskalarem Datenpfad) Ziel: Auflösen von WAW- und WAR-Hazards ohne Pipeline-Stalls Umsetzung: Registerumbenennung mittels Reservation Station

74 Architektur für Tomasulo-Algorithmus Jeder Ausführungseinheit ist eine Menge von Reservation Stations (RS) zugeordnet RS speichern Operationen und (sobald vorhanden) die zugehörigen Operanden, bis Operation auf assoziierter EU ausgeführt wird Jede RS repräsentiert ein virtuelles Register Operandenbus A Operationsbus Reg Reg Reg 2 Reg r Operandenbus B RS RS 2 RS k + RS k + 2 RS k + RS k + 2 RS k m- + RS k m- + RS k RS k RS k 2 Memory Unit Execute RS k m EU-Bus EU-Bus EU-Bus EU-Bus Execute m Ergebnisbus

75 Reservation Station Jede RS hat eindeutige Nummer aus {,,k m } Wichtige Funktionen: Puffert Operation, bis alle Operanden bereitstehen Puffert Operanden, sobald sie berechnet wurden: EU, die diesen Operanden berechnet hat, wird dadurch sofort frei (im Gegensatz zum Scoreboard) Repräsentiert ein virtuelles Register Registerumbenennung dadurch möglich Auszuführende Operation (z.b. add, sub, mul, ) Qj = x, wenn RS x die Operation enthält, die den Wert für Operand A berechnet, sonst Qk = x, wenn RS x die Operation enthält, die den Wert für Operand B berechnet, sonst Wert für Operand A Wert für Operand B Steuerflussabhängigkeiten beachten RS ist belegt Operandenbus A Operationsbus Operandenbus B DeMux opc Qj Qk Vj Vk busy RS k i + opc Qj Qk Vj Vk busy RS k i + 2 opc Qj Qk Vj Vk busy RS k i + Mux Reservation Station für EU k i+ EU-Bus

76 Registerbankerweiterung Für jedes Architekturregister n ist die RS x bekannt, die die letzte Operation enthält, die den Wert für n berechnet (Umbenennung von n in virtuelles Register x) Ergebnisbus Reg[n].Qj = x, wenn RS x die letzte Operation aus dem Befehlsstrom enthält, die gerade den Wert für Reg n berechnet, sonst Reg Reg Reg 2 Qj Qj Qj.Q = x, wenn RS x eine Sprungoperation speichert Reg r Qj Q Operandenbus A Operandenbus B Ermöglicht die Abbildung von Architekturregistern auf virtuelle Register (Reservation Stations) Beispiel: Reg Reg Reg 2 5 RS 5 enthält letzte Operation mit Zielregister Register wird gerade von keiner Operation berechnet RS enthält letzte Operation mit Zielregister 2 Reg r

77 Überblick Pipeline-Phasen Issue Eine Operation aus der an eine Reservation Station und die assoziierte EU ausgeben Operanden müssen noch nicht berechnet worden sein Ausgabe ist in-order Execute Warten auf Operanden und auf Verfügbarkeit der EU Operationen ausführen, sobald Operanden verfügbar und EU frei Ausführung ist out-of-order Write-Back Ergebnis über Ergebnisbus in Registerbank schreiben Alle Reservation-Stations, die den Wert brauchen, lesen ihn auch vom Operandenbus Abschluss out-of-order

78 Issue - Details Für vorderste Operation in sei: opc die auszuführende Operation (add, sub, mul, ) src, src2 die zwei Quelloperanden (Register) dst der Zieloperand (Register) Zuteilung an RS x möglich, falls RS[x].busy = Mit RS x assozierte EU die Operation ausführen kann Reg[r].Qj Aktualisierung nach Zuteilung If Reg[src].Qj ¹ then RS[x].Qj := Reg[src].Qj else RS[x].Qj := ; RS[x].Vj := Reg[src].Qj If Reg[src2].Qk ¹ then RS[x].Qk := Reg[src2].Qk else RS[x].Qk := ; RS[x].Vk := Reg[src2].Qk RS[x].busy := ; RS[].Q :=.Q Operandenbus A Operationsbus RS[i].busy R: 5 R: 67 R2: 89 R3: 8 R4: 7 Operandenbus B If opc = Sprungoperation Then.Q := x Else Reg[dst].Qj := x; RS RS 2 RS 3 RS 4 RS 5 RS 6 EU-Bus EU-Bus EU-Bus Memory Unit Execute Ergebnisbus

79 Tomasulo: Issue (Beispiel : Alle Operanden bereit) Situation: Alle Operanden stehen in Architekturregistern R bis R3 bereit Op A kann auf EU und EU 2 ausgeführt werden add r <- r2, r3 sub r4 <- r, r // Op A // Op B Prüfen: RS[x].busy = Mit RS x assozierte EU die Operation ausführen kann Ergebnis des Prüfens: Zuordnung von Op A an RS3 bis RS4 möglich Operandenbus A Operationsbus Op B Op A RS[i].busy R: 5 R: 67 R2: 89 R3: 8 R4: 7 Reg[r].Qj Operandenbus B RS RS 2 RS 3 RS 4 RS 5 RS 6 EU-Bus EU-Bus EU-Bus Memory Unit Execute Ergebnisbus

80 Tomasulo: Issue (Beispiel : Alle Operanden bereit) Situation: Op A wurde RS 4 zugeordnet Benötigte Operanden wurden gelesen und in RS gepuffert R umbenannt in virtuelles Register RS4 add r <- r2, r3 sub r4 <- r, r // Op A // Op B Aktualisieren der RS[x]-Einträge für x = 4: If Reg[src].Qj ¹ then RS[x].Qj := Reg[src].Qj else RS[x].Qj := ; RS[x].Vj := Reg[src].Qj If Reg[src2].Qk ¹ then RS[x].Qk := Reg[src2].Qk else RS[x].Qk := ; RS[x].Vk := Reg[src2].Qk RS[x].busy := ; Reg[dst].Qj := x; Operandenbus A Operationsbus Op D Op B RS[i].busy R: 5 R: 67 R2: 89 4 R3: 8 R4: 7 Reg[r].Qj Operandenbus B opc Qj Qk Vj Vk busy add 89 8 RS RS 2 Memory Unit Op A RS 3 RS 4 Execute RS 5 RS 6 EU-Bus EU-Bus EU-Bus Ergebnisbus

81 Tomasulo: Issue (Beispiel 2: RAW-Hazard verhindern) Situation: Rechter Operand von B wird gerade noch berechnet Op B kann auf EU und EU 2 ausgeführt werden add r <- r2, r3 sub r4 <- r, r // Op A // Op B Prüfen: RS[x].busy = Mit RS x assozierte EU die Operation ausführen kann Ergebnis des Prüfens: Zuordnung von Op B an RS3, RS5 und RS6 möglich Operandenbus A Operationsbus Op D Op B RS[i].busy R: 5 R: 67 R2: 89 4 R3: 8 R4: 7 Reg[r].Qj Operandenbus B opc Qj Qk add Vj Vk busy 89 8 RS RS 2 Memory Unit Op A RS 3 RS 4 Execute RS 5 RS 6 EU-Bus EU-Bus EU-Bus Ergebnisbus

82 Tomasulo: Issue (Beispiel 2: RAW-Hazard verhindern) Situation: Op B wurde RS 5 zugeordnet Op B muss auf Ergebnis von RS 4 warten (RS[5].Qk = 4) Aktualisieren der RS[x]-Einträge für x = 5: If Reg[src].Qj ¹ then RS[x].Qj := Reg[src].Qj else RS[x].Qj := ; RS[x].Vj := Reg[src].Qj If Reg[src2].Qk ¹ then RS[x].Qk := Reg[src2].Qk else RS[x].Qk := ; RS[x].Vk := Reg[src2].Qk RS[x].busy := ; Reg[dst].Qj := x; Operandenbus A Operationsbus Op E Op D RS[i].busy add r <- r2, r3 sub r4 <- r, r R: 5 R: 67 R2: 89 4 R3: 8 R4: 7 5 // Op A // Op B Reg[r].Qj Operandenbus B RS RS 2 Op A RS 3 RS 4 Op B RS 5 RS 6 opc Qj Qk Vj Vk sub busy Memory Unit EU-Bus EU-Bus EU-Bus Execute opc Qj Qk Vj Vk add 89 8 busy Ergebnisbus

83 Tomasulo: Issue (Beispiel 3: WAW-Hazard verhindern) Situation: Op A hat unter Anderem Ausgabeabhängigkeit zu Scoreboard würde Pipeline anhalten Prüfen: RS[x].busy = Mit RS x assozierte EU die Operation ausführen kann Ergebnis des Prüfens: Zuordnung von an RS3 und RS6 möglich Operandenbus A Operationsbus Op E Op D RS[i].busy add r <- r, r3 sub r4 <- r, r mul r <- r2,r3 R: 5 R: 67 R2: 89 4 R3: 8 R4: 7 5 Reg[r].Qj // Op A // Op B // Operandenbus B RS RS 2 Op A RS 3 RS 4 Op B RS 5 RS 6 opc Qj Qk Vj Vk sub busy Memory Unit EU-Bus EU-Bus EU-Bus Op A Execute opc Qj Qk Vj Vk add 5 8 busy Ergebnisbus

84 Tomasulo: Issue (Beispiel 3: WAW-Hazard verhindern) Situation: wurde RS 3 zugeordnet Wert für R wird von zwei Operationen berechnet R nimmt Ergebnis aber nur von RS3 an (letzte Operation, die in R schreibt) add r <- r, r3 sub r4 <- r, r mul r <- r2,r3 // Op A // Op B // Aktualisieren der RS[x]-Einträge für x = 3: If Reg[src].Qj ¹ then RS[x].Qj := Reg[src].Qj else RS[x].Qj := ; RS[x].Vj := Reg[src].Qj If Reg[src2].Qk ¹ then RS[x].Qk := Reg[src2].Qk else RS[x].Qk := ; RS[x].Vk := Reg[src2].Qk RS[x].busy := ; Reg[dst].Qj := x; opc Qj Qk Vj Vk mul 89 8 opc Qj Qk Vj Vk sub busy busy Operandenbus A Operationsbus RS RS 2 Memory Unit RS 3 Op A RS 4 Execute R: 5 R: 67 R2: 89 RS 5 RS 6 EU-Bus EU-Bus EU-Bus Op A Op F Op E Op D RS[i].busy Op B 3 R3: 8 R4: 7 5 Reg[r].Qj Operandenbus B opc Qj Qk Vj Vk add 89 8 busy Ergebnisbus

85 Execute-Phase EU kann Operation von assoziierter RS x ausführen, falls: RS[x].Qj = und RS[x].Qk = RS[x]. = (Operationen nicht spekulativ ausführen) RS[x]. ¹, gdw. es noch eine Sprungoperation gibt, die noch nicht ausgeführt wurde

86 Tomasulo: Execute (Noch einmal Beispiel : Alle Operanden bereit) Situation: Op A wurde RS 4 (x = 4) zugeordnet Prüfen von RS[x].Qj = und RS[x].Qk = add r <- r2, r3 sub r4 <- r, r // Op A // Op B Reg[r].Qj Operandenbus A Operationsbus Op D Op B RS[i].busy R: 5 R: 67 R2: 89 4 R3: 8 R4: 7 Operandenbus B RS RS 2 Op A RS 3 RS 4 RS 5 RS 6 opc Qj Qk Vj Vk add 89 8 busy Memory Unit EU-Bus EU-Bus EU-Bus Execute Ergebnisbus

87 Tomasulo: Execute (Noch einmal Beispiel : Alle Operanden bereit) Situation: Operation RS[4].opc mit Operanden RS[4].Vj und RS[4].Vk ausführen RS 4 speichert Status von Op A add r <- r2, r3 sub r4 <- r, r // Op A // Op B RS 4 kann erst wieder eine neue Operation annehmen, wenn Op A abgeschlossen ist Reg[r].Qj Operandenbus A Operationsbus Op D Op B RS[i].busy R: 5 R: 67 R2: 89 4 R3: 8 R4: 7 Operandenbus B RS RS 2 Op A RS 3 RS 4 RS 5 RS 6 opc Qj Qk Vj Vk add 89 8 busy Memory Unit EU-Bus EU-Bus EU-Bus Op A Execute Ergebnisbus

88 Tomasulo: Execute (Beispiel 4: Abhängigkeit zu Sprungoperation) Situation: Op Z wurde an RS 6 ausgegeben wartet auf Ergebnis von RS 6 Op A wurde an RS 4 ausgegeben bne loop, r,2 add r <- r2, r3 sub r4 <- r, r // Op Z // Op A // Op B Prüfen für x = 4: RS[x].Qj = und RS[x].Qk = RS[x]. = Prüfen ergibt: Op A kann noch nicht ausgeführt werden Operandenbus A Operationsbus Op D Op B 6 RS[i].busy R: 5 R: 67 R2: 89 4 R3: 8 R4: 7 Reg[r].Qj Operandenbus B RS RS 2 Op A RS 3 RS 4 Op Z RS 5 RS 6 opc Qj Qk Vj Vk add busy Memory Unit EU-Bus EU-Bus EU-Bus Execute Ergebnisbus

89 Write-Back-Phase Es sei: res das Ergebnis der Operation, die RS x zugeordnet wurde Write-Back für wird ausgeführt, wenn: Berechnung von res beendet ist und Ergebnisbus steht zur Verfügung Aktualisierung der Tabellen wie folgt: Für alle r: If Reg[r].Qi = x then Reg[r] := res; Reg[r].Qj := Für alle y: If RS[y].Qj = x then RS[y].Qj := ; RS[y].Vj := res Für alle y: If RS[y].Qk = x then RS[y].Qk := ; RS[y].Vk := res Nur die letzte Operation mit Zielregister r schreibt in Architekturregister zurück (WAW auflösen) Bypass: res wird von Operationen in Reservation Stations nicht über Architekturregister gelesen, sondern direkt von der EU RS[x].busy :=

90 Tomasulo: WB (Beispiel 5: Alle Operanden bereit) Situation: Ergebnis von Op A wurde berechnet Aktualisieren der RS[x]-Einträge für x = 4: Für alle r: If Reg[r].Qi = x then Reg[r] := res; Reg[r].Qj := Für alle y: If RS[y].Qj = x then RS[y].Qj := ; RS[y].Vj := res Für alle y: If RS[y].Qk = x then RS[y].Qk := ; RS[y].Vk := res RS[x].busy := Operandenbus A Operationsbus Op D Op B RS[i].busy add r <- r2, r3 sub r4 <- r, r R: 5 R: 67 R2: 89 4 R3: 8 R4: 7 // Op A // Op B Reg[r].Qj Operandenbus B opc Qj Qk Vj Vk busy add 89 8 RS RS 2 Memory Unit RS 3 Op RS A 4 Execute Op A RS 5 RS 6 EU-Bus EU-Bus EU-Bus Ergebnisbus

91 Tomasulo: WB (Beispiel 5: Alle Operanden bereit) Situation: Ergebnis von Op A wurde berechnet Ergebnis wird nur in R zurückgeschrieben add r <- r2, r3 sub r4 <- r, r // Op A // Op B Aktualisieren der RS[x]-Einträge für x = 4: Für alle r: If Reg[r].Qi = x then Reg[r] := res; Reg[r].Qj := Für alle y: If RS[y].Qj = x then RS[y].Qj := ; RS[y].Vj := res Für alle y: If RS[y].Qk = x then RS[y].Qk := ; RS[y].Vk := res RS[x].busy := Operandenbus A Operationsbus Op D Op B RS[i].busy R: 5 R: 97 R2: 89 R3: 8 R4: 7 Reg[r].Qj Operandenbus B opc Qj Qk Vj Vk busy add 89 8 RS RS 2 Memory Unit RS 3 RS 4 Execute RS 5 RS 6 EU-Bus EU-Bus EU-Bus Ergebnisbus

92 Tomasulo: WB (Beispiel 6: RAW-Hazard auflösen) Situation: Op B benötigt als rechten Operanden das Ergebnis von Op A Op A kann zur Ausführung gebracht werden add r <- r2, r3 sub r4 <- r, r // Op A // Op B Reg[r].Qj Operandenbus A Operationsbus Op D Op B RS[i].busy R: 5 R: 67 R2: 89 4 R3: 8 R4: 7 Operandenbus B opc Qj Qk add Vj Vk busy 89 8 RS RS 2 Memory Unit RS 3 Op RS A 4 Execute RS 5 RS 6 EU-Bus EU-Bus EU-Bus Ergebnisbus

93 Tomasulo: WB (Beispiel 6: RAW-Hazard auflösen) Situation: Op B wurde RS 5 zugeordnet Op B kann erst ausgeführt werden, wenn Qj = und Qk = add r <- r2, r3 sub r4 <- r, r // Op A // Op B Reg[r].Qj Op A wird abgeschlossen Ergebnis wird geschrieben in R, weil Reg[].Qj = 4 RS[5].Vk, weil RS[5].Qk = 4 Operandenbus A Operationsbus Op E Op D RS[i].busy R: 5 R: 67 R2: 89 4 R3: 8 R4: 7 5 Operandenbus B RS RS 2 Op A RS 3 RS 4 RS Op 5 B RS 6 opc Qj Qk Vj Vk sub busy Memory Unit EU-Bus EU-Bus EU-Bus Op A Execute opc Qj Qk Vj Vk add 89 8 busy Ergebnisbus

94 Tomasulo: WB (Beispiel 6: RAW-Hazard auflösen) Aktualisierte Einträge: Für alle r: If Reg[r].Qi = x then Reg[r] := res; Reg[r].Qj := Für alle y: If RS[y].Qj = x then RS[y].Qj := ; RS[y].Vj := res Für alle y: If RS[y].Qk = x then RS[y].Qk := ; RS[y].Vk := res RS[x].busy := Situation Op B kann jetzt ausgeführt werden Operandenbus A Operationsbus Op E Op D RS[i].busy add r <- r2, r3 sub r4 <- r, r R: 5 R: 97 R2: 89 R3: 8 R4: 7 5 // Op A // Op B Reg[r].Qj Operandenbus B RS RS 2 Op A RS 3 RS 4 RS Op 5 B RS 6 opc Qj Qk Vj Vk sub 5 97 busy Memory Unit EU-Bus EU-Bus EU-Bus Execute opc Qj Qk Vj Vk add 89 8 busy Ergebnisbus

95 Tomasulo: WB (Beispiel 7: WAW-Hazard auflösen) Situation: Op A muss lange auf Ergebnis in R warten Op B muss auf Ergebnis von Op A warten add r <- r, r3 sub r4 <- r, r mul r <- r2,r3 // Op A // Op B // Reg[r].Qj Issue-Phase: kann RS 5 zugeordnet werden Operandenbus A Operationsbus Op E Op D RS[i].busy R: 5 R: 67 R2: R3: 8 R4: 7 3 Operandenbus B ld RS RS 2 Op B Op A RS 3 RS 4 RS 5 RS 6 opc Qj Qk Vj Vk sub busy Memory Unit EU-Bus EU-Bus EU-Bus Execute opc Qj Qk Vj Vk add 2-8 busy Ergebnisbus

96 Tomasulo: WB (Beispiel 7: WAW-Hazard auflösen) Situation: R bekommt jetzt seinen Wert von RS 5 kann sofort ausgeführt werden überholt A und B add r <- r, r3 sub r4 <- r, r mul r <- r2,r3 // Op A // Op B // Reg[r].Qj opc Qj Qk Vj Vk mul 89 8 busy Operationsbus Op F Op E Op D RS[i].busy R: 5 R: 67 R2: R3: 8 R4: 7 3 Operandenbus B ld RS RS 2 Op B Op A RS 3 RS 4 RS 5 RS 6 opc Qj Qk Vj Vk sub busy Memory Unit EU-Bus EU-Bus EU-Bus Execute opc Qj Qk Vj Vk add 2-8 busy Ergebnisbus

97 Tomasulo: WB (Beispiel 7: WAW-Hazard auflösen) Situation: wird ausgeführt und schreibt Ergebnis in R zurück add r <- r, r3 sub r4 <- r, r mul r <- r2,r3 // Op A // Op B // Reg[r].Qj Ist jetzt ein WAW-Hazard entstanden? opc Qj Qk Vj Vk mul 89 8 busy Operationsbus Op F Op E Op D RS[i].busy R: 5 R: 67 R2: R3: 8 R4: 7 3 Operandenbus B ld RS RS 2 Op B Op A RS 3 RS 4 RS 5 RS 6 opc Qj Qk Vj Vk sub busy Memory Unit EU-Bus EU-Bus EU-Bus Execute Op Execute C 2 opc Qj Qk Vj Vk add 2-8 busy Ergebnisbus

98 Tomasulo: WB (Beispiel 7: WAW-Hazard auflösen) Situation: Nein: Op B holt sich Ergebnis nicht aus R sondern von RS 4 add r <- r, r3 sub r4 <- r, r mul r <- r2,r3 // Op A // Op B // Reg[r].Qj opc Qj Qk Vj Vk mul 89 8 busy Operationsbus Op F Op E Op D RS[i].busy R: 5 R: 72 R2: 89 2 R3: 8 R4: 7 3 Operandenbus B ld RS RS 2 Op B Op A RS 3 RS 4 RS 5 RS 6 opc Qj Qk Vj Vk sub busy Memory Unit EU-Bus EU-Bus EU-Bus Execute opc Qj Qk Vj Vk add 2-8 busy Ergebnisbus

99 Tomasulo: WB (Beispiel 8: WAR-Hazard verhindern) Situation: Op B muss auf Ergebnis in R warten Wert aus R wurde bereits gelesen sub r4 <- r, r mul r <- r3,r // Op B // Reg[r].Qj Operandenbus A Operationsbus Op E Op D RS[i].busy R: 5 R: 67 R2: 89 2 R3: 8 R4: 7 5 Operandenbus B ld RS RS 2 RS 3 RS 4 Op B RS 5 RS 6 opc Qj Qk Vj Vk sub 2-67 busy Memory Unit EU-Bus EU-Bus EU-Bus Execute Ergebnisbus

100 Tomasulo: WB (Beispiel 8: WAR-Hazard verhindern) Situation: wird RS 4 zugeordnet Operanden sind vorhanden sub r4 <- r, r mul r <- r3,r // Op B // Reg[r].Qj Operandenbus A Operationsbus Op F Op E Op D RS[i].busy R: 5 R: 67 R2: R3: 8 R4: 7 5 Operandenbus B ld RS RS 2 RS 3 RS 4 Op B RS 5 RS 6 opc Qj Qk Vj Vk sub 2-67 busy Memory Unit EU-Bus EU-Bus EU-Bus Execute opc Qj Qk Vj Vk mul 8 67 busy Ergebnisbus

101 Tomasulo: WB (Beispiel 8: WAR-Hazard verhindern) Situation: wird ausgeführt und schreibt Ergebnis in R zurück sub r4 <- r, r mul r <- r3,r // Op B // Reg[r].Qj Anmerkung: Scoreboard würde Abschluss von verzögern Operandenbus A Operationsbus Op F Op E Op D RS[i].busy R: 5 R: 67 R2: R3: 8 R4: 7 5 Operandenbus B ld RS RS 2 RS 3 RS 4 Op B RS 5 RS 6 opc Qj Qk Vj Vk sub 2-67 busy Memory Unit EU-Bus EU-Bus EU-Bus Execute opc Qj Qk Vj Vk mul 8 67 busy Ergebnisbus

102 Tomasulo: WB (Beispiel 8: WAR-Hazard verhindern) Situation: WAR-Hazard entsteht nicht, weil R bereits ausgelesen wurde sub r4 <- r, r mul r <- r3,r // Op B // Reg[r].Qj Operandenbus A Operationsbus Op F Op E Op D RS[i].busy R: 5 R: 536 R2: 89 2 R3: 8 R4: 7 5 Operandenbus B ld RS RS 2 RS 3 RS 4 RS Op 5 B RS 6 opc Qj Qk Vj Vk sub 2-67 busy Memory Unit EU-Bus EU-Bus EU-Bus Execute opc Qj Qk Vj Vk mul 8 67 busy Ergebnisbus

103 Tomasulo (Beispiel 9: Schleifenausführung, Takt ) Loop: ld r <- (r) mul r4 <- r, r2 add r3 <- r3, r4 add r <- r, bne loop, r,2 Operandenbus A Operationsbus add r3,r3,r4 mul r4,r,r2 ld r,(r) R: R: R2: 3 R3: R4: Operandenbus B RS RS 2 RS 3 RS 4 RS 5 RS 6 EU-Bus EU-Bus EU-Bus Memory Unit Execute Ergebnisbus

104 Tomasulo (Beispiel 9: Schleifenausführung, Takt ) Loop: ld r <- (r) mul r4 <- r, r2 add r3 <- r3, r4 add r <- r, bne loop, r,2 Operandenbus A Operationsbus add r,r, add r3,r3,r4 mul r4,r,r2 R: R: R2: 3 R3: R4: Operandenbus B ld r,() RS RS 2 RS 3 RS 4 RS 5 RS 6 EU-Bus EU-Bus EU-Bus Memory Unit Execute Ergebnisbus

105 Tomasulo (Beispiel 9: Schleifenausführung, Takt 2) Loop: ld r <- (r) mul r4 <- r, r2 add r3 <- r3, r4 add r <- r, bne loop, r,2 Operandenbus A Operationsbus bne loop,r,2 add r,r, add r3,r3,r4 R: R: R2: 3 R3: R4: 3 Operandenbus B ld r,() RS RS 2 mul r4,rs,3 RS 3 RS 4 RS 5 RS 6 EU-Bus EU-Bus EU-Bus Memory ld r,() Unit Execute Ergebnisbus

106 Tomasulo (Beispiel 9: Schleifenausführung, Takt 3) Loop: ld r <- (r) mul r4 <- r, r2 add r3 <- r3, r4 add r <- r, bne loop, r,2 Operandenbus A Operationsbus ld r,(r) bne loop,r,2 add r,r, R: R: R2: 3 R3: 4 R4: 3 Operandenbus B ld r,() RS RS 2 mul r4,rs,3 add r3,,rs3 RS 3 RS 4 RS 5 RS 6 EU-Bus EU-Bus EU-Bus Memory ld r,() Unit Execute Ergebnisbus

107 Tomasulo (Beispiel 9: Schleifenausführung, Takt 4) Loop: ld r <- (r) mul r4 <- r, r2 add r3 <- r3, r4 add r <- r, bne loop, r,2 Operandenbus A Operationsbus mul r4,r,r2 ld r,(r) bne loop,r,2 R: 2 R: R2: 3 5 R3: 4 R4: 3 Operandenbus B ld r,() RS RS 2 mul r4,2,3 add r3,,rs3 RS 3 RS 4 add r,, RS 5 RS 6 EU-Bus EU-Bus EU-Bus Memory Unit Execute Ergebnisbus

108 Tomasulo (Beispiel 9: Schleifenausführung, Takt 5) Loop: ld r <- (r) mul r4 <- r, r2 add r3 <- r3, r4 add r <- r, bne loop, r,2 6 Operandenbus A Operationsbus add r3,r3,r4 mul r4,r,r2 ld r,(r) R: 2 R: R2: 3 5 R3: 4 R4: 3 Operandenbus B RS RS 2 mul r4,2,3 add r3,,rs3 RS 3 RS 4 add r,, bne loop,rs5,2 RS 5 RS 6 EU-Bus EU-Bus EU-Bus Memory Unit mul Execute r4,2,3 add Execute r,, 2 Ergebnisbus

109 Tomasulo (Beispiel 9: Schleifenausführung, Takt 6) Loop: ld r <- (r) mul r4 <- r, r2 add r3 <- r3, r4 add r <- r, bne loop, r,2 6 Operationen werden spekulativ geholt und dekodiert Operandenbus A Operationsbus add r,r, add r3,r3,r4 mul r4,r,r2 R: 2 R: R2: 3 R3: 4 R4: 26 Operandenbus B Es befinden sich Operationen aus verschiedenen Iterationen gleichzeitig in der Pipeline ld r,(),rs6 Memory Unit RS RS 2 mul r4,2,3 add r3,,26 Execute RS 3 RS 4 EU-Bus EU-Bus EU-Bus add r,, bne loop,,2 RS 5 RS 6 Ergebnisbus

110 Tomasulo (Beispiel 9: Schleifenausführung, Takt 7) Loop: ld r <- (r) mul r4 <- r, r2 add r3 <- r3, r4 add r <- r, bne loop, r,2 6 Operandenbus A Operationsbus bne loop,r,2 add r,r, add r3,r3,r4 R: 2 R: R2: 3 R3: 4 R4: 26 3 Operandenbus B ld r,(),rs6 RS RS 2 mul r4,rs,3,rs6 add r3,,26 RS 3 RS 4 bne loop,,2 RS 5 RS 6 EU-Bus EU-Bus EU-Bus Memory Unit add Execute r3,,26 bne loop,,2 Ergebnisbus

111 Tomasulo (Beispiel 9: Schleifenausführung, Takt 8) Loop: ld r <- (r) mul r4 <- r, r2 add r3 <- r3, r4 add r <- r, bne loop, r,2 Operandenbus A Operationsbus R: 2 R: ld r,(r) R2: 3 bne loop,r,2 R3: 26 add r,r, 5 R4: 26 3 Operandenbus B ld r,() RS mul r4,rs,3 RS 3 add r3,26,rs3 RS 5 RS 2 add r3,,26 RS 4 bne loop,,2 RS 6 EU-Bus EU-Bus EU-Bus Memory Unit Execute Ergebnisbus

112 Tomasulo (Beispiel 9: Schleifenausführung, Takt 9) Loop: ld r <- (r) mul r4 <- r, r2 add r3 <- r3, r4 add r <- r, bne loop, r,2 Operandenbus A Operationsbus mul r4,r,r2 ld r,(r) bne loop,r,2 R: 2 R: R2: 3 R3: R4: 26 3 Operandenbus B ld r,() RS RS 2 mul r4,rs,3 add r,, RS 3 RS 4 add r3,26,rs3 RS 5 RS 6 EU-Bus EU-Bus EU-Bus Memory ld r,() Unit Execute Ergebnisbus

113 Zusammenfassung Tomasulo-Algorithmus ermöglicht Das Auflösen von RAW-Hazards (Puffern von Operationen in RS) Das Auflösen von WAR-Hazards (Puffern von Operanden in RS + Registerumbenennung) Das Auflösen von WAW-Hazards (Registerumbenennung) Eliminierung von Hazards möglich, die durch statische Ablaufplanung nicht eliminiert werden können, weil mehr RS-Plätze als Architekturregister vorhanden Dezentralisierte Hazarderkennung (Scoreboard: zentralisiert) Spekulatives Holen (Fetchen) und Dekodieren von Operationen wird unterstützt Keine spekulative Ausführung möglich