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.

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: t ₁ ,..., t _k . 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:

IF      ID       EX       MEM      WB

Pipelining

Pipeline‐Register

Pipeline‐Stufen brauchen Pipeline‐Register

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  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.

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)

Was speichern die Pipeline‐Register?

Für die letzte 

Pipeline‐Stufe 

braucht man kein 

Pipeline‐Register.

Zusätzlich wird noch Control‐Info gespeichert

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

Einfaches Multiple‐Clock‐Cycle‐Pipeline‐Diagramm

Detaillierteres Multiple‐Clock‐Cycle‐Pipeline‐Diagramm

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

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

Behandeln von Data‐Hazards mittels Forwarding

Allgemeine Lösung mittels Forwarding‐Unit

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

Allgemeine Lösung mittels Hazard‐Detection‐Unit

Implementation der Hazard‐Detection‐Unit

Quiz: Vermeiden von Pipeline‐Stalls

lw $t1, 0($t0) lw $t2, 4($t0)

add $t3, $t1, $t2 sw $t3, 12($t0) lw $t4, 8($t0)

add $t5, $t1, $t4 sw $t5, 16($t0)

Wo findet  ein Pipe‐

line‐Stall  statt? Bitte  ankreuzen.

Bitte Befehle  umorganisie‐

ren, sodass  alle Stalls  vermieden  werden.

Anzahl Taktzyklen mit Stalls?

Anzahl Taktzyklen ohne Stalls?

Control‐Hazards

Control‐Hazards

Branch‐Not‐Taken‐Strategie und Pipeline‐Flush

Flush = Verwerfe  Instruktionen in der  Pipeline. Hier: Setze  IF/ID‐, ID/EX‐ und 

EX/MEM‐Register auf 0.

Reduktion des Branch‐Delays

• Adressberechnung kann schon in der  ID‐Stufe stattfinden

• beq und bne erfordert lediglich ein  32‐Bit‐XOR und ein 32‐Bit‐OR

– Dazu braucht man keine ALU

– Also auch in der ID‐Stufe realisierbar

• Damit ist der Sprung schon in der ID‐

Stufe entschieden

Beispiel: für $1 und $3: