5. Teil MIPS - Ra.informatik.tu-darmstadt.de - Technische UniversitÃ¤t ...

Kapitel 10 (5. Teil MIPS): 

Pipeline-Implementierung 

Technische Grundlagen der Informatik 2 

SS 2009 

R. Hoffmann 

FG Rechnerarchitektur 

Technische Universität Darmstadt 

In Anlehnung an das Patterson/Hennessy: Computer Organization & Design, 2 nd Edition, Chapter 6 

Es sind auch die Folien von Dr. M. G. Wahl (Univ. Siegen, Inst. Mikrosystemtechnik) und ähnliche 

aus den Grundzügen der Informatik II, SS03, von Prof. Dr. Oskar von Stryk verwendet worden.

Technische Grundlagen der Informatik 2, SS 09, R. Hoffmann, TUD 

Inhalt, Thema: Pipelining 

10–2 

Teil 1 


• Prinzip 

• Bearbeitungszeit 

• Anwendungen 

• Arithmetisches Pipelining 

• Prozessor-Pipelining 

• Befehlspipelining 

• Befehlspipelining bei MIPS 

• Pipeline-Entwurf 

• vom Eintakt-Rechenwerk zum 

Pipelining 

• Einfügen von Pipeline- 

Registern 

• Pipeline-Steuerung 

• Pipeline-Probleme 

• Allgemein 

• MIPS 

1. Ressourcen-Konflikt 

2. Datenkonflikt 

3. Steuerflusskonflikt 

• Datenabhängigkeit 

• Datenhürde 

• Software-Lösung 

• Forwarding 

• Stall 

• Steuerflusskonflikt 

• Weitere Leistungssteigerung


Grundlegende Überlegungen 

10–3 

Bisher erreicht: 

• Mehrtakt-Implementierung 

für eine Teilmenge der MIPS- 

Befehle, 

• dadurch zwar mehrere 

Taktzyklen zur Abarbeitung eines 

Befehls, aber insgesamt 

schneller als bei Eintakt- 

Implementierung. 

• Auslastung der Hardware: 

Mehrtakt-Implementierung 

benutzt die Hardware- 

Einheiten (Ressourcen) nur 

in bestimmten 

Steuerzuständen. 

Ziel: 

• Effizienzsteigerung durch 

Nutzung möglichst vieler 

Ressourcen zu jedem Zeitpunkt 

• Lösungsansatz: Parallele 

Bearbeitung mehrerer Befehle in 

Form einer 

Fließbandverarbeitung 

(Pipelining)


Pipelining Prinzip (1) 

10–4 

• Ziel 

• Es ist eine Menge von 

ähnlichen 

Objekten/Ergebnissen in 

möglichst kurzer Zeit zu 

produzieren. (Maximierung 

des Durchsatzes) 

• Voraussetzungen 

• Die Produktion kann in 

aufeinanderfolgenden 

Teilschritten erfolgen, die in 

etwa gleich lange dauern. 

• Es gibt ausreichend viele 

Ressourcen. 

Frauen am Fließband 

in der 

Anzugschneiderei der 

Firma Bierbaum und 

Proenen in Köln 

Bierbaum und Proenen 

Köln, 1950-1960 

Photographie 

Bundesbildstelle, Bonn 

• Lösung 

• Für jeden Bearbeitungsschritt 

wird eine Pipelinestufe 

vorgesehen. 

• Alle Pipelinestufen arbeiten 

parallel und liefern ihre 

Teilergebnisse synchronisiert 

durch einen Takt an die 

nächste Stufe weiter.



10–5 

Eingabeobjekte (Daten, Befehle, ...), Input-Stream: D1 .. Dm 

Darstellung: Füllung der Stufen über der Zeit 

Takt: 1 2 3 4 5 6 7 8 

Stufe1: D1 D2 D3 D4 D5 




Füllen 

Ausgabeobjekte (Daten, Befehle, ...), 

Output-Stream 

Pipeline- 

Modus 

(Betriebsphase) 

Leeren



"multiple-clock-cycle pipeline diagram" 

Mehrzyklen-Pipelinediagramm 

10–6 

Aus dieser Darstellung kann man gut erkennen, zu welchem Zeitpunkt ein Datum 

welche Stufe benutzt. 

Diese Darstellung eignet sich auch gut zur Ermittlung der Datenabhängigkeiten 

zwischen den Daten=Befehlen, s. z.B. 10-45 

Takt 1. 2. 3. 4. 5. 6. 7. 8. 

Datum1 Stufe1 Stufe2 Stufe3 Stufe4 





Füllen 

Pipeline- 

Modus 

(Betriebsphase) 

Leeren 

Jedes Datum durchläuft sequentiell die n Stufen. 

In der Betriebsphase bearbeiten n Stufen parallel n Daten.


Bearbeitungszeit (1): ohne Pipelining 

10–7 

n=4 

m=5 

m 

n 

n = Anzahl der Stufen 

m = Anzahl der zu bearbeitenden Objekte 

T one = Gesamtbearbeitungszeit in einem Schritt 

Fall ohne Pipelining (n=1) 

• für m=1 Objekt: t ges (m=1,n=1) = T one 

Beispiel: n=1, m=1: T one =7 

n=1, m=10: T one = 70


Bearbeitungszeit (2): nur ein Objekt 

10–8 

Fall mit n Pipelinestufen (n>1) 

t1 t2 t3 t4 

• nur m=1 Objekt wird bearbeitet, die Verweildauer (Durchlaufzeit) 

beträgt dann 

• bei asynchroner Weitergabe: t ges (1,n) = Summe(t i ) = T asyn 

1 

• bei synchroner Weitergabe: t ges (1,n) = n t max = T syn 

mit t max = max (t i ) = Taktzeit 

1 wie bei einem mehrstufigen 

Schaltnetz 

Beispiel: n=4, m=1, t1=1, t2=2, t3=1, t4=3 

T asyn = 1+2+1+3=7 

T syn = n t max = 4 * 3 = 12


Bearbeitungszeit (3): m Objekte 

10–9 

Fall mit n Pipelinestufen (n>1) 

• m Objekte werden bearbeitet, bei synchroner Weitergabe 

t ges (m,n) = n t max + (m-1) t max 

(für das erste Ergebnis, Latenzzeit) + (für die weiteren Ergebnisse) 

