Vorlesung Rechnerarchitektur - Fachbereich Informatik
Vorlesung Rechnerarchitektur - Fachbereich Informatik
Vorlesung Rechnerarchitektur - Fachbereich Informatik
Sie wollen auch ein ePaper? Erhöhen Sie die Reichweite Ihrer Titel.
YUMPU macht aus Druck-PDFs automatisch weboptimierte ePaper, die Google liebt.
<strong>Vorlesung</strong> <strong>Rechnerarchitektur</strong><br />
Der MU0 Rechner
D er von N eum a nn R ec hner<br />
Control Unit<br />
Memory<br />
Arithmetic<br />
Logic Unit<br />
Accumulator<br />
Arithmetic Logic Unit - Rechenwerk<br />
führt Berechnungen durch<br />
Control Unit - Steuerwerk<br />
interpretiert die Anweisungen und<br />
steuert die Befehlsabfolge<br />
Memory - Speicherwerk<br />
speichert sowohl Programme als auch<br />
Input<br />
Output<br />
Daten<br />
Input/Output - Ein/Ausgabewerk<br />
steuert die Eingabe und Ausgabe von<br />
Daten zum Anwender<br />
<strong>Vorlesung</strong> <strong>Rechnerarchitektur</strong><br />
© Gerhard Raffius, WS 2009/10, h_da - <strong>Fachbereich</strong> <strong>Informatik</strong><br />
2
H is torie des M U 0<br />
Der MU0 Rechner ist nach dem ersten funktionierenden Digitalcomputer der Welt,<br />
dem SSEM (Small Scale Experimental Machine) der Universität Manchester<br />
modelliert worden<br />
Der SSEM führte am 21. Juni 1948 zum ersten mal ein Programm aus dem<br />
Speicher heraus aus<br />
Es ist damit die erste erfolgreiche Implementierung eines von Neumann Rechners<br />
Er wird an der Universität Manchester zu Lehrzwecken eingesetzt<br />
<strong>Vorlesung</strong> <strong>Rechnerarchitektur</strong><br />
© Gerhard Raffius, WS 2009/10, h_da - <strong>Fachbereich</strong> <strong>Informatik</strong><br />
3
D ie E lem ente des M U 0 R ec hners<br />
Adressbus<br />
ALU- Arithmetic Logic Unit<br />
kann rechnen<br />
PC<br />
control<br />
IR<br />
PC- Programm Counter<br />
Speichert die aktuelle<br />
ALU<br />
ACC<br />
memory<br />
Programmadresse<br />
ACC- Akkumulator<br />
Ergebnis Register für<br />
Rechnungen<br />
Datenbus<br />
IR - Instruction Register<br />
Speichert den aktuellen<br />
<strong>Vorlesung</strong> <strong>Rechnerarchitektur</strong><br />
© Gerhard Raffius, WS 2009/10, h_da - <strong>Fachbereich</strong> <strong>Informatik</strong><br />
Befehlscode<br />
Memory – Speicher<br />
Speichert Programme<br />
und Daten<br />
4
B eis piel für einen B efehls a bla uf<br />
<strong>Vorlesung</strong> <strong>Rechnerarchitektur</strong><br />
© Gerhard Raffius, WS 2009/10, h_da - <strong>Fachbereich</strong> <strong>Informatik</strong><br />
5
D er R ec henzyklus : Fetc h<br />
Im Fetchzyklus wird der Wert<br />
Adressbus<br />
des Programcounters auf den<br />
PC<br />
control<br />
IR<br />
Adressbus gelegt und der<br />
Programmcode aus dem<br />
ALU<br />
ACC<br />
memory<br />
Speicher in das<br />
Instructionregister gelesen<br />
Die ALU erhöht gleichzitig den<br />
Datenbus<br />
Wert des Programmcounters<br />
und speichert diesen wieder<br />
zurück<br />
<strong>Vorlesung</strong> <strong>Rechnerarchitektur</strong><br />
© Gerhard Raffius, WS 2009/10, h_da - <strong>Fachbereich</strong> <strong>Informatik</strong><br />
6
D er R ec henzyklus : D ec ode/E xec ute für<br />
R ec henopera tion<br />
Bei einer Rechenoperation wird die<br />
Adressbus<br />
Adresse des Operanden aus dem<br />
PC<br />
control<br />
IR<br />
Befehl dekodiert und der Wert des<br />
angesprochenen Speicherworts an<br />
ALU<br />
ACC<br />
memory<br />
den einen Eingang der ALU<br />
geschaltet<br />
Der Zweite Eingang der ALU erhält<br />
Datenbus<br />
seine Information vom Akkumulator<br />
Das Ergebnis der Rechnung wird<br />
wieder im Akkumulator gespeichert<br />
<strong>Vorlesung</strong> <strong>Rechnerarchitektur</strong><br />
© Gerhard Raffius, WS 2009/10, h_da - <strong>Fachbereich</strong> <strong>Informatik</strong><br />
7
D a s m odifizierte M U 0 D a tenpfa d M odell<br />
Die Einführung von Multiplexern<br />
MU0<br />
Datenpfad<br />
Data Out<br />
Adress<br />
00 A 11<br />
Data In<br />
erlaubt die Kontrolle des<br />
Datenpfads und des<br />
Adressbusses<br />
Der modifizierte Mu0 hat jetzt zwei<br />
ACC<br />
PC<br />
IR<br />
getrennte interne Busse, den A<br />
und den B Bus<br />
ALU<br />
A<br />
BB<br />
00 B 11<br />
Die ALU hat zwei Eingänge, A und<br />
B<br />
Erst durch diese Modifikationen ist<br />
Timing/Control<br />
eine einfache Realisierung des<br />
MU0 möglich<br />
<strong>Vorlesung</strong> <strong>Rechnerarchitektur</strong><br />
© Gerhard Raffius, WS 2009/10, h_da - <strong>Fachbereich</strong> <strong>Informatik</strong><br />
8
M U 0 E lem ente<br />
ACC<br />
ie<br />
oe<br />
Akkumulator: ie -> Lesen, oe -> Schreiben<br />
PC<br />
ie<br />
oe<br />
Program Counter: ie ->Lesen, oe -> Schreiben<br />
IR<br />
ie<br />
oe<br />
Instruction Register: ie -> Lesen, oe → Schreiben (fest auf 1)<br />
ALU<br />
A<br />
BB<br />
ALUfs<br />
ALU: Funktionsauswahl über ALUfs<br />
00 A 11<br />
00 B 11<br />
Asel<br />
Bsel<br />
Adressbusmultiplexer A: 0 -> Programcounter, 1 -> Adressteil von IR<br />
Datenbusmultiplexer B: 0 -> Adressteil von IR, 1 -> Daten aus Speicher<br />
Timing/Control<br />
Memory<br />
Steuersignale<br />
MemReq<br />
R/nW<br />
Steuerung: Erzeugt die Steuersignale aus IR, ALU Status, reset<br />
und internem Speicher EX/ft<br />
Speicher: MemReq -> Speicher wird angesprochen,<br />
R/nW -> 1 Lesen, 0 Schreiben<br />
<strong>Vorlesung</strong> <strong>Rechnerarchitektur</strong><br />
© Gerhard Raffius, WS 2009/10, h_da - <strong>Fachbereich</strong> <strong>Informatik</strong><br />
9
D er M ultiplexer<br />
Der Multiplexer ist ein Schalter, der<br />
durch das Anlegen eines Steuersignals<br />
das ausgewählte Eingangssignal auf<br />
den Ausgang legt<br />
S teu<br />
er<br />
s ig na<br />
l<br />
E ing a ng AE ing a ng B<br />
00 11<br />
A us g a ng<br />
E ing a ng AE ing a ng B<br />
S teu<br />
er<br />
s ig na<br />
l<br />
A us g a ng<br />
<strong>Vorlesung</strong> <strong>Rechnerarchitektur</strong><br />
© Gerhard Raffius, WS 2009/10, h_da - <strong>Fachbereich</strong> <strong>Informatik</strong><br />
10
R eg is ter<br />
ie<br />
oe<br />
oe<br />
schreiben<br />
16<br />
...<br />
Register<br />
ie<br />
16<br />
...<br />
lesen<br />
/2 <br />
Zeit<br />
Ein Register ist ein Speicher, der<br />
Daten liest, wenn das Signal ie (input<br />
enable) anliegt und Daten ausgibt,<br />
wenn das Signal oe (ouput<br />
enable)anliegt<br />
Ausgeben und Lesen erfolgt jeweils<br />
beim Flankenwechsel des<br />
Prozessortakts. Das Ausgeben erfolgt<br />
einen halben Takt früher wie das<br />
Lesen, so dass innerhalb eines Zyklus<br />
ein Register seine Information<br />
ausgeben und danach eine neue<br />
Information lesen kann.<br />
<strong>Vorlesung</strong> <strong>Rechnerarchitektur</strong><br />
© Gerhard Raffius, WS 2009/10, h_da - <strong>Fachbereich</strong> <strong>Informatik</strong><br />
11
S peic her<br />
CPU<br />
Adressen<br />
Daten<br />
MemRQ<br />
RnW<br />
Speicher<br />
Ein Speicher besteht aus einer Menge<br />
von Speicherworten die durch eine<br />
Adresse anwählbar sind<br />
<strong>Vorlesung</strong> <strong>Rechnerarchitektur</strong><br />
© Gerhard Raffius, WS 2009/10, h_da - <strong>Fachbereich</strong> <strong>Informatik</strong><br />
Die Steuersignale des Datenbus eines<br />
Prozessors sind:<br />
MemRQ, das bedeutet Memory<br />
Request. Der Speicherbaustein wird<br />
angesprochen. Dieses Signal ist<br />
notwendig, da mehrere<br />
Speicherbausteine vorhanden sein<br />
können<br />
RnW, das bedeutet "Read / not<br />
Write". Dieses Signal gibt an, ob<br />
von dem Speicher gelesen wird,<br />
oder ob eine Information in den<br />
Speicher geschrieben wird. Wenn<br />
nicht geschrieben wird, sollte RnW<br />
immer auf Read geschaltet sein<br />
12
B us s ys tem e<br />
Ein Systembus ist aus einem Datenbus, Adressbus und Kontrollbus sowie einem<br />
Bus zur elektrischen Versorgung der Komponenten aufgebaut.<br />
Einige Architekturen beinhalten zusätzlich noch einen I/O-Bus.<br />
CPU -<br />
ALU und<br />
Steuerwerk<br />
Speicher<br />
Ein-<br />
Ausgabe<br />
<strong>Vorlesung</strong> <strong>Rechnerarchitektur</strong><br />
© Gerhard Raffius, WS 2009/10, h_da - <strong>Fachbereich</strong> <strong>Informatik</strong><br />
Datenbus<br />
Adressbus<br />
Kontrollbus<br />
Versorgung<br />
13
D ie vers c hiedenen B efehls g ruppen im<br />
D a tenpfa dm odell<br />
Der Multiplexer B steht auf 1 bei<br />
MU0<br />
Datenpfad<br />
Data Out<br />
Adress<br />
00 A 11<br />
Data In<br />
allen Datenverarbeitungsbefehlen<br />
und auf 0 bei allen<br />
Sprungbefehlen<br />
Der Multiplexer A wird bei den<br />
ACC<br />
PC<br />
IR<br />
bisherigen Befehlen nur für den<br />
Fetchzyklus auf 0 gestellt,<br />
ALU<br />
A<br />
BB<br />
00 B 11<br />
ansonsten wird S (unterer Teil von<br />
IR) immer als Adresse<br />
interpretiert<br />
Timing/Control<br />
Bei Sprungbefehlen erfolgt kein<br />
Datenzugriff, S (IR) wird direkt<br />
nach PC verschoben<br />
<strong>Vorlesung</strong> <strong>Rechnerarchitektur</strong><br />
© Gerhard Raffius, WS 2009/10, h_da - <strong>Fachbereich</strong> <strong>Informatik</strong><br />
14
Ins truc tion S et des M U 0 R ec hners<br />
4 Bit 12 Bit<br />
opcode<br />
Adresse<br />
Instruction Opcode Effect<br />
LDA S 0000 ACC = mem 16 [S]<br />
STO S 0001 mem 16 [S] = ACC<br />
ADD S 0010 ACC = ACC + mem 16 [S]<br />
SUB S 0011 ACC = ACC - mem 16 [S]<br />
JMP S 0100 PC = S<br />
JGE S 0101<br />
JNE S 0110<br />
STP 0111 stop<br />
IF ACC ≥ 0 PC = S<br />
IF ACC ≠ 0 PC = S<br />
Die Instruktionen setzen sich<br />
zusammen aus einem 4 Bit Operation<br />
Code und einer 12 Bit Adresse<br />
Der Prozessor kennt Befehle zum<br />
Laden und Speichern von Werten<br />
Zur Berechnung<br />
und zur Ablaufkontrolle<br />
<strong>Vorlesung</strong> <strong>Rechnerarchitektur</strong><br />
© Gerhard Raffius, WS 2009/10, h_da - <strong>Fachbereich</strong> <strong>Informatik</strong><br />
15
M U 0 K ontroll Log ic<br />
Inputs<br />
Outputs<br />
Instruction Opcode Reset Step ACCz ACC15 Step Asel Bsel ACCoe ACCie PCoe Pcie Irie ALUfs MEMrq R/nW<br />
Reset xxxx 1 x x x 0 x x 0 0 0 1 0 0 0 1<br />
Fetch xxxx 0 0 x x 1 0 x 0 0 1 1 1 A+1 1 1<br />
LDA S 0000 0 1 x x 0 1 1 0 1 0 0 0 B 1 1<br />
STO S 0001 0 1 x x 0 1 x 1 0 0 0 0 x 1 0<br />
ADD S 0010 0 1 x x 0 1 1 1 1 0 0 0 A+B 1 1<br />
SUB S 0011 0 1 x x 0 1 1 1 1 0 0 0 A-B 1 1<br />
JMP S 0100 0 1 x x 0 x 0 0 0 0 1 0 B 0 1<br />
JGE S 0101<br />
0 1 x 1 0 x x 0 0 0 0 0 x 0 1<br />
0 1 x 0 0 x 0 0 0 0 1 0 B 0 1<br />
JNE S 0110<br />
0 1 1 x 0 x x 0 0 0 0 0 x 0 1<br />
0 1 0 x 0 x 0 0 0 0 1 0 B 0 1<br />
STOP 0111 0 1 x x 1 x x 0 0 0 0 0 x 0 1<br />
<strong>Vorlesung</strong> <strong>Rechnerarchitektur</strong><br />
© Gerhard Raffius, WS 2009/10, h_da - <strong>Fachbereich</strong> <strong>Informatik</strong><br />
16
E in M U 0 P rog ra m m<br />
Loop LDA Total ; Accumulate total<br />
Add_instr ADD Table ; Begin at head of table<br />
STO Total ;<br />
LDA Add_instr ; Change address ...<br />
ADD One ; by modifying instruction!<br />
STO Add_instr ;<br />
LDA Count ; Count iterations<br />
SUB One ; Count down to zero<br />
STO Count ;<br />
JGE Loop ; If >= 0 repeat<br />
STP<br />
; Halt execution<br />
; Data definitions<br />
Total DEFW 0 ; Total - initially zero<br />
One DEFW 1 ; The number one<br />
Count DEFW 4 ; Loop counter (loop 5x)<br />
Table DEFW 39 ; The numbers to total ...<br />
DEFW 25 ;<br />
DEFW 4 ;<br />
DEFW 98 ;<br />
DEFW 17 ;<br />
Dieses Programm<br />
enthält sich selbst<br />
modifizierenden Code.<br />
Tun sie das besser<br />
nicht, wenn sie nicht<br />
sehr genau wissen was<br />
sie tun!!!<br />
<strong>Vorlesung</strong> <strong>Rechnerarchitektur</strong><br />
© Gerhard Raffius, WS 2009/10, h_da - <strong>Fachbereich</strong> <strong>Informatik</strong><br />
17
<strong>Vorlesung</strong> <strong>Rechnerarchitektur</strong><br />
Der MU1 Rechner
D ie G rundfunktionen der A LU<br />
AB ist der Ausgang des Addierers<br />
A−B wird gebildet alsAB1<br />
B wird implementiert indem der<br />
Eingang A fest auf 0 gesetzt wird<br />
A1 wird implementiert indem der<br />
Eingang B fest auf 0 gesetzt und der<br />
Carry Eingang auf 1 gesetzt wird<br />
Alle Funktionen dieser einfachen ALU<br />
können also durch einen Addierer mit<br />
Carry Eingang gebildet werden,<br />
dessen Eingang A auf Null gesetzt und<br />
dessen Eingang B invertiert werden<br />
kann.<br />
FA<br />
A-Bus<br />
ADDIERER<br />
A B<br />
0<br />
C-Bus<br />
FB<br />
B-Bus<br />
0<br />
FS<br />
Inverter<br />
FC<br />
FI<br />
Wie kann man mit dieser<br />
ALU A-1 berechnen?<br />
Statusregister<br />
N Z C V<br />
F1<br />
0<br />
1<br />
<strong>Vorlesung</strong> <strong>Rechnerarchitektur</strong><br />
© Gerhard Raffius, WS 2009/10, h_da - <strong>Fachbereich</strong> <strong>Informatik</strong><br />
19
D ie G rundfunktionen der A LU<br />
C-Bus<br />
FS<br />
FC<br />
Statusregister<br />
N Z C V<br />
Funk FA FB FI FC F1 FS<br />
tion<br />
0 0 0 0 0 0<br />
FA<br />
A-Bus<br />
ADDIERER<br />
A B<br />
0<br />
FB<br />
0<br />
Inverter<br />
FI<br />
F1<br />
0<br />
1<br />
1 0 0 0 0 1<br />
-1 0 0 1 0 0<br />
A 1 0 0 0 0<br />
B 0 1 0 0 0<br />
A+1 1 0 0 0 1<br />
B-Bus<br />
B+1 0 1 0 0 1<br />
A-1 1 0 1 0 0<br />
A+B 1 1 0 0 0<br />
<strong>Vorlesung</strong> <strong>Rechnerarchitektur</strong><br />
© Gerhard Raffius, WS 2009/10, h_da - <strong>Fachbereich</strong> <strong>Informatik</strong><br />
A-B 1 1 1 0 1<br />
20
D er M u1 D a tenpfa d<br />
Mu1<br />
Datenpfad<br />
A-Bus<br />
ACC<br />
Data Out<br />
SP<br />
A<br />
Dout<br />
ALU<br />
PC<br />
B<br />
B-Bus<br />
Adress<br />
0 1<br />
IR<br />
Data In<br />
Timing/Control<br />
Din<br />
Das erweitere MU0 Modell<br />
besitzt einen Stackpointer<br />
und Register Din und Dout.<br />
Durch die zusätzlichen<br />
Register Din und Dout<br />
braucht unser Modell jetzt<br />
zwar mehr Taktzyklen,<br />
aber diese können<br />
schneller durchlaufen<br />
werden<br />
<strong>Vorlesung</strong> <strong>Rechnerarchitektur</strong><br />
© Gerhard Raffius, WS 2009/10, h_da - <strong>Fachbereich</strong> <strong>Informatik</strong><br />
21
M u1 E lem ente ohne S peic her und S teuerung<br />
ACC<br />
ie<br />
oe<br />
Akkumulator: ie -> Lesen, oe -> Schreiben<br />
PC<br />
ie<br />
oe<br />
Program Counter: ie ->Lesen, oe -> Schreiben<br />
IR<br />
ie<br />
oe<br />
Instruction Register: ie -> Lesen, Asel = o -> Schreiben<br />
SP<br />
ie<br />
oe<br />
Stackpointer Register: ie -> Lesen, oe -> Schreiben<br />
Din<br />
ie<br />
oe<br />
DataIn Register: ie -> Lesen, oe -> Schreiben<br />
Dout<br />
ie<br />
oe<br />
DataOut Register: ie -> Lesen, oe -> Schreiben<br />
ALU<br />
A<br />
BB<br />
ALUfs<br />
ALU: Funktionsauswahl über ALUfs<br />
00 A 11<br />
Asel<br />
Adressbusmultiplexer A: 0 -> A-Bus, 1 -> B-Bus<br />
<strong>Vorlesung</strong> <strong>Rechnerarchitektur</strong><br />
© Gerhard Raffius, WS 2009/10, h_da - <strong>Fachbereich</strong> <strong>Informatik</strong><br />
22
D er R es et<br />
Jeder Prozessor hat einen Reset Eingang. Normalerweise ist dieser als /Reset also<br />
als not Reset ausgeführt, so dass bei Anlegen einer 0 ein Reset ausgeführt wird.<br />
Liegt am /Reset Eingang eine 0 an, so wird der Prozessor auf einen Grundzustand<br />
zurückgesetzt, das heißt der Program Counter wird auf 0 gestellt und der<br />
Microprogramcounter step wird ebenfalls auf 0 gesetzt.<br />
Beim Einschalten eines Prozessors wird das /Reset Signal verzögert gesetzt, so<br />
dass der Prozessor Zeit hat, seinen Startzustand herzustellen. Das Taktsignal<br />
muss dazu schon mehrere Takte vorhanden sein, bis /Reset auf 1 gehen darf.<br />
<strong>Vorlesung</strong> <strong>Rechnerarchitektur</strong><br />
© Gerhard Raffius, WS 2009/10, h_da - <strong>Fachbereich</strong> <strong>Informatik</strong><br />
23
D er R es et<br />
MU1<br />
Datenpfad<br />
ACC<br />
A<br />
A-Bus<br />
Data Out<br />
SP<br />
SP<br />
Dout<br />
Dout<br />
ALU<br />
A ALUB<br />
PC<br />
PC<br />
Adress<br />
0 1<br />
C-Bus<br />
0<br />
IR IR<br />
Timing/Control<br />
Data In<br />
Din Din<br />
B-Bus<br />
Die Alu wird auf die Funktion Null<br />
gesetzt und der PC mit diesem Wert<br />
geladen<br />
der Speicher Step in der Steuereinheit<br />
wird auf 0 gesetzt, so dass im<br />
nächsten Schritt ohne Reset ein fetch<br />
von der Adresse 0 ausgeführt wird<br />
Instruction<br />
Inputs Outputs Funktion<br />
Opcode<br />
/Reset<br />
step<br />
Z<br />
N<br />
step<br />
Adress<br />
ACCoe<br />
ACCie<br />
PCoe<br />
PCie<br />
IRoe<br />
Reset xxxx 0 x x x 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 1 PC = 0<br />
IRie<br />
SPoe<br />
SPie<br />
DINoe<br />
DINie<br />
DOUToe<br />
DOUTie<br />
ALU<br />
Function<br />
MEMrq<br />
R/nW<br />
<strong>Vorlesung</strong> <strong>Rechnerarchitektur</strong><br />
© Gerhard Raffius, WS 2009/10, h_da - <strong>Fachbereich</strong> <strong>Informatik</strong><br />
24
D er M ic roprog ra m C ounter S tep<br />
Step ist ein Speicher in der Steuereinheit (Timing/Control Unit) unseres Prozessors<br />
die meisten Befehle unseres Prozessors werden nicht in einem Takt ausgeführt,<br />
sondern erfordern mehrere Takte. Der Microprogram Counter step gibt der<br />
Steuerlogik die Information, welche Aktionen jeweils auszuführen sind. Dazu wird<br />
step als Eingangsinformation für jeden Schritt verarbeitet<br />
Zu jedem Schritt steht in der Steuerungstabelle, welcher Wert Step in diesem<br />
Schritt zugewiesen wird, das heißt welches der nächste Schritt ist<br />
<strong>Vorlesung</strong> <strong>Rechnerarchitektur</strong><br />
© Gerhard Raffius, WS 2009/10, h_da - <strong>Fachbereich</strong> <strong>Informatik</strong><br />
25
D er M ic roprog ra m C ounter S tep<br />
Im ersten Schritt eines Befehls (step ist null), erfolgt immer der fetch, das heißt das<br />
Lesen des Befehls in das Instruktion Register. Der Opcode des Befehls wird dabei<br />
ignoriert<br />
Im letzten Schritt eines Befehls wird Step wieder auf Null gesetzt, so dass danach<br />
ein fetch ausgeführt wird.<br />
In den meisten Fällen wird step in einem Schritt um eins erhöht.<br />
step kann aber auch auf einen kleineren Wert gesetzt werden. Dann erhält man<br />
eine Schleife, die man mit einem bedingten Sprung abbrechen kann<br />
<strong>Vorlesung</strong> <strong>Rechnerarchitektur</strong><br />
© Gerhard Raffius, WS 2009/10, h_da - <strong>Fachbereich</strong> <strong>Informatik</strong><br />
26
D er Fetc h Z yklus im M u1<br />
MU1<br />
Datenpfad<br />
ACC<br />
A<br />
A-Bus<br />
Data Out<br />
SP<br />
SP<br />
Dout<br />
Dout<br />
ALU<br />
A ALUB<br />
PC<br />
PC<br />
Adress<br />
0 1<br />
C-Bus<br />
A<br />
+1<br />
IR IR<br />
Timing/Control<br />
Data In<br />
Din Din<br />
B-Bus<br />
Der Programcounter wird auf den<br />
Adressbus geschaltet und gleichzeitig an<br />
den A Eingang der ALU<br />
An der ALU ist der Befehl A+1<br />
ausgewählt, S ist 0<br />
In der zweiten Hälfte des Takts wird vom<br />
Speicher die nächste Instruktion gelesen<br />
und in IR gespeichert<br />
der PC wird über die ALU um eins erhöht<br />
Instruction<br />
Fetch<br />
Inputs Outputs Funktion<br />
Opcode<br />
xxxx<br />
/Reset<br />
step<br />
Z<br />
N<br />
step<br />
Adress<br />
ACCoe<br />
ACCie<br />
PCoe<br />
PCie<br />
IRoe<br />
IRie<br />
SPoe<br />
SPie<br />
1 0 x x 1 0 0 0 1 1 0 1 0 0 0 0 0 0 A+1 1 1 IR=[PC], PC=PC+1<br />
DINoe<br />
DINie<br />
DOUToe<br />
DOUTie<br />
ALU<br />
Function<br />
MEMrq<br />
R/nW<br />
<strong>Vorlesung</strong> <strong>Rechnerarchitektur</strong><br />
© Gerhard Raffius, WS 2009/10, h_da - <strong>Fachbereich</strong> <strong>Informatik</strong><br />
27
D a s La den des A kkum ula tors m it dem Inha lt einer<br />
a bs oluten A dres s e<br />
MU1<br />
Datenpfad<br />
Data Out<br />
Dout<br />
Dout<br />
Adress<br />
0 1<br />
Data In<br />
MU1<br />
Datenpfad<br />
Data Out<br />
Dout<br />
Dout<br />
Adress<br />
0 1<br />
Data In<br />
ACC<br />
A<br />
SP<br />
SP<br />
PC<br />
PC<br />
IR IR<br />
Din Din<br />
ACC<br />
A<br />
SP<br />
SP<br />
PC<br />
PC<br />
IR IR<br />
Din Din<br />
C-Bus<br />
C-Bus<br />
ALU<br />
A ALUB<br />
ALU<br />
A ALUB<br />
B<br />
A-Bus<br />
B-Bus<br />
A-Bus<br />
B-Bus<br />
Timing/Control<br />
Timing/Control<br />
Der Adressteil der Instruktion wird aus dem Instruktion Register auf den<br />
Adressbus gelegt und der Speicherinhalt nach Din geschrieben<br />
Instruction<br />
Inputs Outputs Funktion<br />
Opcode<br />
/Reset<br />
step<br />
Z<br />
N<br />
step<br />
Adress<br />
ACCoe<br />
ACCie<br />
PCoe<br />
PCie<br />
LDA S 0000 1 1 x x 2 1 0 0 0 0 1 0 0 0 0 1 0 0 x 1 1<br />
1 2 x x 0 x 0 1 0 0 0 0 0 0 1 0 0 0 B 0 1<br />
IRoe<br />
IRie<br />
SPoe<br />
SPie<br />
DINoe<br />
DINie<br />
DOUToe<br />
DOUTie<br />
ALU Function<br />
MEMrq<br />
RnW<br />
Din = [IR]<br />
ACC = Din<br />
<strong>Vorlesung</strong> <strong>Rechnerarchitektur</strong><br />
© Gerhard Raffius, WS 2009/10, h_da - <strong>Fachbereich</strong> <strong>Informatik</strong><br />
28
D er S ta c k<br />
A<br />
push<br />
Speicher<br />
Der Stack stellt einen dynamischen<br />
Speicher dar, auf dem Daten<br />
zwischengespeichert werden können<br />
sp<br />
Die Grundoperationen eines Stacks<br />
sind die Operationen Push und Pop<br />
Push erniedrigt den Stackpointer und<br />
schiebt dann einen Wert in das<br />
pop<br />
Speicher<br />
Speicherwort, auf das der Stackpointer<br />
A<br />
gerade zeigt und<br />
sp<br />
Pop liest ein Speicherwort von der<br />
Adresse auf die der Stackpointer zeigt<br />
und erhöht den Stackpointer<br />
<strong>Vorlesung</strong> <strong>Rechnerarchitektur</strong><br />
© Gerhard Raffius, WS 2009/10, h_da - <strong>Fachbereich</strong> <strong>Informatik</strong><br />
29
D er S ta c k im S peic her<br />
SP<br />
ACC<br />
IR<br />
PC<br />
Memory<br />
Stack<br />
Heap<br />
Daten<br />
Code<br />
Code Fetch<br />
Daten Speicherung<br />
Stack Speicherung<br />
<strong>Vorlesung</strong> <strong>Rechnerarchitektur</strong><br />
© Gerhard Raffius, WS 2009/10, h_da - <strong>Fachbereich</strong> <strong>Informatik</strong><br />
Der Stackpointer wird am Anfang auf<br />
eine Adresse am Ende des<br />
Speicherbereichs gesetzt und wächst<br />
dann langsam nach unten<br />
Die Programme werden meistens in<br />
dem unteren Speicherbereich platziert<br />
und der Programmcounter beim Start<br />
auf die Adresse 0 gesetzt<br />
An den Programmbereich schließt sich<br />
nach oben hin der Datenbereich an<br />
Zwischen Daten und Stack findet man<br />
meist einen Heapbereich, eine andere<br />
Form der dynamischen<br />
Speicherverwaltung<br />
30
U nterprog ra m m e<br />
Hauptprogramm<br />
Unterprogramm<br />
Unterprgramme sind ein wichtiges<br />
Strukturierungsmittel für die Programmierung<br />
Unterprogramme werden mit einem<br />
Sprungbefehl (call, bl) angesprungen und es<br />
wird die Adresse nach dem Sprungbefehl<br />
gespeichert. Nach dem Verlassen des<br />
Unterprogramms wird die<br />
Programmausführung an der gespeicherten<br />
Stelle fortgesetzt.<br />
Der Rücksprung erfolgt indem die<br />
gespeicherte Adresse wieder in den<br />
Programcounter übertragen wird<br />
<strong>Vorlesung</strong> <strong>Rechnerarchitektur</strong><br />
© Gerhard Raffius, WS 2009/10, h_da - <strong>Fachbereich</strong> <strong>Informatik</strong><br />
31
U nterprog ra m m A ufrufe<br />
IR<br />
PC<br />
sp<br />
IR<br />
PC<br />
sp<br />
call<br />
return<br />
Speicher<br />
Speicher<br />
Unterprogrammaufrufe nutzen häufig<br />
(nicht bei jedem Prozessor) den Stack zur<br />
Speicherung der Rücksprung-adresse<br />
Beim Call Befehl wird der nächste nach<br />
der Rückkehr auszuführende Befehl auf<br />
dem Stack gespeichert und die<br />
Sprungadresse aus dem<br />
Instructionregister in den PC geladen<br />
Beim Return wird die Rücksprungadresse<br />
vom Stack geholt, in den PC geschrieben<br />
und in einem fetch zyklus die neue<br />
Instruktion geladen<br />
<strong>Vorlesung</strong> <strong>Rechnerarchitektur</strong><br />
© Gerhard Raffius, WS 2009/10, h_da - <strong>Fachbereich</strong> <strong>Informatik</strong><br />
32
Indirekte A dres s ierung<br />
A<br />
STR<br />
Speicher<br />
Die Adresse an die gespeichert oder<br />
von der gelesen werden soll, steht<br />
nicht mehr direkt im Befehl, sondern im<br />
IR<br />
Befehl steht nur noch die<br />
Speicherstelle, an der sich ein Zeiger<br />
auf die Adresse befindet.<br />
A<br />
LDR<br />
Speicher<br />
Mit diesem Befehl ist es möglich<br />
Schleifn zu programmieren, ohne dass<br />
dazu selbstmodifiziernder Code nötig<br />
IR<br />
ist.<br />
<strong>Vorlesung</strong> <strong>Rechnerarchitektur</strong><br />
© Gerhard Raffius, WS 2009/10, h_da - <strong>Fachbereich</strong> <strong>Informatik</strong><br />
33
D er E rw eiterte M U 0 B efehls s a tz<br />
Instruction Opcode<br />
Effekt<br />
Reset xxxx<br />
PC = 0<br />
LDA S 0000 ACC = [S]<br />
STO S 0001 [S] = ACC<br />
ADD S 0010 ACC = ACC + [S]<br />
SUB S 0011 ACC = ACC - [S]<br />
JMP S 0100 PC = S<br />
JGE S 0101 IF N == 0 PC = S<br />
JNE S 0110 IF Z == 0 PC = S<br />
STOP 0111<br />
stop<br />
CALL S 1000 SP = SP-1; [SP] = PC; PC = S<br />
RETURN 1001 PC = [SP], SP = SP + 1<br />
PUSH 1010 SP = SP-1; [SP] = ACC<br />
POP 1011 ACC = [SP], SP = SP + 1<br />
LDR S 1100 DIN = [S]; DIN = [DIN]; ACC = DIN<br />
STR S 1101 DIN = [S], DOUT = A; [DIN] = DOUT<br />
MOV PC 1110 PC = ACC<br />
MOV SP 1111 SP = ACC<br />
<strong>Vorlesung</strong> <strong>Rechnerarchitektur</strong><br />
© Gerhard Raffius, WS 2009/10, h_da - <strong>Fachbereich</strong> <strong>Informatik</strong><br />
34
B es c hreibung des M ic roc odes durc h einfa c he S pra c he<br />
X = Y<br />
der Inhalt des Registers Y wird nach<br />
X verschoben<br />
X = Y op Z<br />
der Inhalt von Y (A-Bus der ALU)<br />
wird mit Z (B-Bus der ALU)<br />
verrechnet und nach X transportiert<br />
X = [Y ]<br />
der Inhalt von Y wird als<br />
[X ] = Y<br />
der Inhalt von X wird als<br />
Adressinformation genommen und<br />
der Inhalt von Y wird in diese<br />
Adresse geschrieben<br />
Adressinformation genommen. Der<br />
Inhalt der Speicherstelle wird nach<br />
X transportiert<br />
<strong>Vorlesung</strong> <strong>Rechnerarchitektur</strong><br />
© Gerhard Raffius, WS 2009/10, h_da - <strong>Fachbereich</strong> <strong>Informatik</strong><br />
35
B es c hreibung des M ic roc odes durc h einfa c he S pra c he<br />
2<br />
A C C = D in<br />
D in = [S P ]<br />
der Inhalt von D in wird nach A C C der Inhalt von SP wird als<br />
transportiert, A C C und D in sind<br />
Adressinformation benutzt<br />
Registernamen<br />
dazu muss der Adressmultiplexer<br />
im Register D in muss oe (Output<br />
auf 0 stehen<br />
enable) gesetzt sein im Register A im Register SP muss oe (Output<br />
muss ie (Input enable) gesetzt sein<br />
enable) gesetzt sein im Register<br />
da der Transport über die ALU<br />
D in muss ie (Input enable) gesetzt<br />
erfolgt muss die ALUfunktion B sein sein<br />
da der Speicher nicht angesprochen da der Speicher angesprochen wird,<br />
wird (keine [] enthalten) ist Memrq 0 muss Memrq 1 sein und da wir<br />
und RnW 1 (Read)<br />
Lesen wollen muss RnW auch 1<br />
sein<br />
<strong>Vorlesung</strong> <strong>Rechnerarchitektur</strong><br />
© Gerhard Raffius, WS 2009/10, h_da - <strong>Fachbereich</strong> <strong>Informatik</strong><br />
36
B es c hreibung des M ic roc odes durc h einfa c he S pra c he<br />
3<br />
P C = P C + 1<br />
die ALUfunktion muss A +1 sein<br />
der Programmcounter wird auf den<br />
A Bus gelegt und in der zweiten<br />
Hälfte des Taktes wird das Ergebnis<br />
der Berechnung wieder in den<br />
Programcounter zurückgeschrieben<br />
D in = [S P ], S P = S P +1<br />
beiden Operationen können in<br />
einem Takt durchgeführt werden, da<br />
die Adressierung in der ersten<br />
Takthälfte erfolgt und das<br />
zurückschreiben in der zweiten<br />
Takthälfte<br />
oe und ie von P C müssen beide 1<br />
sein<br />
<strong>Vorlesung</strong> <strong>Rechnerarchitektur</strong><br />
© Gerhard Raffius, WS 2009/10, h_da - <strong>Fachbereich</strong> <strong>Informatik</strong><br />
37
R eg eln für M U 02<br />
[X ] = D out<br />
wird in den Speicher geschrieben<br />
muss die rechte Seite Dout sein<br />
Memrq = 1 und RnW = 0<br />
der zu schreibende Wert muss<br />
vorher nach Dout gebracht werden<br />
X = [Y ]<br />
wird vom Speicher gelesen muss<br />
keine A dres s e<br />
wird in einem Befehl keine Adresse<br />
benutzt (keine {] ) so ist<br />
Memrq = 0 und RnW = 1<br />
Nur ein Register darf jeweils auf einen<br />
Bus schreiben (A oder B Bus) aber alle<br />
dürfen lesen<br />
die linke Seite (X) IR oder D in sein<br />
Memrq = 1 und RnW = 1<br />
<strong>Vorlesung</strong> <strong>Rechnerarchitektur</strong><br />
© Gerhard Raffius, WS 2009/10, h_da - <strong>Fachbereich</strong> <strong>Informatik</strong><br />
38
Z us ta nds bes c hreibung des La debefehls<br />
opcode =<br />
LDA<br />
LDA 1<br />
DIN = [IR]<br />
step = 2<br />
fetch 0<br />
IR = [PC], PC = PC+1<br />
step = 1<br />
opcode =<br />
LDA<br />
LDA 2<br />
A = Din<br />
step = 0<br />
<strong>Vorlesung</strong> <strong>Rechnerarchitektur</strong><br />
© Gerhard Raffius, WS 2009/10, h_da - <strong>Fachbereich</strong> <strong>Informatik</strong><br />
Jeder Befehl beginnt mit einem Fetch<br />
Zyklus<br />
Nach dem Fetchzyklus entscheidet der<br />
Opcode im Instruction Register und die<br />
Schrittnummer, welchen Zustand<br />
unser Automat als nächstes annimmt<br />
Die Schrittnummer ist unser<br />
Programmcounter im Microcode und<br />
beschreibt die Abfolge der Befehle im<br />
Microcode<br />
Zu jedem Schritt gehört eine<br />
eindeutige Funktion, die sich wiederum<br />
in die Timing-Control Logik umsetzen<br />
läßt<br />
39
D ie A ddition<br />
MU1<br />
Datenpfad<br />
Data Out<br />
Dout<br />
Dout<br />
Adress<br />
0 1<br />
Data In<br />
MU1<br />
Datenpfad<br />
Data Out<br />
Dout<br />
Dout<br />
Adress<br />
0 1<br />
Data In<br />
ACC<br />
A<br />
SP<br />
SP<br />
PC<br />
PC<br />
IR IR<br />
Din Din<br />
ACC<br />
A<br />
SP<br />
SP<br />
PC<br />
PC<br />
IR IR<br />
Din Din<br />
C-Bus<br />
C-Bus<br />
ALU<br />
A ALUB<br />
ALU<br />
A ALUB<br />
A +B ,S<br />
A-Bus<br />
Timing/Control<br />
B-Bus<br />
A-Bus<br />
Timing/Control<br />
B-Bus<br />
Das Instruktion Register wird zur Adressierung benutzt und der Wert nach Din gebracht D in =<br />
[IR ]<br />
Der Inhalt des Akkummulators wird auf den A Bus gelegt und der Inhalt von Din auf den B-Bus.<br />
Die Alufunktion Inputs ist A +B ,S<br />
Outputs Funktion<br />
Instruction<br />
Opcode<br />
ADD S 0010<br />
/Reset<br />
step<br />
Z<br />
N<br />
step<br />
Adress<br />
ACCoe<br />
ACCie<br />
PCoe<br />
PCie<br />
IRoe<br />
1 1 x x 2 1 0 0 0 0 1 0 0 0 0 1 0 0 x 1 1<br />
1 2 x x 0 x 1 1 0 0 0 0 0 0 1 0 0 0 A+B,S 0 1<br />
IRie<br />
SPoe<br />
SPie<br />
DINoe<br />
DINie<br />
DOUToe<br />
DOUTie<br />
ALU Function<br />
MEMrq<br />
RnW<br />
Din = [IR]<br />
ACC = ACC + Din<br />
<strong>Vorlesung</strong> <strong>Rechnerarchitektur</strong><br />
© Gerhard Raffius, WS 2009/10, h_da - <strong>Fachbereich</strong> <strong>Informatik</strong><br />
40
D ie O pera tion P us h, der A kkum ula tor w ird a uf den<br />
S ta c k g es c hoben<br />
MU1<br />
Datenpfad<br />
Data Out<br />
Dout<br />
Dout<br />
Adress<br />
0 1<br />
Data In<br />
MU1<br />
Datenpfad<br />
Data Out<br />
Dout<br />
Dout<br />
Adress<br />
0 1<br />
Data In<br />
ACC<br />
A<br />
SP<br />
SP<br />
PC<br />
PC<br />
IR IR<br />
Din Din<br />
ACC<br />
A<br />
SP<br />
SP<br />
PC<br />
PC<br />
IR IR<br />
Din Din<br />
C-Bus<br />
C-Bus<br />
ALU<br />
A ALUB<br />
A -1<br />
ALU<br />
A ALUB<br />
A-Bus<br />
Timing/Control<br />
B-Bus<br />
A-Bus<br />
Timing/Control<br />
B-Bus<br />
MU1<br />
Datenpfad<br />
Data Out<br />
Dout<br />
Dout<br />
Adress<br />
0 1<br />
Data In<br />
Die Operation push benötigt drei Schritte<br />
S P = S P -1<br />
ACC<br />
A<br />
SP<br />
SP<br />
ALU<br />
A ALUB<br />
PC<br />
PC<br />
C-Bus<br />
IR IR<br />
Din Din<br />
<br />
<br />
D out = A<br />
[S P ] = D out<br />
im letzten Schritt wird der Microprogramm<br />
Counter Step auf null gesetzt, so dass sich<br />
A-Bus<br />
B-Bus<br />
ein fetch Zyklus anschließt<br />
Timing/Control<br />
<strong>Vorlesung</strong> <strong>Rechnerarchitektur</strong><br />
© Gerhard Raffius, WS 2009/10, h_da - <strong>Fachbereich</strong> <strong>Informatik</strong><br />
41
D er M u1 Z us ta nds a utom a t für lda , a dd und pus h<br />
Nach dem Holen des<br />
add<br />
1<br />
lda<br />
1<br />
lda<br />
2<br />
Opcodes im Fetch Zyklus<br />
wird jeweils der durch den<br />
Opcode vorgegebene<br />
Zustand angesprungen<br />
add<br />
2<br />
push<br />
1<br />
fetch<br />
0<br />
push<br />
2<br />
push<br />
3<br />
durch die Step Variable<br />
(Programcounter im<br />
Microcode) wird eine<br />
Schleife durchlaufen, die<br />
wieder bei Schritt 0 im Fetch<br />
Zyklus endet<br />
<strong>Vorlesung</strong> <strong>Rechnerarchitektur</strong><br />
© Gerhard Raffius, WS 2009/10, h_da - <strong>Fachbereich</strong> <strong>Informatik</strong><br />
42
eding te S prüng e<br />
jge<br />
ACC15 = 1<br />
1<br />
fetch<br />
0<br />
jge<br />
ACC15 = 0<br />
1<br />
in Abhängigkeit von Bit 15 des<br />
Akkumlators (A >= 0 oder A < 0) wird<br />
ein unterschiedlicher Zustand<br />
angesprungen<br />
ist A>=0 (ACC15 = 0) dann wird die<br />
Operation PC = IR ausgeführt<br />
ist A < 0 so wird keine Operation<br />
ausgeführt (NOP)<br />
der bedingte Sprung J N E ist<br />
strukturell gleich, nur ist hier die<br />
Zusatzbedingung, dass der<br />
Accumluator null ist (Zero Flag)<br />
<strong>Vorlesung</strong> <strong>Rechnerarchitektur</strong><br />
© Gerhard Raffius, WS 2009/10, h_da - <strong>Fachbereich</strong> <strong>Informatik</strong><br />
43
M u1 K ontroll Log ik für beding te S prüng e<br />
Beide Befehle weisen jeweils 2 Zustände auf, die sich durch die Statusbits des<br />
Akkumulators unterscheiden<br />
Beide Zustände haben die Schrittnummer 1 und als Folgeschritt die Schrittnummer<br />
0<br />
Die Funktion NOP ist dadurch gekennzeichnet, dass kein Registerinhalt verändert<br />
wird<br />
alle Register haben oe und ie auf 0 und der Speicher wird auch nicht<br />
Inputs Outputs Funktion<br />
angesprochen<br />
Instruction<br />
MEMrq = 0<br />
Opcode<br />
/Reset<br />
step<br />
Z<br />
N<br />
step<br />
Adress<br />
ACCoe<br />
ACCie<br />
PCoe<br />
PCie<br />
JGE S 0101 1 1 x 0 0 x 0 0 0 1 1 0 0 0 0 0 0 0 B 0 1<br />
1 1 x 1 0 x 0 0 0 0 0 0 0 0 0 0 0 0 x 0 1<br />
JNE S 0110 1 1 1 x 0 x 0 0 0 0 0 0 0 0 0 0 0 0 x 0 1<br />
1 1 0 x 0 x 0 0 0 1 1 0 0 0 0 0 0 0 B 0 1<br />
IRoe<br />
IRie<br />
SPoe<br />
SPie<br />
DINoe<br />
DINie<br />
DOUToe<br />
DOUTie<br />
ALU Function<br />
MEMrq<br />
RnW<br />
if ACC > 0 then PC = IR<br />
If ACC
der S top B efehl<br />
stop<br />
1<br />
Der Stop Befehl hat als Folgezustand<br />
den Zustand stop<br />
es wird kein fetchzyklus mehr<br />
ausgeführt, so dass die<br />
Zustandsmaschine in dieser Stellung<br />
angehalten wird<br />
fetch<br />
0<br />
<strong>Vorlesung</strong> <strong>Rechnerarchitektur</strong><br />
© Gerhard Raffius, WS 2009/10, h_da - <strong>Fachbereich</strong> <strong>Informatik</strong><br />
45
R es et<br />
Ist das Reset Signal angelegt, geht<br />
unsere Zustandsmaschine immer in<br />
stop<br />
1<br />
fetch<br />
0<br />
push<br />
1<br />
push<br />
2<br />
push<br />
3<br />
reset<br />
den Zustand Reset<br />
Im Reset Zustand wird der Program<br />
Counter auf Null gesetzt<br />
PC = 0<br />
und die Zustandsvariable Step (der<br />
Microprogram Counter) erhält<br />
ebenfalls den Wert 0<br />
Dadurch wird nach Beendigung des<br />
Reset Signals mit dem Zustand fetch<br />
fortgefahren und der Befehl von der<br />
Adresse 0 geholt<br />
<strong>Vorlesung</strong> <strong>Rechnerarchitektur</strong><br />
© Gerhard Raffius, WS 2009/10, h_da - <strong>Fachbereich</strong> <strong>Informatik</strong><br />
46
P roblem e des M u1 D es ig ns<br />
Der Entwurf begrenzt den Speicher auf 4096 Worte (12 Bit). Dies ist viel zu wenig.<br />
Ein moderner Prozessor verwaltet einen Speicherraum von 4 Gigabyte (32 Bit)<br />
oder sehr viel mehr (64 Bit).<br />
ALU, Programmcounter, ACCU und andere Register auf min. 32 Bit vergrößern.<br />
Die Begrenzung auf einen 4 Bit breiten Opcode verhindert, dass die logischen und<br />
die Schiebebefehle implementiert werden können<br />
Opcode Erweiterung und Verzicht auf Absolute Adressierung oder<br />
Verzicht auf gleiche Wortbreite bei Instruktionen<br />
Die Adressierung erfolgt meist durch absolute Adressierung. Das Befehlswort<br />
enthält direkt die Adresse von der die Daten gelesen werden, oder an die sie<br />
geschrieben werden.<br />
Die Einführung von einer kleineren Anzahl von Registern, die direkt angesprochen<br />
werden können erlaubt mehr Freiheiten<br />
<strong>Vorlesung</strong> <strong>Rechnerarchitektur</strong><br />
© Gerhard Raffius, WS 2009/10, h_da - <strong>Fachbereich</strong> <strong>Informatik</strong><br />
47
P roblem e des M u1 D es ig ns<br />
Adressberechnungen müssen in einem Register zwischengespeichert werden.<br />
Beispiel: Zugriff auf Stack + Offset, Zugriff auf Konstanten mit pc relativem Offset,<br />
relative Sprungbefehle der ALU<br />
Änderung des Datenpfads, so dass das Ergebnis der ALU als Adresse genutzt<br />
werden kann<br />
Einführung eines Adressregisters um Zykluszeit zu verkürzen<br />
Es gibt nur ein Datenregister. Da der Zugriff auf den Speicher langsam und<br />
aufwändig ist, ist es sinnvoll statt eines Akkumulators einen Registersatz mit<br />
mehreren Registern einzuführen<br />
Änderung des Befehlssatz notwendig<br />
Entscheidung über 2 oder 3 Adressbefehle (Beispiel ADD R1, R2, R3)<br />
Einführung von A,B und C Bus notwendig um Flexibiltät zu bekommen<br />
Übergang zur Load/Store Architektur bei Befehlssatz von konstanter Wortbreite<br />
<strong>Vorlesung</strong> <strong>Rechnerarchitektur</strong><br />
© Gerhard Raffius, WS 2009/10, h_da - <strong>Fachbereich</strong> <strong>Informatik</strong><br />
48
P roblem e des M U 0 D es ig ns<br />
Der Programmcounter muss jedesmal in einem eigenen Schritt durch die ALU<br />
erhöht werden. Das verlangsamt den Prozessor<br />
ein eigener Incrementer für den Programmcounter<br />
ein zweites Befehlsregister, in dem der nächste Befehl zwischengespeichert<br />
werden kann (Pipeline)<br />
<strong>Vorlesung</strong> <strong>Rechnerarchitektur</strong><br />
© Gerhard Raffius, WS 2009/10, h_da - <strong>Fachbereich</strong> <strong>Informatik</strong><br />
49
kom plexe A dres s berec hnung und m a xim a le La ufzeit<br />
ohne Z w is c hens peic herung der A dres s e beim H olen<br />
eines Werts vom S ta c k m it O ffs et<br />
Speicher<br />
Mu2<br />
Datenpfad<br />
Data Out<br />
Dout<br />
Adress<br />
Stackpointer +<br />
Offset<br />
Data In<br />
Date<br />
n<br />
Stackpointer<br />
AA<br />
SP<br />
PC<br />
IR<br />
Din<br />
ALU<br />
Offse<br />
t<br />
Die Gesamtlaufzeit<br />
für diesen Befehl<br />
ist zu lang<br />
Timing/Control<br />
<strong>Vorlesung</strong> <strong>Rechnerarchitektur</strong><br />
© Gerhard Raffius, WS 2009/10, h_da - <strong>Fachbereich</strong> <strong>Informatik</strong><br />
50
K om plexe A dres s berec hnung en na c h E inführung des<br />
A dres s reg is ters<br />
MU3<br />
Datenpfad<br />
Data Out<br />
Dout<br />
Adress<br />
Aout<br />
Data In<br />
Es wird jetzt ein<br />
Takt mehr benötigt<br />
um Daten aus dem<br />
Speicher zu holen,<br />
aber die<br />
AA<br />
SP<br />
PC<br />
IR<br />
Din<br />
Taktfrequenz kann<br />
höher sein, da die<br />
ALU<br />
Laufzeiten pro<br />
Teilstück kürzer<br />
sind<br />
Timing/Control<br />
<strong>Vorlesung</strong> <strong>Rechnerarchitektur</strong><br />
© Gerhard Raffius, WS 2009/10, h_da - <strong>Fachbereich</strong> <strong>Informatik</strong><br />
51
K om plexe A dres s berec hnung en<br />
In vielen Operationen werden Adressberechnungen benötigt, die im einfachen MU0<br />
Design nicht möglich sind. Dazu gehören<br />
relative Sprünge, d.h. Sprünge bei denen zu dem augenblicklichen<br />
Programmzähler ein Offset hinzugezählt wird<br />
komplexere Adressierungsarten, wie das indirekte Laden und Speichern mit einem<br />
Offset, bei dem die Basisadresse in einem Register steht (z.B. Stackpointer) und<br />
zu dieser Adresse noch ein Offset addiert wird<br />
Laden von PC-relativen Konstanten. Bei Prozessoren mit einer festen<br />
Befehlsbreite können nur kleine Konstanten direkt im Code dekodiert werden.<br />
Konstanten können aber auch geladen werden, wenn sie in der Nähe des<br />
augenblicklichen Programms stehen, z.B. hinter der Returnanweisung eines<br />
Unterprogramms<br />
<strong>Vorlesung</strong> <strong>Rechnerarchitektur</strong><br />
© Gerhard Raffius, WS 2009/10, h_da - <strong>Fachbereich</strong> <strong>Informatik</strong><br />
52
ela tive S prüng e<br />
.L1:<br />
.L2:<br />
movs r2, r2, LSR #1<br />
bcc .L2<br />
adds r0, r0, r3<br />
adc r1, r1, r4<br />
adds r3, r3, r3<br />
adc r4, r4, r4<br />
cmp r2, #0<br />
bne .L1<br />
.L1<br />
Viele Sprünge in Programmen haben<br />
nur eine kurze Sprungweite<br />
Sie lassen sich viel besser als relative<br />
Sprünge darstellen<br />
.L2<br />
<strong>Vorlesung</strong> <strong>Rechnerarchitektur</strong><br />
© Gerhard Raffius, WS 2009/10, h_da - <strong>Fachbereich</strong> <strong>Informatik</strong><br />
53
K om plexe A dres s berec hnung : B eis piel S ta c k<br />
In Unterprogrammen wird dynamischer<br />
ldr [sp + offset]<br />
Speicher reserviert, indem der<br />
Speicher<br />
Stackpointer nach unten gesetzt wird<br />
A<br />
sp<br />
return pc<br />
var x<br />
var y<br />
var b<br />
var c<br />
var d<br />
var e<br />
Offset aus<br />
Instruction<br />
register<br />
Der Zugiff auf den Speicher erfolgt<br />
über den Stack und einen Offset, der<br />
im Befehl enthalten ist<br />
push und pop sind nicht ausreichend,<br />
da bei mehreren Variablen auf dem<br />
Stack jeweils beim Lesen der Stack<br />
geräumt werden müsste<br />
<strong>Vorlesung</strong> <strong>Rechnerarchitektur</strong><br />
© Gerhard Raffius, WS 2009/10, h_da - <strong>Fachbereich</strong> <strong>Informatik</strong><br />
54
K om plexe A dres s berec hnung : B eis piel rela tive<br />
S prüng e<br />
Data Out Adress Data In<br />
Data Out Adress Data In<br />
Dout<br />
Aout<br />
Dout<br />
Aout<br />
A<br />
SP<br />
PC<br />
IR<br />
Din<br />
A<br />
SP<br />
PC<br />
IR<br />
Din<br />
ALU<br />
ALU<br />
Timing/Control<br />
Timing/Control<br />
<strong>Vorlesung</strong> <strong>Rechnerarchitektur</strong><br />
© Gerhard Raffius, WS 2009/10, h_da - <strong>Fachbereich</strong> <strong>Informatik</strong><br />
55
P roblem : der Fetc h Z yklus bra uc ht m a nc hm a l 2 Ta kte<br />
MU0-3<br />
Datenpfad<br />
Data Out Adress Data In<br />
Dout<br />
Aout<br />
MU0-3<br />
Datenpfad<br />
Data Out Adress Data In<br />
Dout<br />
Aout<br />
A<br />
SP<br />
PC<br />
IR<br />
Din<br />
A<br />
SP<br />
PC<br />
IR<br />
Din<br />
ALU =A<br />
ALU<br />
=A+1<br />
Timing/Control<br />
Holen der Adresse, nur<br />
notwendig wenn Aout<br />
überschrieben wurde<br />
Timing/Control<br />
Holen der Instruktion und<br />
inkrementieren des PC<br />
<strong>Vorlesung</strong> <strong>Rechnerarchitektur</strong><br />
© Gerhard Raffius, WS 2009/10, h_da - <strong>Fachbereich</strong> <strong>Informatik</strong><br />
56
R eg is tera rc hitektur<br />
Die Ergebnisse können in einem von n Registern gespeichert werden<br />
Die Gesamtzahl der Register ist normalerweise eine Zweierpotenz. Gebräuchlich<br />
sind Registersätze von 8 (ARM-Thumb), 16 (ARM), 32 (Power PC, MIPS) und<br />
mehr Register.<br />
Manchmal werden Spezialregister, wie PC, SP und LR wie die anderen Register<br />
adressiert. Dies hat den Vorteil, dass ihre Werte in arithmetischen Operationen und<br />
zur Adressierung benutzt werden können.<br />
Beispiel im ARM Befehlssatz ist der Program Counter R15<br />
das Link Register R14<br />
und der Stackpointer R13<br />
<strong>Vorlesung</strong> <strong>Rechnerarchitektur</strong><br />
© Gerhard Raffius, WS 2009/10, h_da - <strong>Fachbereich</strong> <strong>Informatik</strong><br />
57
R eg is tera rc hitektur<br />
Die Adressierung der jeweiligen Quell- und Zielregister muss im Befehl enthalten<br />
sein. Bei 16 Registern ist daher eine 4 Bit Adressinformation für Quell und<br />
Zielregister notwendig<br />
2 Adress Befehle wie add R0, R1 ; R0 += R1<br />
benötigen 2n Bits zur Dekodierung<br />
3 Adress Befehle wie add R0, R1, R2 ; R0 = R1 + R2<br />
benötigen 3n Bits zur Dekodierung<br />
Prozessoren mit 16 Bit Befehlssatz haben vorwiegend 2 Adress Befehle und<br />
wenige Register, Prozessoren mit 32 Bit Befehlssatz haben meist 3 Adress<br />
Befehle und viele Register<br />
<strong>Vorlesung</strong> <strong>Rechnerarchitektur</strong><br />
© Gerhard Raffius, WS 2009/10, h_da - <strong>Fachbereich</strong> <strong>Informatik</strong><br />
58
K ons equenzen a us der R eg is tera rc hitektur<br />
Die Register erlauben eine schnelle Speicherung von Werten<br />
Die arithmetischen Befehle lassen sich in einem Takt ausführen<br />
Register erlauben einen indirekten Zugriff auf Variablen, indem der Inhalt eines<br />
Registers als Adresse genutzt wird. Die Registerbreite sollte daher so groß sein,<br />
dass sich jede Speicheradresse darin speichern läßt<br />
Dies führt im Augenblick zum Übergang von 32 Bit zu 64 Bit Rechnern, da bei 4<br />
Gigabyte die Speichergrenze für 32 Bit Rechnern liegt<br />
Der direkte Zugriff (Adresse im Befehl dekodiert) funktioniert bei einem Befehlssatz<br />
mit gleicher Breite aller Befehle nicht mehr<br />
Das Laden von Konstanten (Immediate Werte) in ein Register ist schwierig, da nur<br />
kleine Immediate Werte im Befehlscode Platz haben<br />
<strong>Vorlesung</strong> <strong>Rechnerarchitektur</strong><br />
© Gerhard Raffius, WS 2009/10, h_da - <strong>Fachbereich</strong> <strong>Informatik</strong><br />
59
U nterprog ra m m a ufrufe und da s Link R eg is ter<br />
Die Einführung eines Link Registers erlaubt es, Unterprogrammaufrufe<br />
durchzuführen, ohne dass die Rücksprungadresse auf den Stack geschrieben<br />
werden muss. Bei Ausführung eines Unterprogramms wird die Rücksprungadresse<br />
im Linkregister gespeichert und nach dem Programm wieder vom Linkregister in<br />
den Programcounter geschoben<br />
<strong>Vorlesung</strong> <strong>Rechnerarchitektur</strong><br />
© Gerhard Raffius, WS 2009/10, h_da - <strong>Fachbereich</strong> <strong>Informatik</strong><br />
60
E ine V erbes s erte A LU<br />
Einsatz von Modifikatoren<br />
Der Modifikator kann den Eingang<br />
durchschalten oder alle Bits auf 0<br />
ALU<br />
Funktion<br />
AA<br />
ALU<br />
BB<br />
oder 1 setzen<br />
Einsatz eines Shifters<br />
Modifizierer<br />
Modifizierer<br />
Shift<br />
Modification<br />
Shift Weite<br />
Der Shifter kann den Wert um die<br />
Shiftweite nach links oder nach<br />
rechts schieben, oder eine Rotation<br />
durchführen<br />
Weitere Alufunktionen<br />
neben A+B und A-B und A+B+1<br />
kann die ALU noch Bitoperationen<br />
durchführen<br />
<strong>Vorlesung</strong> <strong>Rechnerarchitektur</strong><br />
© Gerhard Raffius, WS 2009/10, h_da - <strong>Fachbereich</strong> <strong>Informatik</strong><br />
A ∧ B, A ∨ B, ¬ A, ¬ Β, Α xor Β<br />
61
R eg is ters a tz: Ü berg a ng von A kkum ula tor zur R eg is ter<br />
A rc hitektur<br />
Dieser Prozessor funktioniert so noch<br />
nicht<br />
Data Out Adress Data In<br />
Die einfache Operation add r d<br />
, r n<br />
, r m<br />
Mu4 Datenpfad<br />
Dout<br />
Aout<br />
kann nicht erzeugt werden, da die<br />
Registerbank nur Zugriff auf den A Bus<br />
AAA<br />
R0-Rn<br />
A SP<br />
LR<br />
PC<br />
IR<br />
Din<br />
hat<br />
Die Registerbank braucht zwei<br />
ALU<br />
Ausgänge, sowohl auf A als auch auf<br />
den B Bus<br />
Timing/Control<br />
<strong>Vorlesung</strong> <strong>Rechnerarchitektur</strong><br />
© Gerhard Raffius, WS 2009/10, h_da - <strong>Fachbereich</strong> <strong>Informatik</strong><br />
62
V erbes s erung des internen B us s ys tem s und S hifter<br />
In den bisherigen Modellen konnten die Registerinhalte auf den A Bus gelegt<br />
werden und Daten und Immediate Konstanten auf den B Bus<br />
Dies ist jedoch in einer Registerarchitektur nicht optimal, da die arithmetischen<br />
Operationen zwei Registeroperanden haben sollten<br />
Eine Verbesserung stellt es dar, wenn die Registerinhalte sowohl auf den A als<br />
auch auf den B Bus gelegt werden können<br />
Die Einführung des Shifters erlaubt es den Operanden des B Bus vor der<br />
Verarbeitung noch einmal zu schieben. Dies ist besonders für<br />
Adressberechnungen wichtig, da häufig ein Wortoffset in eine Adresse auf Byte<br />
Basis umgewandelt werden muss<br />
<strong>Vorlesung</strong> <strong>Rechnerarchitektur</strong><br />
© Gerhard Raffius, WS 2009/10, h_da - <strong>Fachbereich</strong> <strong>Informatik</strong><br />
63
V erbes s erung des internen B us s ys tem s und S hifter<br />
Mit dieser Anordnung lassen sich die<br />
Mu5 Datenpfad<br />
BB A CC<br />
PC<br />
LR<br />
SP<br />
Adress<br />
Aout<br />
ALU<br />
IR<br />
Data In<br />
Din<br />
meisten Befehle realisieren<br />
Jedes Register besitzt jetzt einen<br />
Ausgang für den A und den B Bus<br />
Operanden die über den B Bus zur Alu<br />
gelangen können vor der Operation<br />
R0-Rn<br />
AAAAA<br />
Shifter<br />
noch geschoben werden<br />
Auf dem B Bus können kleine<br />
Dout<br />
Data Out<br />
Timing/Control<br />
Immediate Werte aus dem Instruction<br />
Register in Berechnungen benutzt<br />
werden<br />
Es werden aber noch zu viele Takte<br />
pro Operation benötigt<br />
<strong>Vorlesung</strong> <strong>Rechnerarchitektur</strong><br />
© Gerhard Raffius, WS 2009/10, h_da - <strong>Fachbereich</strong> <strong>Informatik</strong><br />
64
Fetc h Z yklus im M u5<br />
In Aout steht im Normalfall eine<br />
Speicher<br />
Kopie von PC<br />
Mu5 Datenpfad<br />
B A C<br />
PC<br />
LR<br />
SP<br />
Aout<br />
ALU<br />
Adress<br />
A+1<br />
IR<br />
Data In<br />
Din<br />
Nur nach einem Datentransfer<br />
muss der Inhalt von PC wieder in<br />
das Register<br />
Aout kopiert werden<br />
AA<br />
R0-Rn<br />
AA A Shifter<br />
Dout<br />
Timing/Control<br />
Data Out<br />
<strong>Vorlesung</strong> <strong>Rechnerarchitektur</strong><br />
© Gerhard Raffius, WS 2009/10, h_da - <strong>Fachbereich</strong> <strong>Informatik</strong><br />
65
A rithm etis c he O pera tionen<br />
Mu5 Datenpfad<br />
B A C<br />
PC<br />
Adress<br />
Aout<br />
Data In<br />
arithmetische Operationen lassen sich<br />
in einem Taktzyklus + Fetch<br />
durchführen<br />
LR<br />
IR<br />
Din<br />
SP<br />
ALU<br />
AAAA<br />
R0-Rn A Shifter<br />
Dout<br />
Timing/Control<br />
Data Out<br />
<strong>Vorlesung</strong> <strong>Rechnerarchitektur</strong><br />
© Gerhard Raffius, WS 2009/10, h_da - <strong>Fachbereich</strong> <strong>Informatik</strong><br />
66
D a tentra ns fer<br />
Adress<br />
Data In<br />
Adress<br />
Data In<br />
Mu5 Datenpfad:<br />
Adressberechnung<br />
B A C<br />
PC<br />
Aout<br />
Mu5 Datenpfad<br />
B A C<br />
PC<br />
Aout<br />
LR<br />
IR<br />
Din<br />
LR<br />
IR<br />
Din<br />
SP<br />
ALU<br />
SP<br />
ALU<br />
A R0-Rn<br />
AA A Shifter<br />
A R0-Rn<br />
AA A Shifter<br />
Dout<br />
Timing/Control<br />
Dout<br />
Timing/Control<br />
Adress<br />
Data Out<br />
Data In<br />
Data Out<br />
Mu5 Datenpfad:<br />
Schreiben und Reload von Aout<br />
B A C<br />
Aout<br />
PC<br />
LR<br />
IR<br />
Din<br />
SP<br />
ALU<br />
R0-Rn<br />
AAAA A<br />
Shifter<br />
Dout<br />
Timing/Control<br />
Data Out<br />
<strong>Vorlesung</strong> <strong>Rechnerarchitektur</strong><br />
© Gerhard Raffius, WS 2009/10, h_da - <strong>Fachbereich</strong> <strong>Informatik</strong><br />
67
D ie S teuerm a trix des M u5<br />
Notwendige Outputs<br />
<br />
Bedeutung<br />
A-Bus Adresse<br />
B Bus Adresse<br />
C Bus Adresse<br />
IR ie, oe<br />
Aout ie,oe<br />
Dout ie,oe<br />
Din ie,oe<br />
Alu Funktion<br />
Shift Funktion<br />
Shift Wert<br />
Breite<br />
4 Bit<br />
4 Bit<br />
4 Bit<br />
2 Bit<br />
2 Bit<br />
2 Bit<br />
2 Bit<br />
5 Bit<br />
2 Bit<br />
5 Bit<br />
<strong>Vorlesung</strong> <strong>Rechnerarchitektur</strong><br />
© Gerhard Raffius, WS 2009/10, h_da - <strong>Fachbereich</strong> <strong>Informatik</strong><br />
68
V erbes s erte A dres s berec hnung<br />
Mu6 Datenpfad<br />
Adress<br />
Data In<br />
Aout<br />
PC<br />
ADD<br />
BB<br />
AA<br />
LR<br />
CC<br />
DD<br />
+2/4<br />
IR<br />
Din<br />
SP<br />
ALU<br />
AAA R0-Rn<br />
A<br />
Shifter<br />
Dout<br />
Timing/Control<br />
Data Out<br />
<strong>Vorlesung</strong> <strong>Rechnerarchitektur</strong><br />
© Gerhard Raffius, WS 2009/10, h_da - <strong>Fachbereich</strong> <strong>Informatik</strong><br />
69
V erbes s erte A dres s berec hnung<br />
In unserem MU0 Modell verlieren wir jeweils einen Takt pro Befehl um im Fetch<br />
Zyklus die nächste Adresse für den Programmcounter zu berechnen.<br />
In dem verbesserten Ansatz kann die nächste Adresse direkt ohne über die ALU zu<br />
gehen in das Adressregister geladen werden<br />
Ein Addierer holt sich den Wert aus dem Adressregister, addiert einen Offset hinzu<br />
und schreibt bei Bedarf den Wert wieder in den Programmcounter zurück<br />
Jetzt kann der nächste Befehl, oder das nächste Datenwort geholt werden, ohne<br />
dass die ALU oder der C Bus belegt werden<br />
Begrenzt wird dieses Design durch den Umstand, dass der Wert im Instruction<br />
Register bis zum Ende des Befehls erhalten bleiben muss, weil darüber die<br />
Steuerung erfolgt<br />
<strong>Vorlesung</strong> <strong>Rechnerarchitektur</strong><br />
© Gerhard Raffius, WS 2009/10, h_da - <strong>Fachbereich</strong> <strong>Informatik</strong><br />
70
B eis piel: s pekula tive B efehls a us führung<br />
while<br />
if<br />
call<br />
switch, goto<br />
bedingter Sprung<br />
wird ausgeführt<br />
bedingter Sprung<br />
wird nicht ausgeführt<br />
unbedingte Sprünge<br />
werden ausgeführt<br />
unbedingter Sprung<br />
wird ausgeführt<br />
<strong>Vorlesung</strong> <strong>Rechnerarchitektur</strong><br />
© Gerhard Raffius, WS 2009/10, h_da - <strong>Fachbereich</strong> <strong>Informatik</strong><br />
71
E inführung einer P ipeline<br />
Mu7 Datenpfad<br />
Adress<br />
Data In<br />
Aout<br />
PC<br />
ADD<br />
IR0<br />
BB<br />
AA<br />
LR<br />
CC<br />
DD<br />
+2/4<br />
IR1<br />
Din<br />
SP<br />
ALU<br />
IR2<br />
AAA<br />
R0-Rn<br />
A Shifter<br />
Dout<br />
Timing/Control<br />
Data Out<br />
<strong>Vorlesung</strong> <strong>Rechnerarchitektur</strong><br />
© Gerhard Raffius, WS 2009/10, h_da - <strong>Fachbereich</strong> <strong>Informatik</strong><br />
72
P ipeline<br />
Die Pipeline erlaubt es den nächsten Befehl zu holen, während der letzte Befehl<br />
noch bearbeitet wird.<br />
Die Steuerung verwendet die Werte in allen Instructionregistern. Sprünge werden<br />
schon im ersten Register erkannt und ausgewertet. Dazu besitzen viele<br />
Prozessoren eine eigene zusätzliche ALU zur Sprungberechnung.<br />
unbedingte Sprünge werden berechnet und die nächste Instruktion an der richtigen<br />
Stelle geholt<br />
bedingte Sprünge werden bei Sprüngen zurück (Schleifen) genommen, bei<br />
Sprüngen nach vorne (if..else) nicht genommen. Dies nennt man spekulative<br />
Befehlsausführung<br />
Falls die Spekulation falsch war, muss die Pipeline geleert und frisch gefüllt werden<br />
Moderne Prozessoren besitzen Pipelines mit 5 bis 17 Stufen<br />
Als Flaschenhals stellt sich jetzt der gemeinsame Bus für Daten und Befehle<br />
heraus<br />
<strong>Vorlesung</strong> <strong>Rechnerarchitektur</strong><br />
© Gerhard Raffius, WS 2009/10, h_da - <strong>Fachbereich</strong> <strong>Informatik</strong><br />
73
E inführung der H a rva rd A rc hitektur<br />
Mu8 Datenpfad<br />
Instruction<br />
Data<br />
Address<br />
Address<br />
Instruction In<br />
Data In<br />
IAout<br />
DAout<br />
PC<br />
ADD<br />
IR0<br />
LR<br />
BB AA CC DD<br />
+2/4<br />
ADD<br />
IR1<br />
Din<br />
SP<br />
ALU<br />
+2/4<br />
IR2<br />
AA<br />
R0-Rn<br />
AAA A Shifter<br />
Dout<br />
Timing/Control<br />
Data Out<br />
<strong>Vorlesung</strong> <strong>Rechnerarchitektur</strong><br />
© Gerhard Raffius, WS 2009/10, h_da - <strong>Fachbereich</strong> <strong>Informatik</strong><br />
74
D ie H a rva rd A rc hitektur<br />
Durch die Trennung von Daten und Befehlsbus kann der Durchsatz deutlich erhöht<br />
werden.<br />
In einem Befehl können jetzt sowohl Daten geholt oder geschrieben und ein Befehl<br />
geholt werden<br />
Auch hier erhält das Adressregister wieder einen Addierer um Blocktransfers von<br />
Daten zu ermöglichen<br />
Das Zurückschreiben der letzten Adresse in ein Register erfordert einen Zugriff auf<br />
den C Bus<br />
<strong>Vorlesung</strong> <strong>Rechnerarchitektur</strong><br />
© Gerhard Raffius, WS 2009/10, h_da - <strong>Fachbereich</strong> <strong>Informatik</strong><br />
75
B eis piele für einen 16/32 B it Ins truktions s a tz (A R M<br />
Thum b2)<br />
15 14 13 12 11 10 9 8 7 6 5 4 3 2 1 0<br />
opcode<br />
opcode<br />
00xxxx<br />
Instruction or instruction class<br />
Shift (immediate), add, subtract, move, and compare<br />
010000 Data processing<br />
010001 Special data instructi<br />
01001x<br />
0101xx<br />
011xxx<br />
100xxx<br />
10100x<br />
10101x<br />
1011xx<br />
11000x<br />
11001x<br />
1101xx<br />
11100x<br />
Load from Literal Pool, see LDR (literal)<br />
Load/store single data item<br />
Generate PC-relative address, see ADR<br />
Generate SP-relative address, see ADD (SP plus immediate)<br />
Miscellaneous 16-bit instructi<br />
Store multiple registers, see STM / STMIA / STMEA<br />
Load multiple registers, see LDM / LDMIA / LDMFD<br />
Conditional branch, and supervisor call<br />
Unconditional Branch, see B<br />
<strong>Vorlesung</strong> <strong>Rechnerarchitektur</strong><br />
© Gerhard Raffius, WS 2009/10, h_da - <strong>Fachbereich</strong> <strong>Informatik</strong><br />
76
32 B it Ins truktionen<br />
15 14 13 12 11 10 9 8 7 6 5 4 3 2 1 0 15 14 13 12 11 10 9 8 7 6 5 4 3 2 1 0<br />
1 1 1 op1 op2 op<br />
<strong>Vorlesung</strong> <strong>Rechnerarchitektur</strong><br />
© Gerhard Raffius, WS 2009/10, h_da - <strong>Fachbereich</strong> <strong>Informatik</strong><br />
77
32 B it Ins truktionen<br />
op1 op2 op Instruction class<br />
01 00xx 0xx x Load/store multiple<br />
01 00xx 1xx x Load/store dual or exclusive, table branch<br />
01 01xx xxx x Data processing (shifted register)<br />
01 1xxx xxx x Coprocessor instructi<br />
10 x0xx xxx 0 Data processing (modified immediate)<br />
10 x1xx xxx 0 Data processing (plain binary immediate)<br />
10 xxxx xxx 1 Branches and miscellaneous c<br />
11 000x xx0 x Store single data item<br />
11 00xx 001 x Load byte, memory hints<br />
11 00xx 011 x Load halfword, unallocated memory hints<br />
11 00xx 101 x Load word<br />
11 00xx 111 x UNDEFINED<br />
11 010x xxx x Data processing (register)<br />
11 0110 xxx x Multiply, and multiply accumulate<br />
11 0111 xxx x Long multiply, long multiply accumulate, and divide<br />
11 1xxx xxx x Coprocessor instructions<br />
<strong>Vorlesung</strong> <strong>Rechnerarchitektur</strong><br />
© Gerhard Raffius, WS 2009/10, h_da - <strong>Fachbereich</strong> <strong>Informatik</strong><br />
78
A rithm etis c he und log is c he B efehle<br />
15 14 13 9 8 7 6 5 4 3 2 1 0<br />
0 0 opcode<br />
opcode Instruction See<br />
000xx Logical Shift Left LSL (immediate)<br />
001xx Logical Shift Right LSR (immediate)<br />
010xx Ar ithmetic Shift Right ASR (immediate)<br />
01100 Add register ADD (register)<br />
01101 Subtract register SUB (register)<br />
01110 Add 3-bit immediate ADD (immediate)<br />
01111 Subtract 3-bit immediate SUB (immediate)<br />
100xx Move MOV (immediate)<br />
101xx Compare CMP (immediate)<br />
110xx Add 8-bit immediate ADD (immediate)<br />
111xx Subtract 8-bit immediate SUB (immediate)<br />
<strong>Vorlesung</strong> <strong>Rechnerarchitektur</strong><br />
© Gerhard Raffius, WS 2009/10, h_da - <strong>Fachbereich</strong> <strong>Informatik</strong><br />
79
D ie D a ten-V era rbeitung s B efehle<br />
15 10 9 6 5 4 3 2 1 0<br />
0 1 0 0 0 0 opcode<br />
opcode Instruction<br />
See<br />
0000 Bitwise AND AND (register)<br />
0001 Exclusive OR EOR (register)<br />
0010 Logical Shift Left LSL (register)<br />
0011 Logical Shift Right LSR (register)<br />
0100 Ar ithmetic Shift Right ASR (register)<br />
0101 Add with Carry ADC (register)<br />
0110 Subtract with Carry SBC (register)<br />
0111 Rotate Right ROR (register)<br />
1000 Set flags on bitwise AND TST (register)<br />
1001 Reverse Subtract from 0 RSB (immediate)<br />
1010 Compare Registers CMP (register)<br />
1011 Compare Negative CMN (register)<br />
1100 Logical OR ORR (register)<br />
1101 Multiply Two Registers MUL<br />
1110 Bit Clear BIC (register)<br />
1111 Bitwise NOT MVN (register)<br />
<strong>Vorlesung</strong> <strong>Rechnerarchitektur</strong><br />
© Gerhard Raffius, WS 2009/10, h_da - <strong>Fachbereich</strong> <strong>Informatik</strong><br />
80
D er A dditions befehl<br />
15 9 8 7 6 5 4 3 2 1 0<br />
0 0 0 1 0 0 0 Rm Rn Rd<br />
15 10 9 8 7 6 5 4 3 2 1 0<br />
0 1 0 0 0 1 0 0 D RM Rdn<br />
15 14 13 12 11 10 9 8 7 6 5 4 3 2 1 0 15 14 13 12 11 10 9 8 7 6 5 4 3 2 1 0<br />
1 1 1 0 1 0 1 1 0 0 0 S 0 imm3 imm2<br />
Rn Rd type Rm<br />
<strong>Vorlesung</strong> <strong>Rechnerarchitektur</strong><br />
© Gerhard Raffius, WS 2009/10, h_da - <strong>Fachbereich</strong> <strong>Informatik</strong><br />
81
V erg leic h H a rva rd<br />
A rc hitektur<br />
von N eum a nn<br />
Programm<br />
Speicher<br />
Daten<br />
Adressen<br />
Rechenwerk+<br />
Steuerwerk<br />
Je ein Befehls- und<br />
Datenbus<br />
Schneller gleichzeitiger<br />
Zugriff auf Programm<br />
und Daten<br />
Nur ein Bus für Befehle und<br />
Daten<br />
Kein Program Fetch bei<br />
Datenzugriffen<br />
Rechenwerk+<br />
Steuerwerk<br />
I/O<br />
Adressen<br />
I/O<br />
Daten<br />
Daten<br />
Speicher<br />
Daten +<br />
Programm<br />
Speicher<br />
<strong>Vorlesung</strong> <strong>Rechnerarchitektur</strong><br />
© Gerhard Raffius, WS 2009/10, h_da - <strong>Fachbereich</strong> <strong>Informatik</strong><br />
82
S ta c k-A rc hitektur<br />
Stacks werden unabhängig von der<br />
jeweiligen Architektur bei<br />
Unterprogrammaufrufen und<br />
Parameterübergaben verwendet. Ein<br />
Call- Befehl „pusht“ implizit die<br />
Rücksprungadresse und ggf.<br />
Registerstati, ein Return „popt“ diese<br />
Werte wieder.<br />
push Op_A<br />
push Op_B<br />
add<br />
pop Op_C<br />
<strong>Vorlesung</strong> <strong>Rechnerarchitektur</strong><br />
© Gerhard Raffius, WS 2009/10, h_da - <strong>Fachbereich</strong> <strong>Informatik</strong><br />
83
A kkum ula tor-A rc hitektur<br />
Ausgezeichnetes Register: Akku<br />
LOAD und STORE wirken nur auf Akku. Er<br />
ist als expliziter Operand an jeder Operation<br />
beteiligt. Jede Operation braucht nur eine<br />
Adresse<br />
Sehr kompaktes Befehlsformat<br />
LDA Op_A ; Op_A von Speicher -> Akku<br />
ADD Op_B ; Akku = Akku + Op_B<br />
STA Op_C ; Op_C (= Op_A + Op_B) Akku -> Sp<br />
<strong>Vorlesung</strong> <strong>Rechnerarchitektur</strong><br />
© Gerhard Raffius, WS 2009/10, h_da - <strong>Fachbereich</strong> <strong>Informatik</strong><br />
84
R eg is ter-R eg is ter-A rc hitektur<br />
RISC (Load-Store-Architektur)<br />
alle Operationen greifen nur auf Register<br />
zu,<br />
nur LOAD und STORE greifen auf Speicher<br />
zu<br />
32 – 512 Register verfügbar<br />
einfaches Befehlsformat fester Länge<br />
alle Instruktionen brauchen in etwa gleich<br />
lange<br />
LOAD R1, Op_A ; lade Op_A aus Speicher in R1<br />
LOAD R2, Op_B ; lade Op_B aus Speicher in R2<br />
ADD R3, R1, R2 ; addiere R1 und R2, Ergbn. -> R3<br />
STORE Op_C, R3 ;<br />
speichere R3 -> Op_C (=Op_A + Op_B)<br />
<strong>Vorlesung</strong> <strong>Rechnerarchitektur</strong><br />
© Gerhard Raffius, WS 2009/10, h_da - <strong>Fachbereich</strong> <strong>Informatik</strong><br />
85
R eg is ter-S peic her-A rc hitektur<br />
CISC (Mischung von Akkumulator- und Load-Store-<br />
Architektur)<br />
Operationen greifen auf Register und/oder<br />
Speicher zu<br />
Befehlsformat variabler Länge<br />
mächtige Befehle<br />
stark unterschiedliche Zeiten für<br />
Instruktionsausführung<br />
MOV AX, Op_A ; Op_A von Speicher -> Register AX<br />
ADD AX, Op_B ; AX = AX + Op_B<br />
MOV Op_C, AX ; Op_C = AX (= Op_A + Op_B)<br />
<strong>Vorlesung</strong> <strong>Rechnerarchitektur</strong><br />
© Gerhard Raffius, WS 2009/10, h_da - <strong>Fachbereich</strong> <strong>Informatik</strong><br />
86