Grundlagen der Rechnerarchitektur

(1)

Grundlagen der Rechnerarchitektur

Prozessor

(2)

Übersicht

• Datenpfad

• Control

• Pipelining

• Data‐Hazards

• Control‐Hazards

• Multiple‐Issue

(3)

Datenpfad einer einfachen MIPS‐CPU

Grundlagen der Rechnerarchitektur ‐Prozessor 3

(4)

Ziel

Konstruktion des Datenpfads einer einfachen MIPS‐CPU als

Blockschaltbild. Die CPU hat 32 Register und soll folgende MIPS‐

Instruktionen realisieren:

Instruktionen für Speicherzugriff: lw, sw

lw $s1, 4($s2) # $s1 = Memory[$s2+4]

sw $s1, 4($s2) # Memory[$s2+4] = $s1

Arithmetisch‐logische Instruktionen: add, sub, and, or, slt add $s0, $s1, $s2 # $s0 = $s1 + $s2

slt $s0, $s1, $s2 # $s0 = ($s1<$s2)? 1 : 0 Branch‐ Instruktion: beq

beq $s1, $s2, 4096 # $pc = $pc + 4 + 4096<<2, wenn $s1=$s2

(5)

Datenpfad einer einfachen MIPS‐CPU

Erster Abschnitt des Datenpfades

(6)

Benötigte Bausteine

Speicherbaustein in dem die abzuarbeitenden Instruktionen stehen. „Instruction Address“ ist 32‐Bit groß. Wenn an den

Leitungen „Instruction Address“

eine Adresse anliegt, liegt im nächsten Taktzyklus eine 32‐Bit lange Instruktion auf den

„Instruction“ Leitungen.

Register in dem der Programm‐Counter steht. Hier steht die Adresse der nächsten abzuarbeitenden Instruktion.

Eine ALU, die fest auf die Funktion Addieren

verdrahtet ist. Mit dieser ALU wird der Program‐

Counter in 4er Schritten erhöht, um auf die

nächste folgende Instruktion zu zeigen.

(7)

Erster Schritt der Instruktionsausführung

Mit dem neuen Clock‐Signal passiert folgendes:

Instruction‐Fetch:

Lag der Program‐Counter‐Wert seit dem letzten Clock‐Signal am Instruction‐Memory an, erscheint mit dem nächsten Clock‐

Signal die nächste auszuführende Instruktion an der Instruction‐

Leitung.

Program‐Counter erhöhen:

Damit der Speicher schon mit dem Bereitstellen der nächsten Instruktion beginnen kann, wird der Program‐Counter direkt zu Beginn der Instruktionsabarbeitung auf die nächste

abzuarbeitende Instruktion gesetzt.

(8)

Das Blockschaltbild dazu

(9)

Datenpfad einer einfachen MIPS‐CPU

Arithmetische‐Logische Operationen

(10)

Erinnerung, Instruktionen vom R‐Typ‐Format:

Solche Instruktionen machen immer folgendes:

• Lese zwei Register (src1 und src2)

• Führe eine ALU‐Operation darauf aus

• Schreibe Ergebnis zurück in ein Register (dest)

Alle hier zu realisierenden arithmetisch‐logischen Instruktionen (d.h. add, sub, and, or, slt) sind R‐Typ‐Instruktionen.

Zum Speichern der Registerinhalte und zur Durchführung der Rechenoperationen benötigen wir zwei weitere Bausteine.

Betrachten zunächst R‐Typ‐Instruktionen

opcode src1 src2 dest shamt funct

6 Bit 5 Bit 5 Bit 5 Bit 5 Bit 6 Bit

R‐Typ (Register‐Typ) 31 26 25 21 20 16 15 11 10 6 5 0

(11)

Register‐File und ALU

Auf den Read‐Data‐Leitungen liegen die 32‐Bit‐Inhalte der Register, die den 5‐Bit‐Read‐Register‐Inputs entsprechen.

Ein Register‐File ist wesentlich schneller als der Speicher.

Daten liegen in einem Instruktionszyklus unmittelbar auf den Read‐Data‐Leitungen vor. In einem Taktzyklus

überschriebener Registerinhalt ist erst im darauf folgenden auf den Read‐Data‐Leitungen sichtbar.

Zum Schreiben in ein Register müssen die Daten auf den Write‐Data‐Leitungen vorliegen und die RegWrite‐Leitung muss aktiv sein.

Die ALU rechnet auf 32‐

Bit‐Werten. Die ALU‐

Operation wird über die 4‐Bit ALU‐Operation‐

Leitungen gewählt;

hierzu später mehr. Die Zero‐Leitung ist 0, wenn das ALU‐Ergebnis 0

ergab.

Bildquelle: David A. Patterson und John L. Hennessy, „Computer Organization and Design“, Fourth Edition, 2012

(12)