= (n-1) t max + m t max 

(Füllen Start-Up) + (für m Ergebnisse) 

t1 t2 t3 t4 

t ges (m,n) = T syn + (m-1) T syn /n 

Beispiel: n=4, m=10, t1=1, t2=2, t3=1, t4=3 

T syn = n * t max = 4 * 3 = 12 

t ges (10, 4) = 12 + (9) * 12/4 = 39 < 70 !! 

Vergleich: ohne Pipeline: mT one = 10*7=70


Formel (Wdh.) 

10–10 

t ges (m,n) = T syn + (m-1) T syn /n = (n-1)*T syn /n + m*T syn /n 

• t ges Zeit zur Bearbeitung von m Objekten 

• n Anzahl der Stufen 

• m Anzahl der Objekte 

• T syn Verweildauer, Durchlaufzeit 

• t max =T syn /n Taktzeit 

• (n-1)*T syn /n Start-Up-Time, Zeit um die Pipeline zu 

füllen 

• (n)*T syn /n Latenzzeit, Zeit bis zum ersten Ergebnis


Speed-Up 

10–11 

• Speed-Up Z = Beschleunigungsfaktor = 

= Zeit bei sequentieller Verarbeitung 

Zeit bei Pipeline-Verarbeitung 

• für sehr große m: Start-Up-Time ist 

vernachlässigbar 

• t ges m t max , d. h. pro Takt ein neues Ergebnis 

• Z mT asyn / (mT syn /n) = n T asyn /T syn 

kleiner als 1 ! 

Merke: Der Speed-Up zur Bearbeitung eines langen 

Datenstroms ist kleiner als n (Anzahl der Stufen).


Pipelining: Eigenschaften 

10–12 

• Die Durchlaufzeit für eine 

einzelne Aufgabe ist beim 

Pipelining höher im Vergleich zur 

asynchronen Verarbeitung ohne 

Pipelining. 

• Die Pipelinegeschwindigkeit wird 

durch die langsamste Stufe 

bestimmt. 

• Durchsatz/ 

Übertragungsrate: 

• Anzahl der übertragbaren 

Bytes/s, meist in MB/s 

• oder auch Mbps (Megabit/s) 

bei serieller Übertragung 

• Beispiel: Warmwasserleitung .... 

• Durchsatz steigt mit der Anzahl 

n der Pipelinestufen, wenn 

• die Pipeline immer weiter in 

etwa gleich lange Stufen geteilt 

werden kann. 

• die Zeit zum Zwischenspeichern 

der Teilergebnisse 

"vernachlässigt" werden kann 

(Pufferregister verursachen 

Zeitverzögerung). 

• Durchsatz wird reduziert durch 

• Registerübernahmezeiten 

• ungleiche Länge der Stufen 

• Zeit zum Füllen (am Anfang) 

und Leeren der Pipeline (am 

Ende) 

• Eventuelle Abhängigkeiten 

zwischen den Stufen


Verschiedene Anwendungen des Pipelining 

10–13 

• Allgemein: Bearbeitung von 

Datenströmen 

• z.B. digitale 

Signalverabeitung, Videound 

Audiostreams 

• Bearbeitung von Vektoren 

(in Vektorrechnern) 

• Arithmetisches Pipelining: 

Arithmetische Operationen 

werden in Teilschritten 

ausgeführt (z. B. 

Gleitkommaoperationen) 

• Prozessor-Pipelining: in 

jeder Bearbeitungsstufe 

sitzt ein Prozessor. 

• Befehlspipelining, im 

folgenden beim MIPS 

• Befehl holen, decodieren und 

ausführen wird ständig 

wiederholt


Befehlspipelining bei MIPS 

10–14 

• Die Ausführung eines 

komplexen Programms 

bedeutet in der Regel das 

Ausführen von Milliarden 

von Mikrooperationen. 

Durchsatzmaximierung ist 

eines der wesentlichen 

Entwurfsprobleme. 

• Was erleichtert die 

Implementierung (z. B. beim 

MIPS)? 

• Alle Befehle sollten in etwa 

gleich lang sein. 

• Registernummern sollten in 

allen Befehle an derselben 

Stelle platziert sein. 

• Speicherzugriffe sollten nur in 

Lade- und Speicherbefehlen 

vorkommen. 

• Je Befehl wird höchstens ein 

Rechenergebnis erzeugt, das in 

ein Register geschrieben wird.


Befehlspipelining 

10–15 

• die auszuführenden Schritte bei RISC-Befehlen, 

beispielhaft 

• Register-Register-Befehl 

IF Holen 

ID Decodieren, Register-Lesen 

EX ALU-Operation 

WB Register-Schreiben. 

• Load-Befehl 

IF Holen 

ID Decodieren, Register-Lesen 

EX Adresse berechnen 

MEM aus dem Cache oder Hauptspeicher lesen 

WB Register-Schreiben. 

• Sprungbefehl 

IF Holen 

ID Decodieren, (Register-Lesen) 

EX Sprungadresse berechnen 

Befehlszähler neu setzen und schon vorverarbeitete Nachfolge- 

Befehle beenden oder ihre Wirkung verhindern.


MIPS-Befehlszyklen am Beispiel lw 

10–16 

Zyklus 1 

Zyklus 2 Zyklus 3 Zyklus 4 Zyklus 5 

IF ID EX MEM WB 

IF: Fetch Befehl aus dem Programmspeicher 

ID: Decodiere Befehl und Read Register 

EX: (Ececute) Berechne die effektive Speicheradresse 

MEM: Read Daten aus dem Datenspeicher 

WB: Write Back die Daten ins Zielregister 

Die Überlegungen in Kapitel 5 sind auf die acht MIPS-Befehle lw, sw, add, 

sub, and, or, slt, beq beschränkt, die jeweils in maximal 5 Taktzyklen 

ausgeführt werden. Die übrigen MIPS-Befehle werden hier nicht untersucht.


Erhöhung des Befehlsdurchsatzes 

10–17 

Program 

execution 

order 

Time 

(in instructions) 

lw $1, 100($0) 

Eintakt-MIPS-Rechenwerk 

Instruction 

fetch 

2 4 6 8 10 12 14 16 18 

Reg 

ALU 

Data 

access 

Reg 

lw $2, 200($0) 

8 ns 

Instruction 

fetch 

Reg 

ALU 

Data 

access 

Reg 

lw $3, 300($0) 

Program 

execution 

Time 



lw $1, 100($0) 

lw $2, 200($0) 

Instruction 

fetch 

2 ns 

Instruction 

fetch 

8 ns 

T asyn 

... 

8 ns 

T syn 

mit Pipelining 

2 4 6 8 10 12 14 

Data 

Beschleunigungsfaktor 

im Beispiel: 

Reg ALU 

Reg 

access 

Instruction 

Data 

Z 5 * 8/10 = 4 

Reg ALU 

Reg 

fetch 

access 

siehe Folie 10-11: 

lw $3, 300($0) 

2 ns 

Instruction 

fetch 

Reg 

ALU 

Data 

access 

Reg 

Z n T asyn /T syn 

2 ns 2 ns 2 ns 2 ns 2 ns


Pipeline-Entwurf 

10–18 

• Vorgehen allgemein 

• Erst wird angenommen, dass jeder Befehl ein eigenes 

spezielles Operationswerk zur Verfügung hätte. 

Jedes Operationswerk besteht aus einer Folge von 

Operationen. 

• Dann wird die zeitliche Abarbeitung aller einzelnen 

Operationswerke in Zusammenhang gesetzt und daraus 

durch Überlagerung ein gemeinsames Operationswerk 

entworfen. 

• Vorgehen hier 

• Ausgangspunkt: Eintakt-Implementierung 

• Einfügen von Pipelineregistern.


Eintakt-Implementierung (Wdh.) 

10–19 

M ux 

0 

4 

Add 

Instruction [31 26] 

Control 

RegDst 

Branch 

MemRead 

MemtoReg 

ALUOp 

MemWrite 

ALUSrc 

RegWrite 

Shift 

left 2 

Add 

ALU 

result 

1 

PCSrc 

PC 

Read 

address 

Instruction 

memory 

Instruction 

[31– 0] 





0 

M ux 

1 

Read 

register 1 

Read 

Read 

data 1 

register 2 

Registers Read 

Write 

data 2 

register 

Write 

data 

16 32 

Sign 

extend 

0 

M 

ux 

1 

ALU 

control 

Zero 

ALU ALU 

result 

Address 

Write 

data 

Data 

memory 

Read 

data 

M ux 

1 

0 

Instruction [5 0]


Eintakt-Befehlsteilschritte 

10–20 

IF: Instructionfetch 

M ux 

0 

ID: Instructiondecode/ 

register fileread 

EX: Execute/ 

address calculation 

MEM: Memory access 

WB: Writeback 

1 

PC 

clk 

4 

Address 

Add 

Instruction 

memory 

Instruction 

Instruction 

Memory IM 

Read 

register 1 

Read 

Read 

data1 

register 2 


data2 

Write 

register 

Write 

data 

clk 

16 

Sign 

extend 

32 

Shift 

left 2 

0 

M ux 

1 

Add Add result 

ALU Zero 

ALU 

result 

Data 

Memory DM 

Address 

Data 

memory 

Write 

data 

Read 

data 

M ux 

1 

0 

clk 

• Jeder Schritt bei Ausführung eines MIPS-Befehls wird von links nach 

rechts fortgeführt. 

• Zwei Ausnahmen: WB-Schritt und Wahl des nächsten PC


vom Eintakt-Rechenwerk zum Pipelining 

10–21 

Program 

execution 



Time (in clock cycles) 

CC 1 CC 2 CC 3 CC 4 CC 5 CC 6 CC 7 

lw $1, 100($0) IM Reg ALU DM Reg 

lw $2, 200($0) 

IM Reg ALU DM Reg 

lw $3, 300($0) 


Register lesen (in der 2. Hälfte des Taktzyklus) 

Register schreiben (in der 1. Hälfte des Taktzyklus) 

• Befehlsspeicher IM wird nur in jeweils einer der 5 Stufen eines Befehls 

verwendet, d. h. kann während der übrigen 4 Stufen von anderen 

Befehlen verwendet werden. 

• Um den Datenwert eines einzelnen Befehls für die übrigen 4 Stufen zu 

erhalten, muss der aus dem IM gelesen Wert in einem Register 

zwischengespeichert werden. Pipeline-Register zwischen Stufen.

Instruction 


Einfügen von Pipeline-Registern 

M 

ux 

0 

4 Pipeline-Register 

puffern die noch benötigten Informationen und Teilergebnisse 

10–22 

1 

IF/ID (64 Bit) ID/EX (128 Bit) EX/MEM (97 Bit) MEM/WB (64 Bit) 

Add 

PC 

posedge 

clk 

4 

Address 

Instruction 

memory 

write on 

negedge 

clk 

Read 

register 1 

Read 

Read 

data 1 

register 2 


data 2 

Write 

register 

Write 

data 

16 

Sign 

extend 

32 

Shift 

left 2 

0 

M 

ux 

1 

Add 

result 

Add 

Zero 

ALU ALU 

result 

Write 

data 

posedge 

clk 

Address 

Data 

memory 

Read 

data 

M 

ux 

1 

0 

IF/ID: 64 Bit (32-Bit 

für Befehlswort und 

32-Bit für erhöhte PC- 

Adresse) 

Modifiziertes Operationswerk: Nummer des Write-Registers und zu 

schreibender Datenwert kommen aus Pipeline-Register MEM/WB.


Darstellung der Aktivitäten 

• Darstellung der benutzten physikalischen Ressourcen 

Program 

execution 



lw $10, 20($1) 


CC 1 CC 2 CC 3 CC 4 CC 5 CC 6 


10–23 

sub $11, $2, $3 

not 

used 


Program 

execution 



lw $10, $20($1) 

sub $11, $2, $3 

Time ( in clock cycles) 

CC 1 CC 2 CC 3 CC 4 CC 5 CC 6 

Instruction 

fetch 

In dieser Darstellung (multiple-clock-cycle pipeline 

diagram) ist der aktuellste Befehlsschritt rechts unten. 

• konventionelle Darstellung mit Namen der einzelnen Schritte: 

Instruction 

decode 

Instruction 

fetch 

Execution 

Instruction 

decode 

Data 

access 

Execution 

Write back 

Data 

access 

Write back


Betrieb der Pipeline 

10–24 

• Optimale Nutzung, wenn 5 Befehle gleichzeitig aktiv 

in den 5 Stufen 

• Anfangsphase: Füllen der Pipeline 

• Betriebsphase: Gleichzeitige Bearbeitung in der 

Pipeline (eingeschwungene Pipeline) 

• Endphase: Leeren der Pipeline 

• Beispiel: 

• lw 

• sub

Instruction 


Beispiel zur Pipeline (1): lw; sub 

10–25 

lw$10, 20($1) 

Instruction fetch 

M 

ux 

0 

In dieser Darstellung (single-cycle pipeline diagram) 

ist der aktuellste Befehlsschritt links. 

1 

IF/ID ID/EX 

EX/MEM MEM/WB 

Add 

4 

Shift 

left 2 

Add 

result 

Add 

PC 

Address 

Instruction 

memory 

Read 

register 1 

Read 

Read 

data 1 

register 2 


data 2 

Write 

register 

Write 

data 

16 

Sign 

extend 

32 

0 

M 

ux 

1 

Zero 

ALU ALU 

result 

Address 

Write 

data 

Data 

memory 

Read 

data 

M 

ux 

1 

0 

clock Clock 11

Instruction 


Beispiel zur Pipeline (2) 

10–26 

sub $11, $2, $3 


lw$10, 20($1) 

Instruction decode 

M 

ux 

0 

1 

IF/ID ID/EX 

EX/MEM MEM/WB 

Add 

4 

Shift 

left 2 

Add 

result 

Add 

PC 

Address 

Instruction 

memory 

Read 

register 1 

Read 

Read 

data 1 

register 2 


data 2 

Write 

register 

Write 

data 

16 

Sign 

extend 

32 

0 

M 

ux 

1 

Zero 

ALU ALU 

result 

Address 

Write 

data 

Data 

memory 

Read 

data 

M 

ux 

1 

0 

clock Clock 22

Instruction 



10–27 

sub $11, $2, $3 

Instruction decode 

lw$10, 20($1) 

Execution 

M 

ux 

0 

1 

IF/ID ID/EX 

EX/MEM MEM/WB 

Add 

4 

Shift 

left 2 

Add 

result 

Add 

PC 

Address 

Instruction 

memory 

Read 

register 1 

Read 

Read 

data1 

register 2 


data2 

Write 

register 

Write 

data 

16 

Sign 

extend 

32 

0 

M 

ux 

1 

Zero 

ALU ALU 

result 

Address 

Write 

data 

Data 

memory 

Read 

data 

M 

ux 

1 

0 

Clock 3 

clock 3

Instruction 



10–28 

M 

ux 

0 

1 

sub $11, $2, $3 

Execution 

lw$10, 20($1) 

Memory 

IF/ID ID/EX 

EX/MEM MEM/WB 

Add 

4 

Shift 

left 2 

Add 

result 

Add 

PC 

Address 

Instruction 

memory 

Read 

register 1 

Read 

Read 

data1 

register 2 


data2 

Write 

register 

Write 

data 

16 

Sign 

extend 

32 

0 

M 

ux 

1 

Zero 

ALU ALU 

result 

Address 

Write 

data 

Data 

memory 

Read 

data 

M 

ux 

1 

0 

clock Clock 4

Instruction 



10–29 

M ux 

0 

1 

sub$11, $2, $3 

Memory 

lw$10, 20($1) 

Write back 

IF/ID 

ID/EX 

EX/MEM 

MEM/WB 

Add 

4 

Shift 

left 2 

Add 

result 

Add 

PC 

Address 

Instruction 

memory 

Read 

register 1 

Read 

Read 

data1 

register 2 


data2 

Write 

register 

Write 

data 

16 

Sign 

extend 

32 

0 

M ux 

1 

Zero 

ALU ALU 

result 

Address 

Write 

data 

Data 

memory 

Read 

data 

M 

ux 

1 

0 

clock Clock 55

Instruction 



10–30 

M 

ux 

0 

1 

sub $11, $2, $3 

Write back 

IF/ID 

ID/EX 

EX/MEM 

MEM/WB 

Add 

4 

Shift 

left 2 

Add 

result 

Add 

PC 

Address 

Instruction 

memory 

Read 

register 1 

Read 

Read 

data1 

register 2 


data2 

Write 

register 

Write 

data 

16 

Sign 

extend 

32 

0 

M 

ux 

1 

Zero 

ALU ALU 

result 

Address 

Write 

data 

Data 

memory 

Read 

data 

M 

ux 

1 

0 

clock Clock 66


Entwicklung der Pipeline-Steuerung 

10–31 

• Verfahren 

• Nicht nur der Datenpfad der Eintakt-Impl. wird in 

Pipelinestufen zerlegt, 

• auch der Kontrollpfad


Eintakt-Implementierung + Pipelineregister 

10–32 

auch die Steuersignale müssen "gepipet" werden 

M ux 

0 

4 

Add 


Control 

RegDst 

Branch 

MemRead 

MemtoReg 

ALUOp 

MemWrite 

ALUSrc 

RegWrite 

Shift 

left 2 

Add 

ALU 

result 

1 

PCSrc 

PC 

Read 

address 

Instruction 

memory 

Instruction 

[31– 0] 





0 

M ux 

1 

Read 

register 1 

Read 

Read 

data 1 

register 2 


Write 

data 2 

register 

Write 

data 

16 32 

Sign 

extend 

0 

M 

ux 

1 

ALU 

control 

Zero 

ALU ALU 

result 

Address 

Write 

data 

Data 

memory 

Read 

data 

M ux 

1 

0 

Instruction [5 0]

Instruction 


Pipeline-Steuersignale 

10–33 

PCSrc 

0 

IF/ID ID/EX EX/MEM MEM/WB 

4 

RegWrite 

Shift 

left 2 

Add 

Add 

result 

Branch 

PC 

Address 

Instruction 

memory 

M 

ux 

0 

1 

Add 

Read 

register 1 

Read 

Read 

data 1 

register 2 


Write data 2 

register 

Write 

data 

Instruction 

[15–0] 16 32 

Sign 

extend 

ALUSrc 

0 

M 

ux 

1 

6 

ALU 

control 

Zero 

ALU ALU 

result 

Address 

Write 

data 

MemWrite 

Data 

memory 

MemRead 

Read 

data 

MemtoReg 

1 

M 

ux 

0 

Instruction 

[20–16] 

Instruction 

[15–11] 

M 

ux 

1 

ALUOp 

RegDst


Pipeline-Steuerung 

10–34 

• Gleiche Bedeutung der Steuersignale wie beim 

Eintakt-Rechenwerk 

• Gruppierung der Steuersignale nach den 5 Stufen. 

Was muss auf welcher Stufe gesteuert werden? 

• IF: 

• ID: 

• EX: 

• MEM: 

• WB: 

Befehl laden und PC erhöhen 

Decodiere Befehl / Lade Register 

Ausführung 

Speicher read/write 

Zurückschreiben von Daten ins Zielregister 

• Durchreichen der Steuersignale bzw. des 

Opcodes


Pipeline-Steuerung 

• Gruppierung der Steuersignale nach den letzten 3 Pipelinestufen: 

• Durchreichen von Steuersignalen über erweiterte Pipeline-Register wie die Daten: 

Execution/Address Calculation 

stage control lines 

Memory access stage 

control lines 

Write-back 

stage control 

lines 

Instruction 

Reg 

Dst 

ALU 

Op1 

ALU 

Op0 

ALU 

Src Branch 

Mem 

Read 

Mem 

Write 

Reg 

write 

Mem to 

Reg 

R-format 1 1 0 0 0 0 0 1 0 

lw 0 0 0 1 0 1 0 1 1 

sw X 0 0 1 0 0 1 0 X 

beq X 0 1 0 1 0 0 0 X 

10–35 

EX M WB 

WB 

Instruction 

Control 

M 

WB 

EX 

M 

WB 

IF/ID ID/EX EX/MEM MEM/WB

RegWrite 


Pipeline mit Steuerwerk 

• Steuersignale für die 

letzten 3 Pipelinestufen 

werden in ID-Stufe erzeugt 

und dann durchgereicht. 

10–36 

PCSrc 

M ux 

0 

1 

Control 

ID/EX 

WB 

M 

EX/MEM 

WB 

MEM/WB 

IF/ID 

EX 

M 

WB 

Add 

PC 

4 

Address 

Instruction 

memory 

Ausführliche Beispiele 

für Pipelineabarbeitung 

samt 

Steuersignalen bei 

Patterson/Hennessy 

in Chapter 6.3, 6.4. 

Instruction 

Read 

register 1 

Read 

Read 

data 1 

register 2 


Write data 2 

register 

Write 

data 

Instruction 

[15–0] 

Instruction 

[20–16] 

Instruction 

[15–11] 

16 32 

Sign 

extend 

Shift 

left 2 

M ux 

0 

0 

M ux 

1 

6 

1 

RegDst 

Add result 

Add 

ALU 

control 

ALUSrc 

Zero 

ALU ALU 

result 

ALUOp 

Branch 

Write 

data 

MemWrite 

Address 

Data 

memory 

Read 

data 

MemRead 

MemtoReg 

M 

ux 

1 

0


Zusammenfassung Teil 1 

10–37 

• Pipeline-Prinzip 

• Höherer Durchsatz bei 

Datenströmen 

• aber: Latenzzeit 

• Grenzen: 

Registerübernahmezeiten, 

ungleiche Sufenlängen 

• Anwendungen 

• Datenströme 

• Arithmetisches Pipelining 

• Prozessor-Pipelining 

• Befehlspipelining 

• Befehlspipelining bei MIPS 

• IF: Instruction Fetch 

• ID: Instruction Decode (auch 

Register lesen) 

• EX: 

• Execute 

• Speicheradressberechnung 

• NextPC-Berechnung 

• MEM: Speicher 

lesen/schreiben 

• WB: Register schreiben 

• Pipeline-Steuerung 

• Durchreichen des Opcodes 

und von bereits decodierten 

Steuersignalen



10–38 

• Pipeline-Probleme 

• Allgemein 


2. Datenkonflikt 


• MIPS 

• Datenabhängigkeit 

• Datenhürde 

• Software-Lösung 


• Stall 


• Weitere Leistungssteigerung


Pipeline-Probleme (1) 

10–39 

• In der Pipeline befinden 

sich immer bis zu n Befehle 

gleichzeitig in Bearbeitung. 

• Die Befehle konkurrieren 

um die Ressourcen 

• Zwischen den Befehlen gibt 

es unterschiedliche 

Abhängigkeiten, die bei 

der Pipelineverarbeitung zu 

Situationen (Hazards, 

Hemmnisse, Hürden, 

Konflikte) führen, die in der 

Hardware oder Software 

speziell behandelt werden 

müssen. 

• Unterschiedliche 

Komplexität der Befehle 

erschwert den Pipeline- 

Entwurf 

• Anzahl der nacheinander 

auszuführenden 

Mikrooperationen ist nicht 

konstant (variiert je nach 

Befehl und kann von Daten 

in der Ausführung abhängig 

sein)


Probleme (2) 

10–40 

• Die Befehlspipelinestufen können nicht immer 

genutzt werden, wegen der möglichen Konflikte 

1. Ressourcen-Konflikt (Strukturkonflikt, structural 

Hazard) 

2. Datenkonflikt (Data Hazard, Datenhürde) 

3. Steuerflusskonflikt (Control Hazard, 

Sprungabhängigkeit, Procedural Dependency)



10–41 

• entsteht durch die 

begrenzten Ressourcen 

• Die Anzahl, Art und 

Reihenfolge der Zugriffe 

auf die Hardware-Einheiten 

(wie Speicher, Register, 

ALUs, Adressrechenwerk, 

MMU, Cache) variiert je 

nach Befehl. 

• Bei der parallelen 

Ausführung in der Pipeline 

kommt es zu 

Zugriffskonflikten, wenn 

nicht genügend viele 

Hardware- 

Ausführungseinheiten bzw. 

Zugriffsmöglichkeiten zur 

Verfügung stehen. 

• Auflösung: Wartezyklen 

(Bubbles)


2. Datenhürde, Datenkonflikt 

10–42 

• entsteht durch 

Datenabhängigkeiten 

• (echte Datenabhängigkeit) 

Der Befehl i+k, k>1 benötigt das 

Ergebnis des Befehls i, der sich 

noch in der Berechnung befindet 

(true data dependency) 

• Auflösung: Wartezyklen, 

Forwarding 

• (falsche Datenabhängigkeit, 

name dependency) 

• entsteht nur durch Umordnung 

der Ausführungsreihenfolge 

(out-of-order execution) bei 

modernen Prozessoren, dabei 

können sich Befehle überholen. 

Ist bei dem MIPS nicht 

möglich. Die Konflikte sind 

• Zielregisterkonflikt (zwei 

Befehle wollen gleichzeitig in ein 

Zielregister schreiben) 

• Gegenabhängigkeit (ein 

überholender Befehl will schon 

ein Datum ändern, dass noch 

zur Berechnung benötigt wird) 

• Auflösung: Benutzung von 

verdeckten Renaming- 

Registern



• entsteht durch eine verzögerte 

Ausführung des Sprungs 

• weil das Sprungziel erst noch 

berechnet werden muss (z. B. 

relativer Sprung, Branch). 

• weil auf die Berechnung der 

Sprungbedingung noch gewartet 

werden muss. 

• Die Entscheidung zu Auswahl 

des nächsten Befehls 

wird meist getroffen, bevor das 

Sprungziel feststeht, um 

Wartezyklen zu vermeiden. Es ist 

deshalb nicht sicher, dass der in die 

Pipeline gefütterte Befehl wirklich 

als nächster ausgeführt werden 

sollte. 

• Auflösung 

10–43 

• Die Befehle, die hinter dem 

Sprung stehen (Delayed- 

Slot-Befehle) werden schon 

in die Pipeline geholt 

• entweder werden sie bis 

zum Ende ausgeführt 

• oder sie werden annulliert 

(Wirkung: Warten) 

• Es werden die Befehle in die 

Pipeline geholt, die entweder 

hinter dem Sprung stehen 

oder am Sprungziel. Auf 

Grund der Vergangenheit 

wird der wahrscheinlichere 

Weg eingeschlagen 

(spekulative Ausführung).


MIPS: Datenabhängigkeit 

10–44 

• Beispiel: 

sub $2, $1, $3 // 10 -20 

and $12, $2, $5 //soll den neuen Wert benutzen 

or $13, $6, $2 

add $14, $2, $2 

sw $15, 100($2) 

• sub berechnet $2, wird in den Folgebefehlen 

verwendet (gelesen).


Datenabhängigkeit 


Value of CC 1 CC 2 CC 3 CC 4 CC 5 CC 6 CC 7 CC 8 CC 9 

register $2: 10 10 10 10 10/– 20 – 20 – 20 – 20 – 20 

Program 

execution 



sub $2, $1, $3 

IM 

Reg 

DM 

1.Phase: Write 

2.Phase: Read 

Reg 

10–45 

and $12, $2, $5 

or $13, $6, $2 

IM 

inkorrekte 

Werte von 

$2 

Reg 

DM Reg 

IM Reg DM Reg 

add $14, $2, $2 

sw $15, 100($2) 

korrekte Werte 

von $2 

IM Reg 

DM Reg 

IM Reg 

DM Reg 

• Abhängige Schritte sind durch Pfeile gekennzeichnet. 

• Der korrekte Wert von $2 liegt erst nach der 1. Phase (Register 

Schreiben) von Zyklus 5 vor. 

• Abhängigkeiten, die in der Zeit „rückwärts“ zeigen, sind Datenhürden 

(data hazards).


Datenhürde: Software-Lösung 

10–46 

• Compiler löst bei der Übersetzung in die Maschinensprache 

(Assemblersprache) solche Hürden auf. 

• z. B. durch Einfügen zweier unabhängiger Operationen: 

sub $2, $1, $3 

nop 

nop 

and $12, $2, $5 

or $13, $6, $2 

add $14, $2, $2 

sw $15, 100($2) 

• nop (no operation) modifiziert weder Daten noch schreibt 

es ein Ergebnis. 

• Problem: Bremst das Ganze beträchtlich! 

(Und tritt zu häufig auf.) 

• Besser: Hardware-Lösung Forwarding


Datenhürde: Vorreichen (Forwarding) 


CC 1 CC 2 CC 3 CC 4 CC 5 CC 6 CC 7 CC 8 CC 9 

Value of register $2 : 10 10 10 10 10/– 20 – 20 – 20 – 20 – 20 

Value of EX/MEM : X X X – 20 X X X X X 

Value of MEM/WB : X X X X – 20 X X X X 

10–47 

Program 

execution order 


sub $2, $1, $3 

and $12, $2, $5 

IM 

Reg 

IM 

Reg 

A 

EX/MEM 

DM 

B 

MEM/WB 

Reg 

DM 

Reg 

vorher ohne Forwarding 

mit Forwarding 

or $13, $6, $2 

add $14, $2, $2 

IM Reg DM Reg 

C 

IM Reg 

DM Reg 

sw $15, 100($2) 

IM Reg 

DM Reg 

• Direkte Verwendung bereits verfügbarer Zwischenergebnissen von 

Pipeline-Registern ohne die Speicherung im Registersatz abzuwarten. 

• Vorreichen zur ALU (von EX/MEM bzw. MEM/WB) A, B 

• Vorreichen durch Registersatz: Schreiben/Lesen auf gleichem Register im 

gleichen Zyklus (z. B. Zyklus 5 im Bild, 1. Phase: Schreiben, 2. Phase: Lesen) C


Hardware-Erweiterung fürs Vorreichen 

ID/EX 

EX/MEM 

MEM/WB 

Load 

10–48 

Registers 

ALU 

Data 

memory 

M ux 

ohne Vorreichen 

Folgebefehl benutzt 

sofort Ergebnis 

ID/EX 

mit Vorreichen 

EX/MEM 

MEM/WB 

M ux 

Registers 

ForwardA 

ALU 

M ux 

Data 

memory 

M ux 

Rs 

Rt 

Rt 

Rd 

ForwardB 

M ux 

Forwarding 

unit 

EX/MEM.RegisterRd 

MEM/WB.RegisterRd

Instruction 


Hardware-Erweiterung fürs Vorreichen 

10–49 

zusätzliche / erweiterte Multiplexer 

ID/EX 

WB 

EX/MEM 

Control 

M 

WB 

MEM/WB 

IF/ID 

EX 

M 

WB 

M 

ux 

PC 

Instruction 

memory 

Registers 

ALU 

Data 

memory 

