Pipelining
Die Pipelining‐Idee
Annahme die einzelnen Abschnitte des MIPS‐Instruktionszyklus benötigen folgende Ausführungszeiten:
Instruction‐Fetch 200ps, Register‐Read 100ps, ALU‐Operation 200ps, Data‐Access 200ps, Register‐Write 100ps.
Wie hoch dürfen wir unseren Prozessor (ungefähr) Takten?
Die längste Instruktion benötigt 800ps. Also gilt für den Clock‐Cycle c:
Single‐Cycle‐Performance
Bildquelle: David A. Patterson und John L. Hennessy, „Computer Organization and Design“, Fourth Edition, 2012
Die Pipelining‐Idee am Beispiel Wäsche waschen
Waschen Trocknen Falten
Einräumen Bearbeitungszeit pro
Wäscheladung bleibt dieselbe (Delay).
Gesamtzeit für alle Wäscheladungen sinkt (Throughput).
Was ist die Performance‐Ratio?
Annahme jeder Arbeitsgang beansprucht dieselbe Zeit. Was ist die Performance‐Ratio für n Wäscheladungen?
Generell für k „Pipeline‐Stufen“, d.h. k Arbeitsgänge und gleiche Anzahl Zeiteinheiten t pro Arbeitsgang?
Im Folgenden betrachten wir zunächst ein ganz einfaches Programm:
lw $1, 100($0) lw $2, 200($0) lw $3, 300($0) lw $4, 400($0) lw $5, 500($0)
Bemerkung: Da die MIPS‐Registernamen im Folgenden nicht von Bedeutung sind, geben wir in den Programmbeispielen häufig nur noch die Registernummern (z.B. wie oben $0 und $1) an. Außerdem betrachten wir das spezielle Zero‐Register momentan nicht.
Wie kann man die Pipelining‐Idee im Falle unseres MIPS‐Prozessors anwenden?
Pipelining für unseren MIPS‐Prozessor
Die Pipeline nach den ersten drei Instruktionen
Bildquelle: David A. Patterson und John L. Hennessy, „Computer Organization and Design“, Fourth Edition, 2012
Annahme:
IF = 200ps ID = 100ps EX = 200ps MEM = 200ps WB = 100ps
Was ist die Performance‐Ratio?
Wie eben gezeigt wäre für k Pipeline‐Stufen und eine große Zahl an ausgeführten Instruktionen die Performance‐Ratio gleich k, wenn jede Pipeline‐Stufe dieselbe Zeit beanspruchen würde.
Allerdings brauchen die einzelnen Stufen s1,...,sk unterschiedliche Zeiteinheiten: t1,..., tk. Somit ist die Performance‐Ratio für n
Instruktionen:
Mit den Zeiten aus dem vorigen Beispiel für n also:
Die Performance‐Ratio wird durch die langsamste Stufe bestimmt.
Taktung
Annahme die einzelnen Abschnitte des MIPS‐Instruktionszyklus benötigen die bisher betrachteten Ausführungszeiten:
Instruction‐Fetch 200ps, Register‐Read 100ps, ALU‐Operation 200ps, Data‐Access 200ps, Register‐Write 100ps.
Wie hoch dürfen wir unseren Prozessor (ungefähr) Takten? Die längste Stufe benötigt 200ps. Also gilt für den Clock‐Cycle c:
Achtung: Maximal mögliche Taktung hängt aber auch von anderen Faktoren ab. (Erinnerung: Power‐Wall).
Quiz
Welchen CPI‐Wert suggeriert das MIPS‐Pipelining‐Beispiel?
Achtung: der CPI‐Wert ist in der Regel höher, wie wir noch sehen.
Der Ansatz ist noch zu naiv
lw $1, 100($0) lw $2, 200($0)
lw $3, 300($0) lw $4, 400($0)
lw $5, 500($0) Beispiel:
Bildquelle: David A. Patterson und John L. Hennessy, „Computer Organization and Design“, Fourth Edition, 2012
IF ID EX MEM WB
Pipelining
Pipeline‐Register
Pipeline‐Stufen brauchen Pipeline‐Register
Bildquelle: David A. Patterson und John L. Hennessy, „Computer Organization and Design“, Fourth Edition, 2012
Pipeline‐Stufen brauchen Pipeline‐Register
Control …
Änderung im Tafelbild
Write‐Register darf erst in der WB‐Stufe gesetzt werden.
RegDst steht mit der Entscheidung von Control erst in der EX‐Stufe fest.
Wird durchgereicht
Was speichern die Pipeline‐Register?
Wir schauen uns den Weg einer einzigen Instruktion durch die Pipeline an; und zwar den der Load‐Word‐Instruktion lw.
Auf dem Weg durch die Pipeline überlegen wir, was alles in den Pipeline‐Registern IF/ID, ID/EX, EX/MEM und MEM/WB stehen muss.
In der Darstellung verwenden wir folgende Konvention.
Bedeutet: Register/Speicher wird gelesen Bedeutet: Register/Speicher wird beschrieben
Was speichern die Pipeline‐Register?
IF/ID:
• Instruktion
• PC+4 (z.B. für beq)
Was speichern die Pipeline‐Register?
ID/EX:
• PC+4 (z.B. für beq)
• Inhalt Register 1
• Inhalt Register 2
• Sign‐ext. Immediate (z.B. für beq)
• Das Write‐Register
(wird im Letzten Zyklus von lw gebraucht)
Generell: Alles was in einem späteren Clock‐Cycle noch verwendet werden könnte, muss
durchgereicht werden.
Bildquelle: David A. Patterson und John L. Hennessy, „Computer Organization and Design“, Fourth Edition, 2012
Was speichern die Pipeline‐Register?
EX/MEM:
• Ergebnis von PC+4+
Offset (z.B. für beq)
• Zero der ALU (z.B. für beq)
• Result der ALU • Register 2 Daten (z.B. für sw)
• Das Write‐Register (wird im letzten Zyklus von lw gebraucht)
Was speichern die Pipeline‐Register?
MEM/WB:
• Das gelesene Datum aus dem
Speicher (wird dann von
lw im nächsten Zyklus ins Write‐Register geschrieben)
• Das Ergebnis der ALU‐Operation (für die arithmetisch‐logischen Instruktionen)
Bildquelle: David A. Patterson und John L. Hennessy, „Computer Organization and Design“, Fourth Edition, 2012
Was speichern die Pipeline‐Register?
Für die letzte Pipeline‐Stufe braucht man kein Pipeline‐Register.
Zusätzlich wird noch Control‐Info gespeichert
Bildquelle: David A. Patterson und John L. Hennessy, „Computer Organization and Design“, Fourth Edition, 2012
Control …
Zusätzlich wird noch Control‐Info gespeichert
Control hängt von der
Instruktion ab.
Damit muss Control‐Info erst ab ID/EX‐
Register gespeichert werden.
Das ID/EX‐
Register muss bereitstellen:
• RegDst
• ALUOp (2)
• ALUSrc
Das EX/MEM‐
Register muss bereit stellen:
• Branch
•MemRead
•MemWrite
Werden durch‐
gereicht.
Das MEM/WB‐
Register muss bereit stellen:
• MemtoReg
• RegWrite
Pipelining
Pipelining‐Visualisierung
Pipelining‐Visualisierung
Zusammenfassung der vorhin implizit eingeführten Visualisierungen und Einführung einer neuen Visualisierung.
Wir betrachten folgenden Beispiel‐Code:
lw $10, 20($1) sub $11, $2, $3 add $12, $3, $4 lw $13, 24($1) add $14, $5, $6
Wir unterscheiden generell zwischen zwei Visualisierungsarten:
Single‐Clock‐Cylce‐Pipeline‐Diagramm und Multiple‐Clock‐Cycle‐Pipeline‐Diagramm
Single‐Clock‐Cycle‐Pipeline‐Diagramm
Bildquelle: David A. Patterson und John L. Hennessy, „Computer Organization and Design“, Fourth Edition, 2012
Einfaches Multiple‐Clock‐Cycle‐Pipeline‐Diagramm
Detaillierteres Multiple‐Clock‐Cycle‐Pipeline‐Diagramm
Bildquelle: David A. Patterson und John L. Hennessy, „Computer Organization and Design“, Fourth Edition, 2012
IF ID EX MEM WB
Pipelining
Komplexere Pipelines
Komplexere Piplelines
• Pipeline‐Stufen sind nicht auf 5 festgelegt!
• z.B. weitere Unterteilung von IF, ID, EX, MEM, WB – Erlaubt höhere Taktung
– Kann aufgrund der Instruktions‐Komplexität erforderlich sein
– Kann aufgrund von Instruktionen mit zeitlich unbalancierten Stufen erforderlich sein
• Wie „pipelined“ man x86 ISA mit Instruktionslängen zwischen 1 und 17 Bytes?
– Komplexe Instruktionen der x86 ISA werden in Folge von Mikroinstruktionen übersetzt
– Mikroinstruktionssatz ist vom Typ RISC
– Pipelining findet auf den Mikroinstruktionen statt
• Beispiel AMD Opteron X4:
Was das ist sehen wir noch im Kapitel Multiple‐Issue
Bildquelle: David A. Patterson und John L. Hennessy, „Computer Organization and Design“, Fourth Edition, 2012
Pipeline‐Stufen einiger ausgewählter Prozessoren
Mikroprozesor Jahr Taktrate Pipeline‐Stufen Leistung
Intel 486 1989 25 MHz 5 5 W
Intel Pentium 1993 66 MHz 5 10 W
Intel Pentium Pro 1997 200 MHz 10 29 W
Intel Pentium 4 Willamette 2001 2000 MHz 22 75 W Intel Pentium 4 Prescott 2004 3600 MHz 31 103 W
Intel Core 2006 2930 MHz 14 75 W
UltraSPARC IV+ 2005 2100 MHz 14 90 W
Sun UltraSPARC T1 (Niagara) 2005 1200 MHz 6 70 W
Pipeline‐Stufen sinken wieder?
• Aggressives Pipelining ist sehr Leistungshungrig
• Aktueller Trend eher zu Multi‐Cores mit geringerer Leistungsaufnahme pro Core.
Data‐Hazards
Motivation
Ist die Pipelined‐Ausführung immer ohne Probleme möglich?
Beispiel:
sub $2, $1, $3 and $12, $2, $5 or $13, $6, $2 add $14, $2, $2 sw $15, 100($2)
Also, alle vier nachfolgenden Instruktionen hängen von der sub‐
Instruktion ab.
Annahme:
$2 speichert 10 vor der sub‐Instruktion.
$2 speichert ‐20 nach der sub‐Instruktion.
Betrachten wir die Pipeline:
sub $2, $1, $3 and $12, $2, $5 or $13, $6, $2 add $14, $2, $2 sw $15, 100($2)
Problem Rückwärtsabhängigkeiten
Instr.‐
Zeile
Sollte aus
$2 lesen
Liest aus $2 and
or add sw
Data‐Hazard
Bildquelle: David A. Patterson und John L. Hennessy, „Computer Organization and Design“, Fourth Edition, 2012
Behandeln von Data‐Hazards mittels Forwarding
Allgemeine Lösung mittels Forwarding‐Unit
Bildquelle: David A. Patterson und John L. Hennessy, „Computer Organization and Design“, Fourth Edition, 2012
0 1 2
0 1 2
WB WB
EX/MEM.Rd
MEM/WB.Rd
Implementation der Forwarding‐Unit
Bemerkungen
Die Bestimmung von ForwardB erfolgt analog. (Übung)
Das Ganze muss noch als Wahrheitstabelle aufgeschrieben und dann als kombinatorische Schaltung realisiert werden.
Wie sieht die Wahrheitstabelle von ForwardA nach voriger
hergeleiteter Vorschrift aus? (Übung) [Tipp: um Platz zu sparen sollte man möglichst viele „don‘t cares“ verwenden.]
Auch mit der Erweiterung auf ForwardB ist die Implementation der Forwarding‐Unit noch unvollständig. Was passiert z.B. für:
lw $2, 0($1) sw $2, 4($1)
Erweiterung: Forwarding muss z.B. auch in die MEM‐Stufe eingebaut werden. (Übung)
Nicht auflösbare Data‐Hazards
Nicht jeder Data‐Hazard lässt sich durch Forwarding
auflösen. Beispiel: Zugriff auf vorher gelesenes Register.
Pipeline‐Stall als Lösung
Bildquelle: David A. Patterson und John L. Hennessy, „Computer Organization and Design“, Fourth Edition, 2012
