Eine Übung zum Abschluss
Wie lässt sich das Blockschaltbild des Datenpfads erweitern, sodass auch die MIPS‐Instruktion j unterstützt wird?
Zur Erinnerung:
j 4096 # $pc = 4096<<2 + oberste vier
# Bit von $pc
Control einer einfachen MIPS‐CPU
Ziel
Bisher haben wir lediglich den Datenpfad einer einfachen MIPS‐CPU entworfen.
Die Steuerleitungen der einzelnen Bausteine zeigen noch ins Leere.
Jetzt wollen wir festlegen, wann zur Abarbeitung unserer
Instruktionen (d.h. lw, sw,add, sub, and, or, slt,beq ) welche Steuerleitungen an oder aus sein sollen. Den Baustein der das
macht, nennt man „Control“.
Wir trennen die Control in zwei Teile:
ALU‐Control: Legt für jeden Befehl die ALU‐Operation fest.
Main‐Unit‐Control: Legt für jeden Befehl die übrigen Steuerleitungen fest.
Wir verwenden auf den nächsten Folien die folgende Terminologie:
Steuerleitung an: asserted
Steuerleitung aus: deasserted
Control einer einfachen MIPS‐CPU
ALU‐Control
Vorüberlegung: Die passenden ALU‐Funktionen
Control‐Eingänge der betrachteten ALU
• Für Load‐ und Store‐Instruktionen lw, sw brauchen wir die ALU‐
Funktion add.
• Für die arithmetisch‐logischen Instruktionen add, sub, and, or, slt brauchen wir die entsprechende passende ALU‐Funktion.
• Für die Branch‐Instruktion beq brauchen wir die ALU‐Funktion sub.
Vorüberlegung: die Instruktionsformate
Wenn der Wert von Bit 31 bis 26 in der gefetchten Instruktion gleich
• 0: arithmetisch‐logische Instruktion (d.h. add,sub,and,or,slt).
Die Funktion ist mit dem Wert von Bit 5 bis 0 festgelegt.
• 35 oder 43: Load‐ bzw. Store‐Instruktion (d.h. lw, sw).
• 4: Branch‐Instruktion (d.h. beq).
(I-type)
(I-type)
ALU‐Control
ALU‐
Control
Belegung der ALU‐
Steuerleitungen, so dass die ALU die richtigen ALU‐
Operation ausführt.
Ausgabe Eingabe
5‐Bit‐Funct‐Field der Instruktion ALUOp in
Abhängigkeit des Instruktionstyps
In einer Wahrheitstabelle zusammengefasst
Eingabe Ausgabe
Daraus lässt sich mechanisch eine kombinatorische Schaltung generieren, die wir im Folgenden mit dem ALU‐Control‐Symbol abstrakt darstellen.
ALU‐
Control ALUOp
Instruction[5:0]
(also das Funct‐Field
ALU‐Operation 0
0
Erweiterung des Blockschaltbilds
Control einer einfachen MIPS‐CPU
Main‐Unit‐Control
Opcode bestimmt Steuerleitungsbelegungen
Instruction RegDst ALUSrc
Memto
‐Reg
Reg‐
Write
Mem‐
Read
Mem‐
Write Branch
ALU‐
Op1
ALU‐
Op0
R‐format (0) lw (35) sw (43) beq(4)
Eingabe:
Instruction [31‐26] Ausgabe
Auch hier wieder
Aus voriger Wahrheitstabelle lässt sich mechanisch eine
kombinatorische Schaltung generieren, die wir im Folgenden mit dem Control‐Symbol abstrakt darstellen.
Control
Instruction[31—26]
(also: das Opcode‐
Field der Instruktion)
RegDst Branch MemRead MemtoReg ALUOp MemWrite ALUSrc RegWrite
Erweiterung des Blockschaltbilds
Beispiel für eine R‐Typ‐Instruktion
• Instruktion wird gefetched und PC um 4 erhöht.
• Die Register $t2 (Instruction [25‐21]) und $t3
(Instruction [20‐16]) werden aus dem Register‐File geladen.
• Die ALU führt die in dem Function‐Field (Instruction [5‐0]) codierte Operation auf den gelesenen Register‐
Daten aus.
• Das Ergebnis der ALU wird in Register $t1 (Instruction [15‐11]) zurück geschrieben.
add $t1, $t2, $t3
Beispiel für eine Load/Save‐Instruktion
• Instruktion wird gefetched und PC um 4 erhöht.
• Das Register $t2 (Instruction [25‐21]) wird aus dem Register‐File geladen.
• Die ALU addiert das Register‐Datum und den 32‐Bit Sign‐
exteded 16‐Bit‐Immediate‐Wert 8 (Instruction [15‐0]).
• Die Summe aus der ALU wird als Adresse für den Datenspeicher verwendet.
• Das Datum aus dem Datenspeicher wird in das Register‐File geschrieben. Das Register in das geschrieben wird ist $t1 (Instruction [20‐16]).
lw $t1, 8($t2)
Beispiel für eine Branch‐Instruktion
• Instruktion wird gefetched und PC um 4 erhöht.
• Die Register $t1 (Instruction [25‐21]) und $t2 (Instruction [20‐16]) werden aus dem Register‐File geladen.
• Die Haupt‐ALU subtrahiert die ausgelesenen Register‐Daten voneinander.
Die zusätzliche ALU addiert PC+4 auf den 32‐Bit Sign‐
exteded und um 2 nach links geshifteten 16‐Bit‐Immediate‐
Wert 42 (Instruction [15‐0]).
• Das Zero‐Ergebins der Haupt‐ALU entscheidet ob der PC auf PC+4 oder auf das Ergebnis der zusätzlichen ALU gesetzt
wird.
beq $t1, $t2, 42
Eine Übung zum Abschluss
In der vorigen „Übung zum Abschluss“ wurde das Blockschaltbild des Datenpfads so erweitert, sodass auch die MIPS‐Instruktion j unterstützt wird.
Wie müssen Control und Alu‐Control modifiziert werden (wenn überhaupt), damit die MIPS‐Instruktion j auch von Seiten des Control unterstützt wird?
Erinnerung:
j addr # Springe pseudo-direkt nach addr
000010 address
Opcode Bits 31‐26
Adresse Bits 25‐0
J‐Typ
Pipelining
Pipelining
Instruktionszyklen
MIPS‐Instruktionszyklus
Ein MIPS‐Instruktionszklus besteht aus:
1. Instruktion aus dem Speicher holen (IF: Instruction‐Fetch)
2. Instruktion decodieren und Operanden aus Register lesen (ID: Instruction‐Decode/Register‐File‐Read)
3. Ausführen der Instruktion oder Adresse berechnen (EX: Execute/Address‐Calculation)
4. Datenspeicherzugriff
(MEM: Memory‐Access)
5. Resultat in Register abspeichern (WB: Write‐Back)
Instruktionszyklen in unserem Blockschaltbild
Instruktionszyklen generell
• Instruktionszyklen anderer moderner CPUs haben diese oder eine sehr ähnliche Form von
Instruktionszyklen.
• Unterschiede sind z.B.:
– Instruktion decodieren und Operanden lesen sind zwei getrennte Schritte. Dies ist z.B. notwendig,
• wenn Instruktionen sehr komplex codiert sind (z.B. x86 Instruktionen der Länge 1 bis 17 Byte)
• wenn Instruktionen Operanden im Speicher anstatt Register haben (z.B. einige Instruktionen bei x86)
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
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
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:
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 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 Generell: Alles was in einem späteren Clock‐Cycle noch verwendet werden könnte, muss
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
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