M 

ux 

M 

ux 

IF/ID.RegisterRs 

Rs 

IF/ID.RegisterRt 

Rt 


IF/ID.RegisterRd 

Rt 

Rd 

M 

ux 


Forwarding 

unit 

MEM/WB.RegisterRd


Nicht immer kann man vorreichen 


Program CC 1 CC 2 CC 3 CC 4 CC 5 CC 6 

execution 



lw $2, 20($1) IM Reg 

DM Reg 

10–50 

CC 7 CC 8 CC 9 

and $4, $2, $5 

IM 

Reg 

DM 

Reg 

or $8, $2, $6 

IM Reg DM Reg 

add $9, $4, $2 

IM Reg 

DM Reg 

slt $1, $6, $7 

IM Reg 

DM Reg 

• lw kann immer noch eine Datenhürde verursachen. 

• Beispiel: Nachfolgender Befehl versucht, das Register zu lesen, dessen 

Wert gerade aus dem Speicher geladen wird. Das Lesen muss 

abgewartet werden (1 Takt Verzögerung).


lw$2, 20($1) 

Lösung: Anhalten (Stall) 

Program Time(inclock cycles) 

execution 


(ininstructions) 

CC1 CC2 CC3 CC4 CC5 CC6 

IM 

Reg 

DM 

Reg 

10–51 

CC7 CC8 CC9 CC10 

and$4, $2, $5 

IM 

Reg 

Reg 

DM 

Reg 

or $8, $2, $6 

add$9, $4, $2 

IM 

IM Reg DM Reg 

bubble 

IM Reg 

DM Reg 

slt $1, $6, $7 

IM Reg 

DM Reg 

• Anhalten (stall) der Pipeline durch Belassen des Befehls im gleichen Abschnitt, 

d. h. Einfügen eines nop Steuerbefehls ab dem EX-Abschnitt (EX, WB, MEM- 

Steuersignale auf 0). 

• Verhindern, dass PC fortgeschrieben und das ID-Register geändert wird.

Instruction 

IF/IDWrite 


Anhalten der Pipeline 

10–52 

• Es wird eine Hazard Detection Unit benötigt, um den Folgebefehl rechtzeitig 

„aufzuhalten“. Sie erkennt die Befehlsfolge (lw $2.. , and .. $2 ..) 

1 Takt warten 

and 

Hazard 

detection 

unit 

lw 

ID/EX.MemRead 

ID/EX 

WB 

EX/MEM 

IF/ID 

Control 

0 

M 

ux 

M 

EX 

WB 

M 

MEM/WB 

WB 

PCWrite 

M 

ux 

PC 

Instruction 

memory 

Registers 

ALU 

Data 

memory 

M 

ux 

M 

ux 

M 

ux 

IF/ID.RegisterRs 



IF/ID.RegisterRd 

Rt 

Rd 


ID/EX.RegisterRt 

$2 

Rs 

Rt 

Forwarding 

unit 

MEM/WB.RegisterRd

Instruction 

MemWrite 


MIPS: Steuerflusskonflikt 

10–53 

PCSrc 

Sprungziel 

M ux 

0 

1 

2. Stufe 

Control 

ID/EX 

WB 

M 

EX/MEM 

WB 

4. Stufe 

MEM/WB 

IF/ID 

EX 

M 

WB 

4 

Add 

Problem: Sprungziel ist erst in der 4. 

Read 

Stufe bekannt. PC Address 3 Delayed-Slot-Befehle 

register1 Read 

Read data1 

Instruction 

register2 

befinden sich schon 

memory 

in der Pipeline. Registers 

Write 

Read 

register 

data2 

Write 

data 

• 1. Lösung: 

• Anhalten (stall) bis Sprungziel ermittelt, 

Instruction 

[15–0] 16 32 

Sign 

extend 

Instruction 

• Annahme: kein Sprung (Branch [20–16] not 


taken), Folgebefehle (Delayed- 

Instruction 

[15–11] 

Slot-Befehle) starten 

• Falls nachträglich 

Sprungbedingung=true erkannt 

wird: DS-Befehle ignorieren 

RegWrite 

Add result 

Add 

Shift 

left 2 


ALUSrc 

M ux 

0 

0 

M ux 

1 

6 

1 

RegDst 

ALUOp 

Branch 

• Dynamische Zero Sprungvorhersage 

ALU ALU 

anhand result der Vergangenheit 


Address 

Data 

memory 

Write 

data 

Read 

data 

• Sprungzielberechnung von 4. 

ALU 

control 

MemRead 

Stufe auf 2. Stufe vorziehen 

MemtoReg 

M ux 

1 

0


Steuerflusskonflikt bei bedingter Verzweigung (1) 

10–54 

Program 

execution 




CC 1 

CC 2 CC 3 CC 4 CC 5 CC 6 CC 7 CC 8 CC 9 

40 beq $1, $3, 7 

IM 

Reg 

DM 

Reg 

44 and $12, $2, $5 

+1 

IM 

Reg 

DM 

Reg 

48 or $13, $6, $2 

+1 

IM 

Reg 

DM 

Reg 

52 add $14, $2, $2 

Delayed-Slot- 

Befehle 

+1 

IM 

Reg 

DM 

Reg 

72 lw $4, 50($7) 

Sprungziel erst 

nach 3 Takten bekannt 

+1 

? 

IM 

Reg 

DM 

Reg 

• Problem: 3 Delayed-Slot-Befehle befinden sich schon in der Pipeline. 

• 1. Lösung: Anhalten (Beispiel: 3 Anhalte-(stall)-Zyklen) bis Sprungziel ermittelt, 

um die Ausführung der Delayed-Slot-Befehle zu verhindern!



10–55 

not 

taken 

40 beq $1, $3, 7 

44 and $12, $2, $5 

48 or $13, $6, $2 

52 add $14, $2, $2 

72 lw $4, 50($7) 

taken 

Delayed-Slot- 

Befehle 


Annahme kein Sprung (Branch not 

taken), Folgebefehle (Delayed-Slot- 

Befehle) starten; 

bei nachträglicher Erkennung eines 

Sprunges (taken) 

• (a) DS-Befehle regulär beenden. Die 

Delayed-Slot-Befehle werden immer 

ausgeführt und können ggf. eine 

sinnvolle Berechnung (unabh. vom 

Sprung durchführen). Auffüllung mit 