Erweiterung des Blockschaltbilds

(13)

Datenpfad einer einfachen MIPS‐CPU

Die Branch‐Instruktion beq

(14)

Betrachten nun Branch‐Instruktion beq

Erinnerung, Branch‐Instruktionen beq ist vom I‐Typ‐Format:

beq‐Instruktion macht immer folgendes:

• Ziehe zwei Register voneinander ab (reg1 und reg2)

• Wenn das Ergebnis ungleich 0: nächste Instruktion ist bei PC+4

• Wenn das Ergebnis gleich 0 :

• Sign‐Extension von 16‐Bit‐Offset auf 32‐Bit Zahl x

• x = 4*x (lässt sich durch ein Links‐Shift von 2 erreichen)

• nächste Instruktion ist bei PC+4+x

Berechnung reg1 ‐ reg2 ist durch den Datenpfad schon realisiert.

Für den Rest brauchen wir noch zwei neue Bausteine:

31 26 25 21 20 16 15 0

opcode reg1 reg2 Offset

6 Bit 5 Bit 5 Bit 16 Bit

I‐Typ

(Immediate‐Typ)

(15)

Sign‐Extend und Shift‐Left 2

Grundlagen der Rechnerarchitektur ‐Logik und Arithmetik 15

Sign‐

Extend

Vorzeichenbehaftetes Ausweiten von k auf n Leitungen (z.B. 16 auf 32).

Shift‐

Left 2

Links oder Rechts‐Shift von Leitungen (z.B. Shift‐Left 2)

k n

(16)

Wir müssen außerdem eine Auswahl treffen

• Wenn die aktuelle Instruktion ein beq ist, dann berechne den PC nach vorhin beschriebener Vorschrift.

• Wenn die Instruktion kein beq ist, dann bestimme den PC wie bisher gehabt; also PC=PC+4.

• Zum Treffen von Auswahlen brauchen wir eine weiteren

Bausteintyp:

(17)

Multiplexer

Grundlagen der Rechnerarchitektur ‐Logik und Arithmetik 17

0 Mux 1 Select

A B

C

Für ein Bit Für n Bit (z.B. 32 Bit)

0 Mux 1 Select

A B

C

32 32

32

C = A, wenn Select = 0 C = B, wenn Select = 1

Für n‐Bit‐Select (z.B. 2 Bit) Select Mux

A₁ A₄

C A₂ A₃

C = A₀, wenn Select = 00 C = A₁, wenn Select = 01 C = A₂, wenn Select = 10 C = A₃, wenn Select = 11

(18)

Erweiterung des Blockschaltbilds

(19)

Datenpfad einer einfachen MIPS‐CPU

Zugriff auf den Datenspeicher

(20)

Betrachten nun Load‐ und Store‐Word

Erinnerung, Instruktionen lw und sw sind vom I‐Typ‐Format:

Die Adresse des Speicherzugriffs berechnet sich wie folgt:

• Sign‐Extension von 16‐Bit‐Offset auf 32‐Bit Zahl x

• Adresse ist Inhalt von reg1 + x

Hierzu werden wir vorhandene ALU und Sign‐Extend mitbenutzen Der Speicherinhalt wird dann

• bei lw in Register reg2 geschrieben

• bei sw mit Registerinhalt von reg2 überschrieben

Zur Vereinfachung trennen wir im Folgenden den Speicher der Instruktionen vom Speicher der Daten. Letzterer ist wie folgt:

31 26 25 21 20 16 15 0

opcode reg1 reg2 Offset

6 Bit 5 Bit 5 Bit 16 Bit

I‐Typ

(Immediate‐Typ)

(21)

Datenspeicher

Speicherbaustein in dem die Daten liegen. „Address“, „Write‐Data“ und „Read‐Data“

sind 32‐Bit groß. In keinem Taktzyklus wird gleichzeitig gelesen und geschrieben.

Schreiben oder lesen wird über Signale an MemWrite und MemRead durchgeführt. Der Grund für ein MemRead ist, dass sicher gestellt sein muss, dass die anliegende Adresse gültig ist (mehr dazu im Kapitel Speicher).

(22)

Erweiterung des Blockschaltbilds

(23)

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

(24)

Control einer einfachen MIPS‐CPU

(25)

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

(26)

Control einer einfachen MIPS‐CPU

ALU‐Control

(27)

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.

(28)

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)

(29)

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

(30)

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

(31)

Erweiterung des Blockschaltbilds

(32)

Control einer einfachen MIPS‐CPU

Main‐Unit‐Control

(33)

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

(34)

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

(35)

Erweiterung des Blockschaltbilds

(36)

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

(37)

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)

(38)

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

(39)

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

(40)

Pipelining

(41)

Pipelining

Instruktionszyklen

(42)

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)

(43)

Instruktionszyklen in unserem Blockschaltbild

(44)

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)