nops, falls keine sinnvollen Aktionen 

möglich. 

• oder (b) der alte Zustand vor dem 

Sprung wird restauriert. Wirkung der DS- 

Befehle rückgängig machen.



10–56 

40 beq $1, $3, 7 

Vorhersage 

44 and $12, $2, $5 

48 or $13, $6, $2 

52 add $14, $2, $2 

Delayed-Slot- 

Befehle 

• 3. Lösung: Der dynamischen 

Programmablaufs wird verfolgt und die 

Sprünge in der Vergangenheit werden 

aufgezeichnet. Aus dieser Information wird 

eine Sprungvorhersage getroffen. Dadurch 

wird mit hoher Wahrscheinlichkeit der 

richtige Weg eingeschlagen. 

72 lw $4, 50($7)


Steuerung mit Verkürzung der Verzweigung 

10–57 

• 4. Lösung: Sprungzielberechnung von 4. Stufe auf 2. Stufe vorziehen und 

Hardware zum Löschen (flush) des bereits geholten Befehls (steht vor dem IF/ID- 

Register) durch Überschreiben mit NOPs. 

IF.Flush 

Unbedingtem Sprung: 

Sprungziel bekannt 

1 nop bubble 

IF/ID 

Hazard 

detection 

unit 

Control 

Sprungbedingung wird schon in der 

Decodierphase ausgewertet 

(Vergleicher) 

1 nop bubble 

0 

Bedingter Sprung 

ID/EX 

WB 

M ux M 

EX 

Bedingter Sprung 

Vorgänger-Befehl ändert einen 

Vergleichsoperanden,auf den gewartet 

werden muss. 

2 nop bubbles 

EX/MEM 

WB 

M 

MEM/WB 

WB 

4 

M ux 

PC 

Instruction 

memory 

M ux 

= 

Shift 

left 2 

Registers 

ALU 

Data 

memory 

M ux 

M ux 

M ux 

Sign 

extend 

NOP 

Forwarding 

unit


Weitere Leistungssteigerung (1) 

• Compiler: Vermeiden des Anhaltens der Pipeline von Compilerseite durch 

Umordnung von Befehlen (Lösung 2 a) 

• Superpipelining: Längere Fließbänder mit 8 und mehr Stufen 

• Superskalare Prozessoren: 

• In jedem Taktzyklus Start mehrerer Befehle gleichzeitig (z. B. 2 bis 8). 

• Voraussetzung: Zusätzliche Hardware-Einheiten notwendig zur Vermeidung 

von Ressourcenkonflikten. Z. B. Start zweier ALU-Operationen erfordert zwei 

ALUs. 

• z. B. superskalare Version von MIPS 

• Gleichzeitig eine ALU- oder Verzweigung sowie eine Lade- oder 

Speicheroperation aktivierbar. 

• In einem 64 Bit Befehlsregister können zwei aufeinander folgende Befehle 

gepuffert und dann parallel decodiert werden. 

10–58


Weitere Leistungssteigerung (2) 

10–59 

Dynamisches Pipelining (dynamic pipeline scheduling): 

• Hardware zum Aufspüren und Abarbeiten unabhängiger Befehle 

• in-order issue: Befehle werden in Programmordnung aktiviert 

• out-of-order execution: Ausführung in unabhängigen funktionalen Einheiten 

mit Befehlspuffern (reservation stations) und Ergebnispuffern 

• in-order commit: fertig bearbeitete Befehle werden wieder in die 

Programmreihenfolge gebracht (Schreiben in die Architektur-Register oder 

Speicher). 


and decode unit 

In-order issue 

Reservation 

station 

Reservation 

station 

… 

Reservation 

station 

Reservation 

station 

Functional 

units 

Integer 

Integer 

… 

Floating 

point 

Load/ 

Store 

Out-of-order execute 

Commit 

unit 

In-order commit


Aus der Technik 

10–60 

• Alle modernen Prozessoren sind äußerst komplex. 

• Compaq/DEC Alpha 21264: 

• 9-stufige Pipeline, 6 Befehle gleichzeitig 

• Intel/HP Itanium: 

• bis zu 6 IA-64-Befehle gleichzeitig 

• DEC Alpha 21164, PowerPC G3, MIPS R12000, UltraSparc- 

II, HP PA-8500: 

• bis zu 4 Befehle pro Takt 

• PowerPC, Pentium: 

• Sprungvorhersage-Tabelle 

• Trace-Cache: Befehlsgruppen werden dynamisch in Mikrobefehle 

zur Laufzeit übersetzt. Bei erneuter Ausführung werden die 

Mikrobefehle benutzt. 

• Aktuelle Prozessortechnik siehe Kap. 12, Multicores, 

Manycores


Zusammenfassung Teil 2 

10–61 

• Konflikte 

• Ressourcen-Konflikt Bubbles 

• Datenkonflikte Bubbles, Forwarding 


• Abwarten bis Sprungbedingung und Sprungziel berechnet 

• Delayed-Slot-Befehle befinden sich in der Pipeline 

• Auflösung 

• Software NOPs 

• Stall (Bubbles) 


• Sprungvorhersage


Ergänzung: lw add mit Datenabhängigkeit 

10–62 2 

lw


10–63 3 

lw 

Reg 

read 

and


10–64 4 

lw 

Reg 

read 

ALU 

and 

Reg 

read 

Hazard 

Detect


10–65 5 

lw 

Reg 

read 

ALU 

M 

read 

and 

Reg 

read 

Reg 

read 

bubble 

Hazard 

Detect


10–66 6 

lw 

Reg 

read 

ALU 

M 

read 

Reg 

write 

and 

Reg 

read 

Reg 

read 

ALU 

Hazard 

Detect


10–67 7 

lw 

Reg 

read 

ALU 

M 

read 

Reg 

write 

and 

Reg 

read 

Reg 

read 

ALU 

Hazard 

Detect


10–68 8 

lw 

Reg 

read 

ALU 

M 

read 

Reg 

write 

and 

Reg 

read 

Reg 

read 

ALU 

Reg 

write 

Hazard 

Detect

5. Teil MIPS - Ra.informatik.tu-darmstadt.de - Technische UniversitÃ¤t ...

Erfolgreiche ePaper selbst erstellen

Template löschen?

Als Template speichern?