Sie sind auf Seite 1von 363

Computersysteme

Michael Zwick

Technische Universität München


Inhalt

1 Motivation: Wie funktioniert ein Computer? ................................ 10


1.1 Komponenten eines Computers ................................................................................................ 10
1.1.1 Peripherie-Geräte und Netzteil ....................................................................................... 12
• Netzteil .................................................................................................................................... 12
• Grafikkarte .............................................................................................................................. 15
• DVD-ROM .............................................................................................................................. 24
• DVD-Brenner .......................................................................................................................... 33
• Festplatte ................................................................................................................................. 34
1.1.2 Komponenten auf der Hauptplatine - Überblick .............................................................. 42
• Prozessor ................................................................................................................................. 44
• Arbeitsspeicher ........................................................................................................................ 49
• Busse ....................................................................................................................................... 56
• GMCH = Graphics and Memory Controller Hub (B) ............................................................. 65
• ICH = Input/Output Controller Hub (C) ................................................................................. 65
• SIO-Controller = Super Input/Output Controller (D) ............................................................. 65
1.2 Von Neumann-Architektur .......................................................................................................... 66
1.3 Harvard-Architektur .................................................................................................................... 70
1.4 Vom Algorithmus zum Prozessor – Abstraktionsebenen ....................................................... 71
Inhalt

1 Aufgaben ‘‘Wie funktioniert ein Computer’’ 81


Netzteil . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 81
Grafikkarten . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 82
Optische Laufwerke . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 82
Festplatte . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 83
Prozessor . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 85
Bussystem . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 86
Rechner-Architekturen . . . . . . . . . . . . . . . . . . . . . . . . . . . 87

2 Darstellung von Zahlen und Zeichen 89

2.1 Bits, Byte, Datenworte und Logikpegel . . . . . . . . . . . . . . . . . . 90

2.2 Zeichen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 92

2.3 Zahlen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 95

2.4 Codierung von Festkommazahlen . . . . . . . . . . . . . . . . . . . . . 98


Vorzeichenlose Festkommazahlen . . . . . . . . . . . . . . . . . . . . . 98
Vorzeichenbehaftete Festkommazahlen . . . . . . . . . . . . . . . . . . 106
Vorzeichen und Betrag . . . . . . . . . . . . . . . . . . . . . . . . . 106
Einer-Komplement . . . . . . . . . . . . . . . . . . . . . . . . . . . . 110
Zweier-Komplement . . . . . . . . . . . . . . . . . . . . . . . . . . . 114

2.5 Codierung von Gleitkommazahlen nach IEEE 754 . . . . . . . . . . . . 118


Format von Gleitkommazahlen . . . . . . . . . . . . . . . . . . . . . 119
Rechnen mit Gleitkommazahlen . . . . . . . . . . . . . . . . . . . . 121

3 Arithmetische Schaltungen 127

3.1 Schaltungselemente . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 127


Logikgatter . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 127
Multiplexer . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 127
Demultiplexer . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 130
Decoder . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 131
Speicherelemente: Flipflops und Register . . . . . . . . . . . . . . . . . 132

3.2 Halbaddierer (HA) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 137


4

3.3 Volladdierer (VA) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 138

3.4 Ripple-Carry-Addierer/Subtrahierer . . . . . . . . . . . . . . . . . . . . 139

3.5 Carry-Look-Ahead . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 141


Einstufige Carry-Look-Ahead-Schaltung . . . . . . . . . . . . . . . . . 143
Kaskadierung von Carry-Look-Ahead-Schaltungen . . . . . . . . . . . 145

3.6 Addition und Subtraktion von Gleitkommazahlen . . . . . . . . . . . . 153

3.7 Kombinatorischer Multiplizierer . . . . . . . . . . . . . . . . . . . . . . 153

3.8 Sequentieller Multiplizierer . . . . . . . . . . . . . . . . . . . . . . . . . 157


Multiplexer-basierte Implementierung der Steuerung . . . . . . . . . . 161
ROM-basierte Implementierung der Steuerung . . . . . . . . . . . . . . 166
Multiplikation vorzeichenbehafteter Zahlen . . . . . . . . . . . . . . . . 170
Multiplikation von Gleitkomma-Zahlen . . . . . . . . . . . . . . . . . . . 170

3.9 Subtraktion . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 171


Allgemein . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 171
Halb-Subtrahierer . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 173
Voll-Subtrahierer . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 174
Ripple-Borrow-Subtrahierer . . . . . . . . . . . . . . . . . . . . . . . . . 175

3.10 Division . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 178


Allgemein . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 178
Kombinatorischer Dividierer . . . . . . . . . . . . . . . . . . . . . . . . . 180
Sequentieller Dividierer . . . . . . . . . . . . . . . . . . . . . . . . . . . 181
Implementierung des Zustandsautomaten mit Multiplexern . . . . . . . 185
Implementierung des Zustandsautomaten mit Speicherbausteinen . . . 188

4 Prozessor-Datenpfad 191

4.1 Vom zu lösenden Problem abhängige Schaltung . . . . . . . . . . . . 191

4.2 Universalrechner: Schaltung unabhängig vom Problem . . . . . . . . 192


Allgemein . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 192
Beispiel-Schaltung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 192
Aufgaben . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 196
Verständnisfragen . . . . . . . . . . . . . . . . . . . . . . . . . . . . 196
Programmieraufgaben . . . . . . . . . . . . . . . . . . . . . . . . . . . . 200
Quadratische Gleichung . . . . . . . . . . . . . . . . . . . . . . . . . 200
Kugelvolumen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 202
5

4.3 Assembler . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 204


Assembler als leicht verständliche hardwarenahe Sprache . . . . . . . 204
Definition einer Assembler-Sprache für den Universalrechner . . . . . . 205
Assembler als Übersetzer . . . . . . . . . . . . . . . . . . . . . . . . . . 210

5 Befehlssätze und deren Klassifikation 215


Befehlssatz . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 215
Klassifikation nach Komplexität . . . . . . . . . . . . . . . . . . . . . . 215
CISC = Complex Instruction Set Architecture . . . . . . . . . . . . . 215
RISC = Reduced Instruction Set Architecture . . . . . . . . . . . . . 215
Klassifikation nach Verortung der Operanden . . . . . . . . . . . . . . . 216
Register-Speicher-Architektur . . . . . . . . . . . . . . . . . . . . . 216
Register-Register-Architektur/Load-Store-Architektur . . . . . . . . 216
Klassifikation nach der Anzahl der Operanden . . . . . . . . . . . . . . 216
Drei-Adress-Maschine . . . . . . . . . . . . . . . . . . . . . . . . . . 216
Zwei-Adress-Maschine . . . . . . . . . . . . . . . . . . . . . . . . . 216
Ein-Adress-Maschine/Akkumulator-Maschine . . . . . . . . . . . . 216
Null-Adress-Maschine/Stack-Maschine . . . . . . . . . . . . . . . . 216

6 MMIX-Prozessor 218

6.1 Programmiermodell . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 219

6.2 Register . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 220


Allzweckregister . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 220
Spezialregister . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 221
Verständnisfragen/Aufgaben . . . . . . . . . . . . . . . . . . . . . . . . 222
Allgemein . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 222
Allzweckregister . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 222
Spezialregister . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 223

6.3 Speicher . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 225


Wortbreiten . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 225
Ausrichtung der Daten im Speicher - Alignment . . . . . . . . . . . . . 225
Big- und Little Endian . . . . . . . . . . . . . . . . . . . . . . . . . . . . 227
Speicherorganisation . . . . . . . . . . . . . . . . . . . . . . . . . . . . 228
Text-Segment: Programme und Interrupt-Vektoren . . . . . . . . . 228
Daten-Segment . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 231
Pool-Segment . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 231
Stack-Segment . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 232
6

Betriebssystem-Segment . . . . . . . . . . . . . . . . . . . . . . . . 232
Virtueller Speicher . . . . . . . . . . . . . . . . . . . . . . . . . . . . 233
Aufgaben . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 234
Verständnis Speicher . . . . . . . . . . . . . . . . . . . . . . . . . . 234
Alignment . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 235
Big- und Little-Endian . . . . . . . . . . . . . . . . . . . . . . . . . . 236
Speicherorganisation . . . . . . . . . . . . . . . . . . . . . . . . . . 238
Virtueller Speicher . . . . . . . . . . . . . . . . . . . . . . . . . . . . 241

6.4 MMIX-Programme . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 242


Aufbau . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 242
Assembler- und Loader-Befehle . . . . . . . . . . . . . . . . . . . . . . 243
Der IS-Befehl . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 243
Der GREG-Befehl . . . . . . . . . . . . . . . . . . . . . . . . . . . . 243
Der LOC-Befehl . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 244
Die Befehle BYTE, WYDE, TETRA und OCTA . . . . . . . . . . . . . 245
Aufgaben . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 246
Übersetzungsprozess . . . . . . . . . . . . . . . . . . . . . . . . . . . . 253
Befehlswort . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 254
Aufgaben . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 258

6.5 MMIX Befehle . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 260


Definitionen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 260
Register-Register-Befehle . . . . . . . . . . . . . . . . . . . . . . . . . . 263
Hardware . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 263
Arithmetische Befehle auf Festkommazahlen . . . . . . . . . . . . . 266
Direktoperand in Register schreiben . . . . . . . . . . . . . . . . . . 268
Umwandlung Gleitkommazahl $ Festkommazahl . . . . . . . . . . 271
Arithmetische Befehle auf Gleitkommazahlen . . . . . . . . . . . . . 272
Schiebe-Befehle . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 274
Logische Operationen auf Bit-Ebene . . . . . . . . . . . . . . . . . . 276
Register-Speicher-Befehle . . . . . . . . . . . . . . . . . . . . . . . . . 279
Daten vom Speicher in ein Register laden . . . . . . . . . . . . . . . 280
Daten vom Register in den Speicher schreiben (speichern) . . . . . 289
Adressen in ein Register laden . . . . . . . . . . . . . . . . . . . . . . . 294
Zugriff auf Spezialregister . . . . . . . . . . . . . . . . . . . . . . . . . . 296
Verzweigungsbefehle . . . . . . . . . . . . . . . . . . . . . . . . . . . . 298
Unbedingte Verzweigung . . . . . . . . . . . . . . . . . . . . . . . . 298
Bedingte Verzweigungen . . . . . . . . . . . . . . . . . . . . . . . . 298
7

Befehle für Funktionsaufrufe . . . . . . . . . . . . . . . . . . . . . . . . 302


Namensräume - der PREFIX-Befehl . . . . . . . . . . . . . . . . . . . . 303
Funktionsaufrufe . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 305
Wert-Übergabe und Referenz-Übergabe . . . . . . . . . . . . . . . 306
Aufrufkonventionen . . . . . . . . . . . . . . . . . . . . . . . . . . . 307
Parameterübergabe auf dem Stack beim MMIX . . . . . . . . . . . 307
Aufgaben . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 318
Beispielprogramm: Quadratische Gleichung . . . . . . . . . . . . . 327

7 Pipelining 333

7.1 Pipelining-Datenpfad . . . . . . . . . . . . . . . . . . . . . . . . . . . . 334

7.2 Pipelining-Konflikte . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 337


Datenkonflikte . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 337
Erkennen von Datenkonflikten . . . . . . . . . . . . . . . . . . . . . 337
Auflösen von Datenkonflikten durch Einfügen von NOP-Befehlen . . 339
Auflösen von Datenkonflikten mittels Befehlsumstellung . . . . . . . 340
Auflösen von Datenkonflikten durch ‘‘Stalls’’ . . . . . . . . . . . . . 342
Auflösen von Datenkonflikten durch Forwarding-Pfade . . . . . . . 342
Strukturkonflikte . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 346
Steuerungskonflikte . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 348

8 Cache 351

8.1 Motivation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 351

8.2 Speicher-Hierarchien . . . . . . . . . . . . . . . . . . . . . . . . . . . . 353

8.3 Begriffsklärungen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 354


Cache-Hit, Hit-Time und Hit-Rate . . . . . . . . . . . . . . . . . . . . . 354
Cache-Miss, Miss-Time und Miss-Rate . . . . . . . . . . . . . . . . . . 354
Verdrängungsstrategien . . . . . . . . . . . . . . . . . . . . . . . . . . . 354
Schreibstrategien . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 355
Aufgaben . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 356

8.4 Direkt-Abgebildeter Cache . . . . . . . . . . . . . . . . . . . . . . . . . 357

8.5 Voll-Assoziativer Cache . . . . . . . . . . . . . . . . . . . . . . . . . . . 360

8.6 Set-Assoziativer Cache . . . . . . . . . . . . . . . . . . . . . . . . . . . 361

9 Pipelining 4
8
9
10
1 Motivation: Wie funktioniert ein Computer?
In diesem Kapitel geben wir Ihnen eine kleine Einführung in den Vorlesungsstoff der Computertechnik.
Dieses Kapitel ist jedoch mehr als nur eine Einführung. Es dient als Überblick über den Aufbau und
die Funktionsweise gängiger Arbeitsplatzrechner. Während dieses Kapitel dabei einen kompletten PC
betrachtet, fokussieren die restlichen Kapitel fast ausschliesslich auf den Prozessor.

Ziel dieses Kapitel ist es, Ihnen das Umfeld von Prozessoren und die Interaktion von Prozessoren mit
diesem Umfeld näherzubringen. Wenn Sie verstanden haben, welche Aufgabe Prozessoren in diesem
Umfeld haben, dann kennen Sie automatisch auch das Funktionsvermögen von Prozessoren, wissen
also, was so ein Prozessor eigentlich können muss. Dies ist die Voraussetzung für die restlichen Kapi-
tel dieses Skripts, in denen wir uns einen eigenen Prozessor zusammenbauen werden.

1.1 Komponenten eines Computers


In diesem Kapitel öffnen wir einen gewöhnlichen Arbeitsplatzrechner und schauen uns einmal an, was
da alles drinnen steckt. Dabei werden wir die zutage tretenden Komponenten hinsichtlich Funktion
und Aufbau untersuchen. Nachdem wir uns bis zu den auf der Hauptplatine befindlichen Komponen-
ten vorgearbeitet haben, werden wir durch eine Abstraktion (Verstecken von Details) die prinzipielle
Funktionsweise des PCs zu erläutern.

Nach dieser Abstraktion werden wird wieder detailreicher, wenn wir das reale (nicht abstrahierte) Zu-
sammenspiel der einzelnen Komponenten betrachten.

Nachfolgende Abbildung zeigt den Arbeitsplatzrechner, den wir im Folgenden zerlegen werden.

Abb. 1: Computer-Arbeitsplatz

11
Wir schrauben die Seitenverkleidung ab …

Abb. 2: Öffnen eines Computers

… und identifizieren die dann erscheinenden Komponenten.

DR

NT

DB

DL

GK FP

FW

Abb. 3: Geräte in einem Computer

12
1.1.1 Peripherie-Geräte und Netzteil

• Netzteil

Das mit NT gekennzeichnete Gerät ist das Netzteil. Es dient zur Stromversorgung des PCs.

Abb. 4: Computer-Netzteil

Computernetzteile wandeln die aus der Steckdose kommenden 230 V Wechselspannung in folgende
Gleichspannungen um:

− +3,3 V und +5 V für das Mainboard (die grosse grüne Platine) und die darauf befindlichen bzw.
damit verbundenen elektrischen Bauteile.

− +12 V für die Motoren der Laufwerke und Lüfter.

− -5 V und -12 V, die heutzutage meist gar nicht mehr verwendet werden, sondern zumeist nur
noch aus Gründen der Kompatibilität zu älteren Geräten vorhanden sind (z.B. -5 V und -12 V für
den ISA-Bus, der in der heutigen Zeit fast nur noch in der Industrie zur Maschinensteuerung
(z.B. CNC-Fräßmaschine) verwendet wird oder -5 V zur ±5 V-Versorgung älterer Floppy-
Controller, die zur Verstärkung des Lesesignals noch Operationsverstärker ohne Ladungspum-
pe einsetzen).

Insbesondere der hohe Stromverbrauch des Hauptprozessors und der Grafikkarte erfordern die Be-
reitstellung hoher Ströme. Nachfolgende Abbildung zeigt eine typische Aufteilung der Leistung auf die
+3,3 V, +5V und +12 V Leitungen. Die Leitung mit der Bezeichnung +5 VSB (SB = Standby) dient zur
Versorgung bestimmter Rechner-Komponenten im Standby-Modus (z.B. Arbeitsspeicher).

13
Ausgangsspannung +3,3 V +5 V +5 VSB +12 V
Strom (max.) 26 A 42 A 2,5 A 18 A
Leistung (max.) 220 W 12,5 W 216 W
max. Gesamtleistung 450 W

Abb. 5: Typische Ausgangsleistung eines ATX-Netzteils

Aufgrund dieser hohen Ströme erfolgt die Spannungsreduktion von 230 V auf die gewünschten Aus-
gangsspannungen nicht durch einen gewöhnlichen Transformator, sondern durch den Einsatz eines
Schaltnetzteils.

In PCs eingesetzte Schaltnetzteile haben oft folgenden Aufbau:

Gleich- Leistungs- Gleich- Tiefpass-


° HF-Trafo
richter Schalter richter Filter
230 V ~ •
° •
° ° •
°
• °
= ° ° ° ° =
°• °•
5V=
• •

° ~
°

° ° ° ~
°

° ° •
°
°
1 2 3 4 5 °

Potential-
Regler
trennung
=
° °
° °

7 6
Abb. 6: Prinzip-Aufbau eines Schaltreglers

Eine mögliche Zuordnung der Komponenten ist in nachfolgender Abbildung angegeben.

4
3 2 5

2
6

1 3

Abb. 7: Identifizierung von Schaltregler-Komponenten

14
Der in Abb. 6 gezeigte Schaltregler funktioniert wie folgt:

− Die Netzspannung (230 V Wechselspannung, 50 Hz) wird an einen Gleichrichter (1) angelegt,
der daraus eine Gleichspannung generiert.
− Über einen Leistungsschalter (2) wird diese Spannung der Primärseite eines HF-Trafos (3) zu-
geführt. Der Leistungsschalter sorgt durch permanentes Ein- und Ausschalten dafür, dass die
am HF-Trafo angelegte Spannung mit einer Frequenz von ca. 20 – 200 kHz ein- und ausge-
schaltet wird.
− Der HF-Trafo (3) überträgt die an der Primärseite angelegte Spannung auf seine Sekundärseite.
− Der Gleichrichter (4) erzeugt aus der sekundärseitigen Wechselspannung wieder einen rein po-
sitiven Spannungsverlauf, der durch das Tiefpassfilter (5) auf einen Mittelwert gebracht wird.
− Dieser Mittelwert entspricht der aktuellen Ausgangsspannung.
− Die Ausgangsspannung dient als Eingang für den Regler (6), der zur Aufgabe hat, die Aus-
gangsspannung auf einem bestimmten Niveau zu halten. Dies erreicht der Regler durch Ände-
rung des An-/Aus-Verhältnisses des Signals, das den Leistungsschalter steuert. Die Ausgangs-
spannung des Schaltnetzteils ist dabei lediglich abhängig vom Tastverhältnis (Verhältnis der
An-/Aus-Zeit) des Signals, das den Leistungsschalter ein- bzw. ausschaltet.
− Die Potentialtrennung (7), die in der Regel durch Optokoppler erreicht wird, verhindert, dass die
230 V Netzspannung über den Regelkreis zum Ausgang des Netzteils gelangt.

Zwar müssen in Schaltreglern auch Trafos eingesetzt werden, diese können jedoch wesentlich kleiner
gebaut werden, da sie durch die Verwendung einer hohen Frequenz (20 – 200 kHz statt 50 Hz Netz-
frequenz) wesentlich mehr Leistung (proportional zur Frequenz) übertragen können und die Win-
dungsanzahl somit gering bleiben kann.
Wenige Windungen auf der Sekundärseite ⇔ geringer Innenwiderstand der Sekundärseite ⇔ in der
Sekundärseite wird wenig Leistung in Wärme umgewandelt ⇒ guter Wirkungsgrad.

Nachfolgend angegebene Steckerbelegung eines ATX-Netzteils zeigt, dass aufgrund der hohen
Strombelastung bei +3,3 V und +5 V diese Spannungen über mehrere Kontakte parallel übertragen
werden.

+3,3 V 11 1 +3,3 V
-12 V 12 2 +3,3 V
GND 13 3 GND
PS_ON 14 4 +5 V
GND 15 5 GND
GND 16 6 +5 V
GND 17 7 GND
-5 V 18 8 PW_OK
+5 V 19 9 +5 VSB
+5 V 20 10 +12 V

Abb. 8: Steckerbelegung eines (ATX-) Netzteils

Die Signale PS_ON und PW_OK haben folgende Funktion:


− PS_ON ist die Abkürzung für Power supply on. Dieses Signal ist ein Eingangs-Signal und dient
dazu, das Netzteil einzuschalten. Die Leitung PS_ON muss dabei auf Masse (GND für engl.
Ground) gelegt werden.
− PW_OK ist die Abkürzung für Power ok. Dieses Signal liegt beim Einschalten des Netzteils auf
Masse und wechselt auf einen Pegel von etwa 5 V, wenn sich die vom Netzteil gelieferte Span-
nung nach dem Einschalten stabilisiert hat. PW_OK ist auf der Hauptplatine mit dem Taktgeber
des Prozessors verbunden und sorgt über die Reset-Leitung dafür, dass der Prozessor erst
dann mit der Abarbeitung von Befehlen beginnt, wenn sich die Versorgungsspannung stabili-
siert hat. Auf diese Weise wird verhindert, dass der Prozessor in einen undefinierten Zustand
gerät.

15
• Grafikkarte

Die in Abb. 3 auf Seite 12 mit GK gekennzeichnete Einsteck-Platine ist die Grafikkarte.

Anschluss für den Stecker für zusätzliche Stromversorgung


Monitor (DVI)
Speicherchips mit Kühlkörper

BIOS GPU mit Kühlkörper


(GPU = Graphics
AGP-Anschluss Processing Unit)
Anschluss für den (Verbindung zum Prozessor)
Monitor (VGA)
Abb. 9: Grafikkarte

Die Grafikkarte besteht aus folgenden Komponenten:

− GPU (Graphics Processing Unit): Der Prozessor der Grafikkarte. Die GPU implementiert die von
der Grafikkarte bereitgestellten Funktionen:

+ Kommunikation mit dem PC-Prozessor (hier über AGP)


+ Ansteuerung der Speicherchips
+ RAMDAC → Wandlung der digitalen Bildinformationen in analoge Bildschirm-Signale (s.u.)
+ Kommunikation mit dem Monitor (über VGA oder DVI)
+ Beschleunigung von 3D-Funktionen

− Speicherchips, um Bilddaten und sonstige anfallende Daten abspeichern zu können

− BIOS (Basic Input Output System), um die Grafikkarte auch schon vor dem Laden von Grafik-
kartentreibern verwenden zu können (s.u.)

− AGP-Anschluss (oder auch PCI-Express) zur Kommunikation mit dem PC-Prozessor

− VGA- bzw. DVI-Anschluss zur Kommunikation mit dem Monitor

16
Die Grafikkarte hat im wesentlichen zwei Aufgaben:

− Sie dient als Schnittstelle zwischen Computer und Bildschirm.

− Sie beschleunigt grafikrelevante Berechnungen (insbesondere 3D-Berechnungen).

Als Schnittstelle zwischen Computer und Bildschirm übersetzt die Grafikkarte die Daten, die der Pro-
zessor liefert, in Signale, die der Bildschirm zur Anzeige benötigt.

Die Grafikkarte verfügt über einen sog. Grafik-Speicher (oft auch Video-Speicher genannt).
− In diesen Speicher schreibt der Prozessor die Daten, die er als Bild angezeigt bekommen will.
− Die Grafikkarte liest diese Daten aus und erzeugt aus diesen Daten die entsprechenden Bild-
schirm-Signale.

1
Die einzelnen Byte im Video-Speicher werden direkt auf Pixel -Farben abgebildet. Die Farbe eines
einzelnen Pixels ergibt sich dabei aus der Kombination eines roten (R), grünen (G) und blauen (B)
Bildschirmpunkts. Nachfolgende Abbildung zeigt, wie die im Video-Speicher abgelegten Byte der In-
tensität (Helligkeit) der jeweiligen Bildschirmpunkte (Grundfarben) zugeordnet werden.

Video-Speicher in der Grafikkarte Bildschirm

0x3F
pro Grundfarbe 1 Byte 0x00 R G B R G B R
⇒ 24 Bit Farbtiefe B R G B R G
0x78 …
R G B R G B R
0xFF
1 Pixel B R G B R G
0xE8

Abb. 10: Abbildung der im Video-Speicher abgelegten Werte auf die Intensität von Bildschirm-Punkten

Durch Ändern einzelner Byte im Grafik-Speicher kann der Prozessor die Intensität jedes rot (R)-, grün
(G)- oder blau (B)-Anteils eines Pixels ändern. Soll ein Pixel beispielsweise Rot erscheinen, werden
den zugehörigen drei Byte im Grafik-Speicher die Werte R = 0xFF, G = 0x00, B = 0x00 zugeordnet.
Grün entspricht dann R = 0x00, G = 0xFF, B = 0x00 und ein dunkles Grau etwa R = 0x60, G = 0x60, B
= 0x60.

Zum Verständnis der Umwandlung der im Grafik-Speicher der Grafikkarte abgelegten Byte in ein Bild-
schirm-Signal ist es sinnvoll zu wissen, wie diese Bildschirmsignale überhaupt aussehen.

Bildschirm-Signale, die aus dem DVI-Anschluss kommen, sind digital und können in der Regel nur von
TFT-Bildschirmen verwendet werden.

Die Signale, die aus dem VGA (Video Graphics Array)-Anschluss einer Grafikkarte kommen, sind
analog und so aufgebaut, dass sie sich sehr leicht von einem Röhrenmonitor verarbeiten lassen. Aus
diesem Grund schauen wir uns erst einmal kurz an, wie ein Röhrenmonitor funktioniert (auch wenn
diese gerade von TFT-Bildschirmen vom Markt gedrängt werden).

1
Pixel ist ein aus picture element zusammengesetztes Kunstwort und bezeichnet die Punkte, aus denen gerasterte Bilder
aufgebaut sind. Die Farbe eines Pixels wird dabei aus den drei Grundfarben rot, grün und blau zusammengemischt.

17
Ein (Farb-)Röhrenmonitor enthält drei Kathoden, die jeweils einen Elektronenstrahl aussenden. Jeder
Elektronenstrahl (und somit jede Kathode) ist dabei für eine der drei Grundfarben (RGB) zuständig.
Die drei Elektronenstrahlen können in der Röhre durch sog. Ablenkspulen derart abgelenkt werden,
dass der Auftreffpunkt der Elektronenstrahlen auf der Bildschirmvorderseite horizontal und vertikal
verschoben werden kann. Durch Anlegen einer geeigneten Spannung kann man den Elektronenstrahl
somit an einer beliebigen Stelle auf der Vorderseite der Bildröhre auftreffen lassen.

Abb. 11: Durch geeignete Spannungen an den Ablenkspulen


kann der Auftreffpunkt der drei Elektronenstrahlen beliebig
in horizontaler und vertikaler Richtung verschoben werden.

Um aus den Elektronenstrahlen Farben erzeugen zu können, sind innen auf der Bildschirmvorderseite
abwechselnd phosphorhaltige Stoffe aufgebracht, die bei Elektronenbeschuss entweder Rot, Grün
oder Blau leuchten. Damit die Elektronenstrahlen immer nur die drei zu einem bestimmten Pixel gehö-
rigen Punkte treffen und nicht auch noch benachbarte, ist zwischen den Kathoden und der fluoreszie-
renden Schicht noch eine Lochblende eingebaut.

Kathoden

3 Elektronenstrahlen

Lochblende
R G B R G B R

B R G B R G

R G B R G B R

B R G B R G
Fluoreszierende Schicht

Spulen zur Ablenkung


der Elektronenstrahlen

Abb. 12: Die von den Kathoden abgegebenen drei Elektronenstrahlen werden von Spulen
abgelenkt und treffen dann auf eine Lochblende, welche die Elektronenstrahlen genau
auf die rot, grün oder blau fluoreszierenden Punkte des gewünschten Pixels fokussiert.

18
Führt man die drei Elektronenstrahlen wie in nachfolgender Abbildung angegeben über den Bild-
schirm, werden alle rot, grün und blau fluoreszierenden Punkte von den zugehörigen Elektronenstrah-
len getroffen.

Abb. 13: Weg der drei Elektronenstrahlen über den Monitor

An den Ablenkspulen zur horizontalen Ablenkung muss also eine periodisch ansteigende Spannung
(Sägezahn) Hsync anliegen, so dass die drei Elektronenstrahlen von links nach rechts wandern.

− Hat Hsync einen bestimmten negativen Wert, dann befindet sich der Elektronenstrahl ganz
links.

− Hat Hsync einen bestimmten positiven Wert, dann befindet sich der Elektronenstrahl ganz
rechts.

Bei den Ablenkspulen zur vertikalen Ablenkung muss ebenfalls eine von einem bestimmten negativen
Wert bis zu einem bestimmten positiven Wert ansteigende Spannung Vsync angelegt werden, so dass
die drei Elektronenstrahlen von oben nach unten wandern. Vsync muss dabei jedoch eine um die
Anzahl der Bildzeilen niedrigere Frequenz als Hsync haben. So gelangen die drei Elektronenstrahlen
erst dann am unteren Ende der Bildröhre an, wenn alle Zeilen von links nach rechts durchlaufen wur-
den.

Nachfolgende Abbildung zeigt die von einem VGA-Anschluss gelieferten Signale. Hsync und Vsync
sind dabei die gerade besprochenen Spannungen zur Positionierung der drei Elektronenstrahlen, R,
G, und B sind die Spannungen, welche die Strahlungsintensität der zugehörigen Kathoden und damit
die Intensität jeder Pixel-Grundfarbe steuern.

Hsync

Vsync t

1. Zeile 2. Zeile letzte Zeile 1. Zeile

1. Bild 2. Bild

Abb. 14: Signale am VGA-Anschluss

19
Zur Umwandlung der im Grafik-Speicher abgelegten Daten in die analogen Signale R, G und B ver-
wenden Grafikkarten sog. RAMDACs. Diese RAMDACs wenden auf die im Grafik-Speicher (Grafik-
RAM; RAM = Random Access Memory, s.u.) abgelegten Byte eine Digital-/Analog-Wandlung (DAC =
Digital Analog Converter) an. Die Daten werden dabei byteweise ausgelesen und dann in die analo-
gen Spannungen umgewandelt, die am VGA-Anschluss (vgl. Abb. 14) der Grafikkarte herauskommen.

Nachfolgende Abbildung zeigt den Verlauf der Daten auf dem Weg vom Prozessor zum Bildschirm.

0x3F RAMDAC (für Rot)


0x00
• ••• c:\>

0x78 •• •
RAMDAC (für Grün) •• •
0xFF •• •
• •
0xE8 RAMDAC (für Blau)

Prozessor Video-Speicher Digital-Analog-Wandler VGA-


Bildschirm
auf der Grafikkarte (RAMDAC) Buchse
Abb. 15: Datenverlauf vom Prozessor zum Bildschirm

Die Darstellung von Bildern auf dem Bildschirm funktioniert wie folgt:

− Der Prozessor schreibt die Farbwerte für die Pixel in den Video-Speicher.

− Die im Video-Speicher liegenden Daten werden permanent vom RAMDAC in VGA-Signale


übersetzt und über die VGA-Buchse an den Bildschirm ausgegeben, der das Bild dann anzeigt.

− Das am Bildschirm angezeigte Bild bleibt solange dasselbe, bis der Prozessor andere Werte in
den Video-Speicher der Grafikkarte schreibt.

Die Daten, die der Prozessor in den Video-Speicher schreibt, müssen jedoch erst berechnet werden,
was im Vergleich zu den von der Grafikkarte auszuführenden Aktionen (Auslesen der Daten aus dem
Grafik-Speicher und Wandlung durch die RAMDACs [und der Darstellung am Bildschirm]) relativ lange
dauert.

Nehmen Sie an, auf den Bildschirm soll eine Linie mit einer bestimmten Dicke und einer bestimmten
Länge gezeichnet werden, wie z.B. die nachfolgend abgebildete Linie.

Abb. 16: Linie

Um im Grafik-Speicher für jedes Pixel die Intensität der drei Grundfarben Rot, Grün und Blau ablegen
zu können, muss der PC-Prozessor zunächst berechnen, welche Pixel beim Zeichnen der Linie mit
welcher Farbe eingefärbt werden müssen.

20
Ausgehend von einer mathematischen Beschreibung der Linie, z.B. der Geradengleichung y = mx + t,
kann man bestimmen, welche Pixel von der Linie überhaupt getroffen werden.
2
Nachfolgende Abbildung zeigt, wie ein kurzer Ausschnitt der Linie auf den Pixeln zu liegen kommt.

Farbpunkte
auf dem
Bildschirm

zu zeichnende
einzelne Linie
Pixel

Abb. 17: Ausschnitt der Linie

Für alle Pixel, die von der Linie berührt werden, muss der Prozessor jetzt berechnen, zu welchem Teil
die Pixel von der Linie bedeckt werden.

− Bedeckt die Linie den Pixel vollständig, wird er schwarz eingefärbt, d.h. im Grafik-Speicher wer-
den an der entsprechenden Speicherstelle für Rot, Grün und Blau jeweils die Werte 0 eingetra-
gen.

− Bedeckt die Linie die Pixel nur zu 40 Prozent, so trägt die Farbe der Linie (hier schwarz) auch
nur zu 40 Prozent zur Farbe des Pixels bei. Die restlichen 60 Prozent der Farbe des Pixels ent-
sprechen der ursprünglichen Farbe des Pixels (bei uns also der Farbe weiss). Mit RGBschwarz =
(0, 0, 0) und RGBweiss = (255, 255, 255) ergibt sich damit für die neue Farbe RGBneu = (0,4 ⋅ 0 +
0,6 ⋅ 255 , 0,4 ⋅ 0 + 0,6 ⋅ 255 , 0,4 ⋅ 0 + 0,6 ⋅ 255), also der neue Farbwert RGBneu = (153,
153, 153).

Die Pixel-Darstellung der Linie ergibt sich damit wie folgt:

Abb. 18: Pixeldarstellung der Linie

Der Übergang von der Darstellung „Linie mit y = mx + t“ in die Pixeldarstellung wird in der Computer-
grafik als rendern bezeichnet.
Das Vorgehen, von der Linie berührte Pixel nicht einfach in der Farbe der Linie darzustellen, sondern
die Farbe des Pixels aus dem prozentualen Anteil der Überdeckung zu Mischen, wird Antialiasing
genannt.

2
Im obersten linken Pixel ist noch einmal dargestellt, wie die Pixel auf dem Bildschirm durch rote, grüne und blaue Punkte
erzeugt werden.

21
Die für die Render-Vorgänge benötigten Berechnungen werden von optimierten Assembler-Routinen
durchgeführt, die im Betriebssystem verankert sind. Diese Routinen können über die Schnittstelle des
Betriebssystems aufgerufen werden, so dass jeder Programmierer Linien, Kreise, aber auch einzelne
Punkte auf dem Bildschirm zeichnen kann.

Obwohl die Render-Vorgänge bereits als optimierter Assembler-Code geschrieben sind, dauert deren
Ausführung (im Vergleich zur Darstellung der im Video-Speicher abgelegten Daten auf dem Bild-
schirm) relativ lange.

Würden die langsamen Render-Vorgänge direkt auf dem Grafik-Speicher ausgeführt werden, dann
würden Objekte bereits dann auf dem Bildschirm erscheinen, wenn sie noch gar nicht fertig berechnet
sind, was vom Betrachter insbesondere bei bewegten Objekten als sehr störend empfunden würde
(flickern).

Aus diesem Grund wird beim Rendern nicht direkt in den Grafik-Speicher, sondern in einen sog. Back-
Buffer gerendert, der ebenfalls auf der Grafikkarte zu finden ist. Ist das Bild fertig gerendert, werden
Grafik-Speicher und Back-Buffer vertauscht. Dabei werden die in den Puffern enthaltenen Daten je-
doch nicht kopiert, sondern es wird den RAMDAC-Bausteinen einfach mitgeteilt, dass sich der Grafik-
Speicher jetzt an einer anderern Adresse befindet. Der ehemalige Grafik-Speicher wird dann automa-
tisch zum Back-Buffer.

0x3F
0x00
0x78
wird gerade dargestellt
0xFF
0xE8

RAMDAC (für Rot)


• ••• c:\>

•• •
RAMDAC (für Grün) •• •
•• •
• •
RAMDAC (für Blau)
0x4C
0x38

0x79
0x00 wird gerade erstellt und
im Anschluss dargestellt
0xFE

Prozessor Front- und Digital-Analog-Wandler VGA-


Bildschirm
Back-Buffer (RAMDAC) Buchse
Abb. 19: Front- und Back-Buffer

Um das Verhältnis von Grafik-Speicher und Back-Buffer zu verdeutlichen, wird der Grafik-Speicher
auch oft Front-Buffer genannt.

22
Zu Beginn dieses Abschnitts hatten wir erwähnt, dass die Grafikkarte nicht nur als Schnittstelle zwi-
schen Computer und Bildschirm dient, sondern auch 3D-Berechnungen beschleunigt, worauf wir im
Folgenden kurz eingehen werden.

In der 3D-Computergrafik (wie z.B. bei PC-Spielen) werden Objekte bzw. deren Oberflächen durch
Polygone (z.B. Dreiecke) modelliert (vgl. nachfolgende Abbildung).

Abb. 20: Modellierung von Objekten durch Polygone (Daten für die Grafikkarte)

Diese Modellierung wird vom PC-Prozessor durchgeführt. Wenn sich beispielsweise in einem PC-
Spiel Personen bewegen, berechnet der PC-Prozessor permanent die Positionierung der verschiede-
nen Polygone. Die Polygone haben natürlich ganz bestimmte Oberflächeneigenschaften wie Farbe,
Struktur etc. Diese Oberflächeneigenschaften übergibt der Prozessor zusammen mit den 3D-
Koordinaten der berechneten Polygonpunkte der Grafikkarte, die die aktuelle Szene dann in ein nor-
males Bild umwandelt (vgl. nachfolgende Abbildung).

Abb. 21: Von der Grafikkarte erzeugtes Bild

Die Grafikkarte „initialisiert“ dabei jedes Polygon mit der zugehörigen Oberfläche (Struktur und Grund-
farbe). Anschliessend berechnet die Grafikkarte für jede Polygon-Position die gerade aktuellen Licht-
verhältnisse der Umgebung und ändert das Erscheinungsbild der Polygone dementsprechend. Aus-
serdem berechnet die Grafikkarte, welche Polygone von anderen verdeckt werden und wandelt so das
dreidimensionale Bild in ein zweidimensionales Bild um. Im Anschluss rendert die Grafikkarte die Po-
lygone, d.h. sie erzeugt aus den Polygonen die Farbwerte der einzelnen Pixel, die sie dann in den
Back-Buffer überträgt. Zur Darstellung des Bilds auf dem Bildschirm müssen dann nur noch Front- und
Back-Buffer umgeschaltet werden.

23
Die Berechnungen zur Oberflächenstrukturierung, Beleuchtung und Verdeckung sind sehr aufwendig.
Ohne Grafikbeschleunigung müssten diese Berechnungen alle vom PC-Prozessor ausgeführt werden.
Mit Grafikbeschleunigung kann die Arbeit des PC-Prozessors auf die Berechnung der Polygon-
Positionen beschränkt bleiben, da die Grafikkarte den Rest erledigt. Da die Grafikkarte auf diese Art
von Berechnungen spezialisiert ist, kann sie diese wesentlich schneller ausführen als der PC-
Prozessor. Darüber hinaus arbeitet die Grafikkarte parallel zum Prozessor, so dass die Grafikkarte
beispielsweise ein Bild rendern kann, während der PC-Prozessor gerade die Polygon-Positionen des
nächsten Bildes berechnet.

24
• DVD-ROM

Das in Abb. 3 auf Seite 12 mit DR gekennzeichnete Gerät ist das DVD-ROM-Laufwerk.

DVD-ROM-Laufwerke dienen zum Lesen von DVDs und CDs. Diese Laufwerke können also keine
Daten aufzeichnen (ROM = Read Only Memory ⇒ nur lesen), sondern sie lediglich lesen.

Um den Aufbau eines DVD-ROM-Laufwerks leichter verstehen zu können, schauen wir uns erst ein-
mal an, wie Daten auf einer DVD gespeichert werden.

Wie in nachfolgender Abbildung gezeigt, besteht eine DVD aus Spuren, die spiralförmig von innen
nach aussen verlaufen.

Abb. 22: Spuren auf einer DVD

25
Die Spuren bestehen dabei aus einer Folge verschieden langer Erhöhungen, den sog. Pits, die auf
dem sog. Land aufgebracht sind.

Pits

Land

Abb. 23: Pits und Land

Pits und Land sind aus dem gleichen Material und mit einer Aluminium-Schicht verspiegelt, so dass
sowohl Pits als auch das Land auftreffendes Licht reflektieren. Die reflektierende Seite ist mit einer
Schicht aus Polycarbonat vor Kratzern geschützt, die andere Seite dient der Beschriftung der DVD.

Von der Seite betrachtet, ergibt sich für Pits und Land somit folgendes Bild:

Beschriftung der DVD/Etikett


Drehrichtung
Träger (Land)
reflektierende
Pit ALU-Schicht

Land Polycarbonat
Leseseite der DVD

Abb. 24: Aufbau einer DVD-ROM

26
Zum Auslesen der DVD wird die Leseseite der DVD mit einem Laser bestrahlt und das von der ALU-
Schicht reflektierte Laser-Licht von einem Photo-Detektor aufgefangen.
Beschriftung der DVD/Etikett
Drehrichtung
Träger (Land)
reflektierende
Pit ALU-Schicht

Land Polycarbonat
Leseseite der DVD

Halbdurchläs-
siger Spiegel

Photo-Detektor Auswertung der Signale


Laser Umwandlung in einzelne
Byte

Abb. 25: Prinzip-Darstellung eines DVD-ROM-Laufwerks

Angenommen, die DVD bewegt sich in der angegebenen Drehrichtung. Was für ein Licht-Signal
kommt dann beim Photo-Detektor an?

− Auf den ersten Blick scheint sich beim Photo-Detektor keine Änderung des Licht-Signals zu er-
geben, da sowohl die Pits als auch das Land das Laser-Licht reflektieren.

− Wenn die Höhe der Pits auf dem Land jedoch ein Viertel der Wellenlänge des Lasers beträgt,
erscheint das von den Pits reflektierte Licht wesentlich dunkler als das vom Land reflektierte
Licht. Warum?

Nachfolgende Abbildung zeigt mehrere Licht-Wellen. Die oberen beiden Wellen sind dabei in Phase,
die unteren beiden sind gegenphasig, haben also einen Phasenversatz von 180°.

einzelne Lichtwellen Summe

konstruktive Interferenz:

destruktive Interferenz:

Abb. 26: Konstruktive und destruktive Interferenz

Man erkennt deutlich, dass sich bei der Addition beider Wellen bei

− gleichphasigen Wellen eine gleichartige Welle mit grösserer Amplitude ergibt. Die Wellen über-
lagern sich also konstruktiv, man spricht von konstruktiver Interferenz.

27
− gegenphasigen Wellen beide Wellen genau auslöschen. Die Wellen überlagen sich also de-
struktiv, man spricht von destruktiver Interferenz.
Betrachtet man die Pits und das Land auf der DVD von der Leseseite her, fällt folgendes auf:

destruktive Interferenz
konstruktive Interferenz

Ansicht von unten


(Leseseite)

Laser

Abb. 27: Auftreffen des Lasers auf der DVD

− Trifft der Laser auf reines Land, wird er einfach reflektiert.

− Trifft der Laser jedoch auf ein Pit, so trifft er neben dem Pit auch noch auf Land, da der Radius
des Laserstrahls grösser ist als die Breite eines Pits. Das reflektierte Laser-Licht enthält also
sowohl Licht, das vom Land reflektiert wurde, als auch Licht, das vom Pit reflektiert wurde.

Nachfolgende Grafik zeigt diese Situation von der Seite betrachtet. Darunter ist das von der DVD-Spur
reflektierte Laser-Licht abgebildet, das dann auf den Photo-Sensor trifft.

Ansicht von der Seite


(Querschnitt)

von der Leseseite


reflektiertes Laserlicht

konstruktive Interferenz destruktive Interferenz


(es wird viel Licht reflektiert) (es wird fast kein Licht
reflektiert, da sich die
Wellen gegenseitig aus-
löschen)

Abb. 28: Reflexionen an der DVD

28
Die rotierende DVD reflektiert also
− beim Auftreffen des Laserstrahls auf Land das komplette Licht.
− beim Auftreffen des Laserstrahls auf Pits fast kaum Licht.
Der Photo-Detektor bekommt dabei bei rotierender DVD eine Folge von „Licht an/Licht aus“ mit, die er
als Rechteck-Spannung an einen im DVD-Laufwerk eingebauten Chip weiterleitet.

Spannung

Zeit

Abb. 29: Vom Photo-Detektor erzeugte Rechteck-Spannung

Dieser Chip tastet die Rechteckspannung ab und wandelt die darin gespeicherte Information in Bits
um. Die Bits sind jedoch nicht direkt als Pits und Land codiert. Das hat folgende Gründe:

− Sich rasch ändernde Bitfolgen wie z.B. 10101 können vom Laser nicht mehr aufgelöst werden.

− Bei sich sehr langsam ändernden Bitfolgen wie z.B. 00000000000000000000000111111


111111 geht die Synchronisation verloren, d.h. es kann nicht genau gezählt werden ob jetzt
bspw. 23 oder 24 Nullen in der Bitfolge vorkamen. Das liegt daran, dass die Umdrehungsge-
schwindigkeit der DVD während des Lesens schwanken kann und Zeitmessungen dadurch nur
für relativ kurze Zeiten in die von der aktuellen DVD-Spur zurückgelegte Strecke (und damit die
Anzahl der Bits) umgerechnet werden kann.

Aus diesen Gründen hat man bei der Standardisierung der DVD folgendes festgelegt:
− es müssen auf der DVD immer zwei Pit-Stellen bzw. zwei Land-Stellen in Folge auftreten, d.h.
es darf keine Kombinationen 101 oder 010 geben.
− nach spätestens zehn Pit-Stellen oder zehn Land-Stellen muss ein Wechsel stattfinden.

Zwischen zwei Einsen können also zwei bis zehn Nullen auftreten. Dies führt zur sog. Eight-to-
3
Fourteen-Modulation (EFM), in der ein Byte (8 Bits) durch 14 sog. Channel-Bits kodiert wird. Damit
auch beim Aneinanderfügen von Channel-Codewörtern die obige Forderung nicht verletzt wird, wer-
den zwischen zwei Channel-Codewörtern noch drei sog. Merge-Bits eingefügt. Zur Codierung eines
Bytes sind somit 14 + 3 = 17 Bits notwendig. Diese Bits werden zusammen mit weiteren Bits zur Feh-
lerkorrektur und Adressierung als Pits und Lands auf die DVD gepresst.

Aus Gründen der Fehlerrobustheit werden gesetzte Bits (1) dabei immer nur als Pit-/Land- bzw. Land-
/Pit-Übergang codiert. Eine Folge von Pits oder Lands entspricht immer gelöschten Bits (0).

3 14
Von den mit 14 Bit darstellbaren 2 Bitkombinationen entsprechen lediglich 267 Kombinationen den oben genannten Forde-
8
rungen. Von diesen 267 gültigen Folgen wurden 256 ausgewählt, um ein Byte (8 Bit, also 2 = 256 verschiedene Werte) zu
codieren.

29
1 0 0 1 0 0 0 0 1 0 0 0 0 0 0 1 0 0 1 0 0 0 1 0 0 0 0 1 0 0 1 0

0 1 0 0 0 1 0 0 1 0 0 0 0 1 0 0 1 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0

0 0 0 0 0 0 1 0 0 0 0 0 0 1 0 0 0 0 0 0 1 0 0 0 1 0 0 1 0 0 0 1

0 1 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 1 0 0 1 0 0 1 0 0 0 0 0 1 0

Abb. 30: Codierung der Bits in Pit-/Land-Übergange

30
Zur Erhöhung der Speicherkapazität können auf jeder DVD-Seite Daten auf zwei Ebenen, den sog.
Layern abgespeichert werden. Der dem Laser nähere Layer ist dabei halbtransparent ausgeführt, so
dass der Laser von diesem zwar reflektiert wird, der untere Layer aber auch noch erreicht werden
kann. Die Auswahl der Layer erfolgt durch Einstellung des Brennpunkts des Lasers (Bewegung der
Linse) entweder auf den einen oder den anderen Layer.

reflektierender Layer
halbtransparenter Layer

verschiebbare Linsen
Abb. 31: Doppel-Layer DVD

Die Verschiebung der Linsen kann beispielsweise über Schrittmotoren oder Elektromagnete erfolgen.
Nachfolgende Abbildung zeigt den prinzipiellen Aufbau einer DVD-Mechanik.

Linse
DVD

Antriebsmotor

Gewindestange Spulen zur vertikalen Positionierung der Linse


Motor zur horizontalen Positionierung der Linse
Abb. 32: Prinzip-Aufbau einer DVD-Mechanik

Im echten DVD-Laufwerk sieht das folgendermaßen aus:

Abb. 33: DVD-Laufwerk

31
In der Grossaufnahme kann man den Motor zum horizontalen Verschieben der Linse gut erkennen:

Auflagepunkt
für die DVD
(Antrieb)

Motor zum horizontalen


Verschieben der Linse

Linse

Abb. 34: Innenleben eines DVD-ROM-Laufwerks

Die horizontale Positionierung der Linse erfolgt folgendermaßen:

− Zunächst wird die ungefähre Position der Linse durch Parameter wie Spurbreite, mittlere Pit-
Länge etc. berechnet.

− Anschliessend wird die Linse an die berechnete Position gefahren und und es werden einige
Daten gelesen; die gelesenen Daten enthalten dabei in einem Header abgelegte Adressinfor-
mation.

Header mit Adress-Information Daten Trailer

Abb. 35: Auf der DVD werden Adressinformationen im Header gespeichert

− Diese Adressinformation wird jetzt weiterverwendet, um eine genauere Positionierung der Linse
vorzunehmen.

32
Vergrössert man den Bildausschnitt noch weiter, kann man auch gut die Elektromagnete/Spulen er-
kennen, mit denen die Linse vertikal positioniert wird:

Spulen zur Positionierung der Linse

Linse

Spulen zur Positionierung der Linse

Abb. 36: Vertikale Positionierung der Linse durch Elektromagnete/Spulen

33
• DVD-Brenner

Das in Abb. 3 auf Seite 12 mit DB gekennzeichnete Gerät ist ein DVD-Brenner.

DVD-Brenner funktionieren im Prinzip genauso wie DVD-Leser. Die DVD-Medien sind jedoch anders
aufgebaut: Unterhalb der Reflektierenden Schicht ist eine spezielle Schicht eingebracht, die sich bei
Bestrahlung mit sehr starkem Laser-Licht dunkel färbt und das Licht dann nicht mehr so gut reflektiert.
Auf diese Weise wird die gegenphasige Auslöschung der DVD-ROM nachgeahmt.

Beschriftung der DVD/Etikett


Drehrichtung
Schutzschicht
reflektierende
Pit Schicht

Land
Leseseite nicht reflektierende
Polycarbonat
schwarze Punkte

Abb. 37: Beschreibbare DVD (DVD-R)

Bei beschreibbaren DVDs muss das Laufwerk die Adresse der zu beschreibenden Stellen finden kön-
nen. Nachfolgende Grafik zeigt das Verfahren, das bei der DVD+RW angewendet wird: Die Pits wer-
den in eine Art „Spurrille“, den sog. Grooves geschrieben. Die Seiten der Grooves sind jedoch nicht
gerade, sondern durch eine Modulation von Sinus-Signalen geprägt. Diesen wellenförmigen Seiten
kann das DVD-Laufwerk die Information über die aktuelle Position auf der DVD entnehmen und damit
Daten adressieren.

Grooves (Vertiefungen)

Land

Pits
Abb. 38: Adressierung von beschreibbaren DVDs

Im Gegensatz zu einmal beschreibbaren DVDs (DVD-R) müssen mehrfach beschreibbare DVDs auch
gelöscht werden können. Dies wird durch eine spezielle Metall-Legierung als Reflexionsschicht er-
reicht: In Abhängigkeit der Stärke des Lasers, der die DVD beschreibt, wird das Material entweder
amorph (ungeordnete Anordnung der Moleküle, schlecht reflektierend) oder kristallin (regelmäßige
Anordnung der Moleküle, gut reflektierend).

34
• Festplatte

Das in Abb. 3 auf Seite 12 mit FP gekennzeichnete Gerät ist die Festplatte.

Abb. 39: Festplatte

Die Festplatte ist ein magnetisches Speichermedium, das sehr grosse Datenmengen aufnehmen
kann. Aufgrund des technischen Fortschritts können ca. alle 12 Monate Festplatten mit doppelter Ka-
pazität hergestellt werden.

Im Inneren bestehen Festplatten in der Regel aus ein bis vier drehbar gelagerten festen Platten (des-
wegen der Name Festplatte – im Gegensatz zur biegsamen Floppy-Disk [engl. floppy = schlapp]), die
übereinander montiert sind und immer gleichzeitig gelesen bzw. beschrieben werden. Die Platten sind
in der Regel entweder aus Aluminium oder aus Glaskeramik gefertigt und mit einer magnetisierbaren
Oberfläche (z.B. Eisenoxyd, Kobalt etc.) beschichtet, auf der noch eine Schutzschicht aus Graphit
aufgebracht wird.

Armpositionierung
Permanentmagnet
(Elektromagnet)

Schreib-/Lese-Kopf

schwenkbarer magnetisierbare
Arm Speicherplatte

Anschluss für die Elektronik

Abb. 40: Aufau einer Festplatte

35
Das Abspeichern von Daten auf die Festplatte erfolgt durch die sog. Schreib-/Leseköpfe, die (wie bei
einer Audio-Cassette) Teile der Plattenoberfläche magnetisieren (vgl. nachfolgende Abbildung).

-
+
Spule
Magnetfeldlinien
Schreib-/Lesekopf
magnetisierbare
N N S S N N S S N N S
Schicht

Bewegungsrich-
Trägermaterial
tung der Platte
aus Glaskeramik

Stromverlauf
t
beim Schreiben

Abb. 41: Datenspeicherung auf der Festplatte durch Magnetisierung

Nachfolgende Abbildung zeigt den Vorgang der Magnetisierung der Festplatte.


-
+ Spule

Magnetfeldlinien

ungeordnete
geordnete Elementarmagnete
Elementarmagnete

N S

Magnetisierung (Äquivalent-Magnet) keine Magnetisierung

Abb. 42: Magnetisierung

36
Die Schreib-/Leseköpfe haben die Gestalt eines auf einer Seite aufgesägten „O“ und sind mit einer
Spule umgeben. Wird die Spule bestromt, bildet sich in ihr ein Magnetfeld, das durch den Schreib-
/Lesekopf (eine Art Ferrit) geleitet wird. Da Feldlinien stets geschlossen sind, bildet sich zunächst im
Luftspalt des Schreib-/Lesekopfes (die „aufgesägte Stelle“) ein Magnetfeld. Wird der Spalt in die Nähe
der magnetisierbaren Platte gebracht, schließen sich die Feldlinien nicht mehr über die Luft, sondern
über das magnetisierbare Material, da sich Feldlinien leichter über magnetische Leiter als über mag-
4
netische Nichtleiter schließen.
Durch die magnetische Kraft der Feldlinien werden die im Plattenmaterial befindlichen Elementarmag-
nete dabei so geordnet, dass sie ihre Nord-Süd-Ausrichtung alle in dieselbe Richtung haben. Die
Feldlinien der Elementarmagnete heben sich dann also nicht mehr gegenseitig auf (wie auf der rech-
ten Seite von Abb. 42), sondern bilden zusammen einen „Äquivalent-Magneten“ (linke Seite von Abb.
42). Diese „Äquivalent-Magnete“ bilden die in Abb. 41 gezeigten Magnetfeldlinien, die dauerhaft erhal-
ten bleiben.

Schaltet man die Stromversorgung der Spule des Schreib-/Lesekopfes ab, lässt sich mit dem Schreib-
/Lesekopf die zuvor auf die Platte aufgebrachte Magnetisierung wieder detektieren.

Strommessung • +
(siehe Stromverlauf)
OpAmp
• -
Spule
Magnetfeldlinien
Schreib-/Lesekopf
magnetisierbare
N N S S N N S S N N S
Schicht

Bewegungsrich-
Trägermaterial
tung der Platte
aus Glaskeramik

Stromverlauf
beim Lesen t

t1 t2
Abb. 43: Auslesen von der Festplatte

Detektiert werden dabei lediglich die Grenzen unterschiedlicher Magnetisierung, die sich in kurzen
„Stromstößchen“ (einige µA) äussern (vgl. Abb. 43). Diese Unterschiede im Stromverlauf werden mit
geeigneten elektrischen Schaltungen verstärkt, detektiert und dann ausgewertet.

Die abgespeicherte Information steckt dabei in den unterschiedlichen Längen zwischen den Strom-
stößen. In Abb. 43 ist erkennbar, dass die Zeit t1 wesentlich kürzer ist als die Zeit t2. Diese Zeitunter-
schiede werden von dem auf der Festplatte integrierten Controllerchip (Festplatten-Controller) regis-
triert, ausgewertet und in einzelne Byte dekodiert. Diese Byte stellen dann die auf der Festplatte ab-
gespeicherte Information dar.

Um die Oberfläche der Festplatte nicht zu beschädigen, sind die Schreib-/Leseköpfe auf einem sog.
Schlitten montiert, der im Betrieb durch den von den Platten verursachten Luftzug nach oben gedrückt
wird. Die Schreib-/Leseköpfe liegen also beim Schreiben/Lesen nicht auf den Platten auf, sondern
schweben ganz knapp über ihnen. Wird die Festplatte ausgeschaltet, verringert sich die Rotation der
Platten und der Luftzug reicht nicht mehr aus, um die Köpfe über den Platten schweben zu lassen.
Deshalb wird der schwenkbare Arm, auf dem die Köpfe montiert sind, in eine Park-Position gezogen.

4
Das ist wie beim elektrischen Strom, der auch lieber durch einen Leiter als durch einen Nichtleiter fließt: Überbrückt man einen
Widerstand (Nichtleiter) mit einem Draht (Leiter), dann fließt der ganze Strom durch den Draht und nicht durch den Widerstand.

37
Die Park-Position sind Spuren am Innenrand der Platten, da dort die Plattengeschwindigkeit am ge-
ringsten ist, der Abrieb beim Landen der Köpfe also gering bleibt. Da die Spuren im Landebereich der
Köpfe nicht zum Abspeichern von Daten verwendet werden, tritt kein Datenverlust auf.

Um auf der Festplatte gespeicherte Informationen zu finden, müssen die Daten auf der Festplatte in
irgendeiner Form organisiert sein. Dazu werden die einzelnen Platten in sog. Spuren aufgeteilt.

Spur Sektoren

Abb. 44: Spuren und Sektoren bei einer Festplatte

Da die Platten übereinander montiert sind, bilden die übereinander liegenden Spuren jeweils einen
Zylinder, weswegen man mit dem Begriff Zylinder alle übereinander liegenden Spuren meint.

Platten

Alle übereinander liegenden Spuren bilden jeweils einen Zylinder


Abb. 45: Zylinder

Aktuelle Festplatten verfügen über mehrere tausend Zylinder, also mehrere tausend Spuren pro Plat-
tenoberfläche, wobei die Platten auch beidseitig beschrieben werden. Da die Spuren mehrere Mega-

38
byte (MB) gross sein können, werden die Platten zudem noch in Sektoren (vgl. Abb. 44) eingeteilt. Die
Sektoren sind dabei so gross, dass sie (je nach Hersteller) ca. 570 Byte an Daten speichern können.

Ca. 60 dieser Byte werden für Verwaltungsinformation verwendet.

− Werte zur Synchronisation für den Taktgenerator, der die Zeit zwischen zwei Stromstössen (vgl.
Abb. 43) nur messen kann, wenn er die genaue Umdrehungsgeschwindigkeit der Platte kennt.
− Prüfsummen
− Speicherung der Nummer des aktuellen Zylinders
− Speicherung der Nummer des aktuellen Sektors
− Speicherung der Nummer des aktuellen Schreib-/Lesekopfs
− Start- und Ende-Marken für den Datenbereich
− mehrere „Leer-Byte“ als Toleranzzone für unterschiedliche Umdrehungsgeschwindigkeiten

Die restlichen Byte sind die Nutzdaten des Sektors, welche in der Regel 512 Byte lang sind.

Das Aufbringen dieser Verwaltungsinformation wird Grundformatierung genannt. Sie steht im Gegen-
satz zur logischen Formatierung, bei der Betriebssystem-spezifische Daten zur Verwaltung von Datei-
en auf die Platten geschrieben werden (z.B. ein Inhaltsverzeichnis).

Um Daten aus einem bestimmten Sektor einer bestimmten Spur einer bestimmten Platte auslesen zu
können, werden die Schreib-/Leseköpfe über dem gewünschten Zylinder positioniert und der von der
Festplatte gelieferte Datenstrom gelesen. Der Festplatten-Controller wartet solange, bis er in dem
Datenstrom des betreffenden Schreib-/Lesekopfs die gewünschte Sektor-Nummer detektiert, macht
sich dann lesebereit und liest beim Auftreten der nächsten Start-Marke solange Werte ein, bis er eine
Ende-Marke detektiert. Da alle Schreib-/Leseköpfe an einem einzigen schwenkbaren Arm befestigt
sind, können alle zu einem Zylinder gehörigen Spuren gleichzeitig gelesen werden.

Die Positionierung der Schreib-/Leseköpfe ist dabei eine sehr heikle Angelegenheit. Betrachten Sie
dazu die in nachfolgender Tabelle angegebenen typischen Daten einer Festplatte:

Abmessung der Schreib-/Leseköpfe 0,3 mm x 0,1 mm


Dicke des Luftkissens, auf dem die Köpfe schweben 20 nm
Umdrehungsgeschwindigkeit der äußeren Spuren
110 km/h
(Radius = 4 cm, 7200 U/min)
Spurabstand (bei 1500 Spuren pro cm) 6,7 µm
Bit-Abstand 0,5 µm
Abb. 46: Festplatten-Daten

Um uns diese Daten besser vor Augen führen zu können, rechnen wir sie einmal so um, dass die
Dicke des Luftkissens 1 cm beträgt, die Schreib-/Leseköpfe also 1 cm über den Platten schweben. Zur
Skalierung müssen wir dann alle Festplatten-Parameter mit 1 cm / 20 nm = 500.000 multiplizieren. Es
ergeben sich dann folgende Werte:

Abmessung der Schreib-/Leseköpfe 150 m x 50 m


Dicke des Luftkissens, auf dem die Köpfe schweben 1 cm
Umdrehungsgeschwindigkeit der äußeren Spuren
55.000.000 km/h
(Radius = 4 cm, 7200 U/min)
Spurabstand (bei 1500 Spuren pro cm) 3,35 m
Bit-Abstand 25 cm
Abb. 47: Skalierte Festplatten-Daten

39
Nach dieser Skalierung wären die Schreib-/Leseköpfe gut eineinhalb mal so lang und ein halbes mal
so breit wie die Münchener Frauenkirche hoch ist und würden mit einer Geschwindigkeit, mit der sie in
2,6 Sekunden die Erde umrunden, nur 1 cm über dem Boden gleiten. Dabei würden Sie Daten ausle-
sen und schreiben, die nach links und rechts nur 3,35 m von anderen Daten entfernt sind und nach
vorne und hinten bereits nach 25 cm an ihre Nachbarn stoßen. Eine unvorstellbare Leistung!

Typische Festplattenlaufwerke haben eine durchschnittliche Zugriffszeit von ca. 8 ms, das bedeutet,
sie benötigen ca. 8 ms, um ein Drittel aller auf der Oberfläche befindlichen Spuren zu überqueren und
dann zielsicher auf der richtigen Spur zu landen. In unserem Skalierungs-Beispiel beträgt die Entfer-
nung, die in den 8 ms von den Schreib-/Leseköpfen in Frauenkirche-Grösse zurückgelegt werden
müssen, gute 5 km. Das entspricht einer Seitwärts-Geschwindigkeit von 625.000 km/h (in knappen 4
Minuten um die Erde).

Wie kann so eine schwierige Aufgabe gelöst werden? Modernste Regelungstechnik macht’s möglich!

Da die Schreib-/Leseköpfe im Betrieb nicht auf den Platten aufliegen, ergibt sich bei der Bewegung
der Arme so gut wie keine Reibung. Die Arme können also mit minimalstem Kraftaufwand bewegt
werden. Sie lassen sich also auch ruckfrei anfahren und abbremsen. Der Antrieb erfolgt dabei durch
magnetische Kräfte:

− Am drehbar gelagerten Arm ist an der Hinterseite eine Spule angebracht, deren Magnetfeld sich
vom Festplatten-Controller steuern lässt.

− Im Gehäuse der Festplatte sind zwei sehr starke Permanent-Magnete montiert, zwischen denen
die Spule des drehbaren Arms eingebettet ist.

Wird die Spule bestromt, stößt sie sich vom Permanent-Magneten ab und bewegt dabei die Schreib-
Leseköpfe über die Platten.

Permanent-
Magnet zum
Halten des
Arms in der Permanent-
Parkposition Magnete

Spule (am Arm montiert)

Drehlager zur Rotation


des Arms

drehbar gelagerter
Arm

Abb. 48: Mechanik zur Armpositionierung

40
Doch woher weiß der Festplatten-Controller, wieviel Strom er durch die Spule schicken muss, um die
Schreib-/Leseköpfe genau auf den gewünschten Zylinder (auf die gewünschten Spuren) zu positionie-
ren?

Die Antwort ist: Auf den Platten sind sog. Servo-Informationen gespeichert, in denen auch die Num-
mer des jeweiligen Zylinders gespeichert ist.

Diese Servo-Informationen werden in der Regel zwischen den einzelnen Sektoren gespeichert.

Zur Positionierung wartet der Festplatten-Controller zunächst, bis ein Schreib-/Lesekopf über einen
Servo-Bereich fährt. Der Festplatten-Controller liest die Servo-Information ein und ermittelt dadurch
die aktuelle Position des Arms (Ist-Position). Durch Vergleich mit der Soll-Position (Ziel-Zylinder) er-
mittelt der Festplatten-Controller, wie weit die Schreib-/Leseköpfe noch vom Ziel-Zylinder entfernt sind
und erhöht oder verringert den Spulenstrom dementsprechend. Die Platte dreht sich dabei weiter.
Wenn die Schreib-/Leseköpfe das nächste mal einen Servo-Bereich überfahren, vergleicht der Fest-
plattencontroller wieder die aktuelle Position des Arms mit der Soll-Position und berechnet daraus
wieder eine geeignete Spulenspannung. Diese Prozedur wird nun solange wiederholt, bis der Arm
über dem richtigen Zylinder steht. Anschließend findet noch eine Feinpositionierung statt, die mithilfe
spezieller (ebenfalls im Servo-Bereich abgespeicherten) Fein-Positionierungs-Informationen durchge-
führt wird.

Im Festplatten-Controller ist also unter anderem ein Regler implementiert, der aus den Laufwerkspa-
5
ramtern, der Ist- und der Soll-Position den nötigen Spulenstrom bestimmt.

aktueller
Fehler
Soll-Position + Regler • Spulenstrom

Laufwerk
Ist-Position

Abb. 49: Regelkreis

Um gute Zugriffszeiten der Festplatte zu erreichen, muss der Arm möglichst schnell von seiner Ist-
Position in die Soll-Position bewegt werden. Er darf dabei jedoch nicht über sein Ziel hinausschiessen
und zu weit fahren. Gute oder schlechte Zugriffszeiten von Festplatten sind somit nicht zuletzt auf die
verwendeten Regelungs-Algorithmen zurückzuführen.

Zur Verbesserung der Zugriffszeit der Festplatte kann die Umdrehungsgeschwindigkeit der Platte
erhöht werden, so dass die zeitlichen Abstände, in denen die Servo-Informationen an die Schreib-
/Leseköpfe gelangen, verringert werden.

Eine weitere Möglichkeit zur Beschleunigung der Kopfpositionierung besteht darin, die Servoinformati-
onen nicht nur zu Beginn eines Sektors, sondern auch in kürzeren Abständen auf die Platten zu spei-
chern. Eine verbreitete Vorgehensweise spendiert eine komplette Plattenoberfläche allein für die Ser-
vo-Informationen. Diese Festplatten erkennt man oft daran, dass sie über eine ungerade Anzahl an
Schreib-/Lese-Köpfen verfügen.

Die Servo-Informationen werden vom Festplatten-Hersteller auf die Platte geschrieben und können
nicht gelöscht werden. Auch nicht mit der zuvor erwähnten Grundformatierung.

5
Wie solche Regler funktionieren und wie sie ausgelegt werden müssen, um nicht nur sehr schnell, sondern auch noch stabil zu
arbeiten, können Sie beispielsweise in „Regelungs- und Steuerungstechnik“ bei Prof. Buss oder in einem guten Buch über
Regelungstechnik (z.B. Horn, Dourdoumas, Regelungstechnik, ISBN 3-8273-7059-0) erfahren.

41
In diesem Kapitel haben wir uns diejenigen Peripherie-Geräte angeschaut, die uns unmittelbar nach
dem Öffnen des PCs aufgefallen sind: Netzteil, Grafikkarte, DVD-Laufwerk, DVD-Brenner und die
Festplatte.

DR

NT

DB

DL

GK
FP

FW

Abb. 50: Geräte in einem PC

Wir haben dabei gemerkt: Die betrachteten Geräte sind ziemlich intelligent. Sie können selber schwie-
rige Aufgaben ausführen (z.B. Kopf-Positionierung bei der Festplatte) und dadurch den PC-Prozessor
entlasten. Die Intelligenz und hohe Leistungsfähigkeit der Geräte rührt von den eingebauten Chips
her, die z.T. sehr ähnlich aufgebaut sind wie PC-Prozessoren, mit denen wir uns in dieser Vorlesung
hauptsächlich beschäftigen werden.

42
Jetzt tauchen wir jetzt tiefer in den PC hinein, indem wir das Netzteil und die Steckkarten entfernen
und die dahinter liegende Hauptplatine untersuchen.

1.1.2 Komponenten auf der Hauptplatine - Überblick

Nach dem Ausbau des Netzteils und der Grafikkarte ergibt sich vom Innenleben unseres PCs folgen-
des Bild:

D5 D3
D6 D

C1
D1 D4
A B4 B4
D2 B4 B4

FS

B1
C5 B C3
LA C6
B2
HI
C7 C3
B3 C C2
C7 C8
C7
C9
C4
C7

C7

C7

Abb. 51: Hauptplatine eines Computers

Die grosse grüne Platine ist die Hauptplatine unseres Computers, die auch Mainboard oder
Motherboard genannt wird. Auf der Hauptplatine sind alle wichtigen Komponenten des PCs unterge-
bracht, die nicht so wie die Festplatte oder das DVD-Laufwerk als Peripherie-Geräte angesehen wer-
den. Auf ihr befindet sich der Prozessor (A) der Hauptspeicher (B4), der Chipsatz (B, C), viele An-
schlussmöglichkeiten für Steckkarten (B2, C7), für interne Geräte (C3, D4) wie beispielsweise DVD-
ROM und für externe Geräte (z.B. D1, D2).

Da die Hauptplatine auf den ersten Blick ziemlich kompliziert aussieht, haben wir davon auf der nächs-
ten Seite eine Schema-Darstellung angefertigt, aus der hervorgeht, wie die einzelnen Bausteine auf
der Hauptplatine heißen und wie sie miteinander verschaltet sind.

43
A
Prozessor
Intel P4

NT Rechen- Steuer-
Werk Werk
230 V ~ Netzteil Adress-Umsetzer
Befehls- Daten-
Cache Cache
FSB Logik/Treiber

FS Prozessor-Bus, 4⋅200 MHz


(FSB = Front Side Bus)
B
TFT- Intel 82865G
Bildschirm GMCH
B1
DVI Analoger VGA- Grafik-
Anschluss Controller B4
DDR-RAM
B2
AGP- DDR-RAM
Grafikkarte AGP-Port Kanal A DDR-RAM B4
2,1 GByte/s Controller Controller 3,2 GyteB/s
GK
B4
Gigabit-Ethernet- CSA- DDR-RAM
Controller Controller
B3 266 MByte/s Kanal B DDR-RAM B4
HI Controller 3,2 GByte/s
1 GBit/s
HI = Hub Interface
HI 266 MByte/s
LA
LAN- C
Anschluss Intel 82801EB
ICH5 C6
Takt-Generator
100 MBit/s Ethernet- System-
CPU, PCI, …
Controller Managmnt.

C1 Anschlüsse 480 MBit/s USB2.0- PCI- C7


6 PCI-Slots FireWire-
für USB 2.0 Controller Controller PCI-Bus Adapter
FP 133 MByte/s FW
C2
2 Anschlüsse 150 MByte/s 2 SATA- CMOS-
C8
Festplatte Batterie
für Serial-ATA Controller RAM

DR C3 100 MByte/s
DVD- 2 Anschlüsse ATA 100 Bios-interf.
Flash-Bios C9
ROM für ATA 100 Controller Controller

DVD- Audio-Codec AC `97 SMBus SMBus 2.0/


Brenner C4 AC `97 3 Controller Controller I2C-Bus
DB
LPC-interface
Controller

LPC-Interface
(Low Pin Count)
D
Super
Input/Output
Controller
D4 DL
D1 Anschluss für RS 232 Floppy Anschluss Dis- Disketten-
seriellen Port Controller Controller ketten-Laufwerk Laufwerk

D2 Anschluss für LPT Tastatur PS/2 Anschluss D5


Controller Controller Tastatur Tastatur
parallelen Port

Anschluss für Drehzahl- Maus PS/2 Anschluss


D3 Ventilator regelung Controller Maus Maus
D6

Abb. 52: Schematischer Aufbau eines Computers

44
Die wichtigste Komponente dieser Schema-Darstellung ist der Prozessor (A).

• Prozessor

Nachfolgende Abbildung zeigt den auf der Hauptplatine befindlichen Prozessor (A), nachdem wir den
Kühlkörper entfernt haben.

Abb. 53: Prozessor (Pentium 4, Vorder- und Rückseite)

Der Prozessor ist die zentrale Rechen- und Steuereinheit des gesamten Computers. Wie bzw. was
der Prozessor rechnen oder steuern soll, steht in sog. Programmen, die aus einzelnen Prozessor-
Befehlen bestehen.

Die Prozessor-Befehle sind außerhalb des Prozessors gespeichert und werden vom Prozessor über
den sog. Front-Side-Bus (FSB – in Abb. 51 und Abb. 52 mit FS markiert) in den Prozessor geladen
und dann ausgeführt. Die zu den Befehlen gehörigen Operanden (die sog. Daten) liegen zunächst
ebenfalls außerhalb des Prozessors und müssen über den Front-Side-Bus in den Prozessor geladen
werden.

Um die über den FSB in den Prozessor geladenen Befehle und Operanden im Prozessor ablegen zu
können, verfügen Prozessoren über sog. Register. Register sind sehr schnelle Speicherelemente, die
genau soviele Bits aufnehmen können, wie sich intern parallel verarbeiten lassen. Die Anzahl dieser
Bits nennt man Wortbreite und den Inhalt eines Registers dementsprechend Datenwort oder auch nur
kurz Wort. Bei einem 32 Bit-Pentium-Prozessor beträgt die Wortbreite 32 Bit, die Register sind also 32
Bit breit und können somit genau 32 Bits aufnehmen.

jeweils 1 Bit
MSB LSB

Numerierung der Bits: n-1 …2 1 0

Datenwort mit Wortbreite n


Abb. 54: Datenwort

45
Die Bitstelle mit der geringsten Wertigkeit (ganz rechts) wird auch LSB (engl. Least Significant Bit ⇔
dt. niederwertigstes Bit) genannt. Die Bitstelle mit der höchsten Wertigkeit (ganz links) wird MSB (engl.
Most Significant Bit ⇔ dt. höchstwertigstes Bit) genannt.

Um Befehle sowohl abspeichern, als auch über den Bus übertragen zu können, werden Befehle ge-
nauso wie Operanden und Adressen als Zahlen codiert. Der Befehl „Addiere zwei Zahlen“ kann bei-
spielsweise als 0x20 codiert sein, also der Bitfolge 00100000 entsprechen. Diese Bitfolge kann dann
problemlos abgespeichert bzw. übertragen werden.

Die nachfolgenden Abbildungen zeigen die Abarbeitung von Befehlen durch den Prozessor: Der als
nächstes auszuführende Befehl wird aus einem externen Speicher über den FSB in das Befehls-
Register transportiert. Anschliessend werden die zugehörigen Operanden (ebenfalls über den FSB)
geladen.

FSB = Front Side Bus

BR:
BZ: Registerblock
3
1 • mit Registern

Steuerung •
ALU
Flags:

Steuerwerk

Abb. 55: Laden von Befehlen in den Prozessor

6
Dazu wird vom sog. Steuerwerk zuerst der im Befehlszähler BZ (ein Register im Steuerwerk) stehen-
de Wert als Adresse auf den FSB gelegt (1). Diesen Vorgang nennt man Befehlsadressierung, da im
Befehlszähler immer die Zahl steht, die der Adresse des als nächstes auszuführenden Befehls ent-
spricht. Auf den FSB wird also die Adresse des nächsten Befehlsworts gelegt.

Kurz danach erhält der Prozessor über den FSB das gewünschte Befehlswort, das er dann im Be-
fehlsregister BR ablegt (2).

Nachdem das Befehlswort ins Befehlsregister übertragen wurde, wird es von der Steuerung analysiert
(3). Die Steuerung ermittelt dabei, von woher sie die Operanden des Befehls laden soll, ob die Ope-
randen also z.B.
− direkt im Befehlswort abgelegt sind,
− bereits in den Prozessor geladen wurden und jetzt in Registern stehen, oder
− erst über den FSB in den Prozessor geladen werden müssen.

6
Der Name Steuerwerk leitet sich von der Aufgabe des Steuerwerks ab: Es steuert die Abarbeitung von Befehlen. Es wird oft
auch als Leitwerk bezeichnet, da es zum einen die Befehlsausführung leitet (leiten im Sinne von überwachen, verantwortlich
sein), zum anderen die Befehle und Operanden zu den jeweiligen Prozessor-Komponenten hinleitet (leiten im Sinne von ent-
langleiten, hinführen).

46
Nach dieser Analyse sorgt das Steuerwerk dafür, dass die benötigten Operanden der sog. ALU (Arith-
metic Logic Unit), der Recheneinheit des Prozessors, zugeführt werden.

− Stehen die Operanden direkt im Befehlswort, werden sie von dort zur ALU geleitet (4).

− Stehen die Operanden in Registern, adressiert die Steuerung die entsprechenden Register (5),
d. h. sie teilt dem Registerblock mit, welche Register ausgelesen werden sollen. Anschliessend
sorgt sie dafür, dass die adressierten Operanden aus dem Registerblock an die ALU geleitet
werden (6).

FSB = Front Side Bus

BR:
4 Registerblock
BZ:
• mit Registern
5
Steuerung
5
• 6
4
ALU
Flags:

Steuerwerk

Abb. 56: Bereitstellung von Operanden:


Direktoperanden und Register-Operanden.

− müssen die Operanden erst über den FSB in den Prozessor geladen werden,
+ legt die Steuerung zunächst die Adresse der Operanden auf den FSB (7) und
+ leitet die dann über den FSB gelieferten Daten als Operanden
• entweder direkt an die ALU (8)
• oder erst mal in ein Register (9), von wo aus sie dann von anderen Befehlen der ALU
zugeführt werden können (10).

FSB = Front Side Bus

9
BR:
BZ: Registerblock
• mit Registern
8
Steuerung
7
• 10

ALU
Flags:

Steuerwerk

Abb. 57: Bereitstellen von Operanden über den FSB

47
Nachdem die Steuerung alle Operanden an die ALU angelegt hat, teilt sie der ALU den auszuführen-
den Befehl (z.B. Addieren, Multiplizieren etc.) mit (11) und startet dann die Befehlsausführung (12).

FSB = Front Side Bus

BR:
BZ: Registerblock
• mit Registern

Steuerung
11

12
13 ALU
Flags:
14

Steuerwerk

Abb. 58: Berechnung des Ergebnisses

Treten bei der Befehlsausführung in der ALU unvorhergesehene Ereignisse/Fehler auf (z.B. Division
durch Null), werden diese der Steuerung gemeldet (13), die dann weitere Maßnahmen trifft.

Hat die ALU die ihr aufgetragenen Berechnungen abgeschlossen, meldet sie bestimmte Eigenschaf-
ten des Ergebnisses (z.B. Ergebnis ist Null, Ergebnis ist negativ), indem Sie das im Steuerwerk unter-
gebrachte Flag-Register aktualisiert (14).

Nachfolgende Abbildung zeigt ein Beispiel für ein Flag-Register.

Overflow: Überlauf bei vorzeichenbehafteten Zahlen


Carry (Übertrag): Überlauf bei vorzeichenlosen Zahlen
Zero: Ergebnis ist Null
Sign (Vorzeichbit): Ergebnis ist negativ

OC Z SW I X E

Gleitkomma-Zahl ungenau (z.B. 1.0/3.0)


Gleitkomma-Division durch Null
Ungültige Gleitkomma-Operation (z.B. −1 )
Überlauf bei Gleitkomma-Festkomma-Wandlung

Abb. 59: Flag-Register

48
Je nach ausgeführtem Befehl muss die Steuerung jetzt das am ALU-Ausgang anliegende Ergebnis

− über den FSB verschicken (15). Dazu muss die Steuerung neben dem Ergebnis auch die
Zieladresse (Adresse im Arbeitsspeicher oder Peripherie-Gerät) mit auf den FSB legen (16).

− in ein Register des Registerblocks transportieren (17). Hierbei muss die Steuerung durch Anle-
gen der Registeradresse an den Registerblock diesem mitteilen, in welches Register das Er-
gebnis abgelegt werden soll (18).

FSB = Front Side Bus

20
BR:
BZ: Registerblock
18
• mit Registern

Steuerung
16 21
• 19

ALU
Flags: 15
• 17
Steuerwerk

Abb. 60: Sichern des Ergebnisses

Wird das Ergebnis in einem Register abgelegt, kann es

− sofort wieder verwendet werden (19). Eine zeitaufwendige Datenübertragung über den FSB ist
hier nicht notwendig.

− auch vom Register aus über den FSB verschickt werden (20). Dazu muss die Steuerung wieder
die Zieladresse an den FSB anlegen (21).

Um den nächsten Befehl über den FSB in den Prozessor zu laden, muss der Befehlszähler (die Ad-
resse auf den nächsten Befehl) angepasst werden. Dazu wird zu dem aktuellen Wert des Befehlszäh-
lers die Wortbreite eines Befehls (in Byte) addiert und der Wert des neuen Befehlszählers dann wieder
auf den FSB gelegt [(1) aus Abb. 55 (Seite 46)].

Wortbreite des Addierer


aktuellen Befehls
+
BZ
zum FSB

Abb. 61: Anpassen des Befehlszählers

Ab diesem Zeitpunkt wiederholen sich die in den Abb. 55 bis Abb. 60 dargestellten Schritte. Die im
Speicher stehenden Befehle werden der Reihen nach ausgeführt.

49
Fast genauso wichtig wie der Prozessor ist der Arbeitsspeicher, in dem sowohl die auszuführenden
Befehle, als auch die zugehörigen Operanden (die sog. Daten) stehen.

• Arbeitsspeicher

Die in den Abb. 51 und Abb. 52 mit B4 gekennzeichneten Komponenten sind die DDR-RAM-Module,
die zusammen den Arbeitsspeicher des Computers bilden.

Abb. 62: DDR-RAM (Arbeitsspeicher)

Die Aufgabe des Arbeitsspeichers ist die temporäre Speicherung von Daten und Befehlen. Mit tempo-
rär ist gemeint, dass

− zum Einen die im Arbeitsspeicher abgelegten Daten mit dem Ausschalten des PCs verloren ge-
hen. Der Arbeitsspeicher wird deshalb auch als volatiler (= flüchtiger) Speicher bezeichnet.

− zum Anderen im Arbeitsspeicher nur diejenigen Daten bzw. Befehle liegen, mit denen gerade
gearbeitet wird, woher sich auch der Name Arbeitsspeicher ableitet.

Im Gegensatz dazu ist die Festplatte ein nicht volatiler (= nicht flüchtiger) Speicher. Die Daten auf der
Festplatte gehen also nicht verloren, wenn man sie ausschaltet. Auf der Festplatte sind alle Daten und
Programme (Folge von Befehlen) gespeichert, die man irgendwann einmal verwendet hat oder evtl.
einmal verwenden wird. Mit den Daten auf der Festplatte wird also nicht aktuell gearbeitet, die Daten
werden auf der Festplatte nur gelagert.

Um mit Daten/Programmen zu arbeiten, müssen diese erst von der Festplatte in den Arbeitsspeicher
geladen werden (1) (vgl. nachfolgende Abbildung). Die Daten werden dann vom Arbeitsspeicher in
den Prozessor transportiert (2), dort verarbeitet (3) und dann wieder im Arbeitsspeicher abgelegt (4).
Sollen die Daten erneut bearbeitet werden, müssen sie wieder vom Arbeitsspeicher in den Prozessor
geladen werden (5). Dort werden Sie weiterverarbeitet (6) und im Anschluss wieder in den Arbeits-
speicher zurückgeschrieben (7). Würde der Rechner jetzt ausgeschaltet werden, gingen die Daten
verloren. Um sie permanent zu speichern, müssen sie auf der Festplatte abgelegt werden (8).

50
36

2 4 5 7

1 8

Abb. 63: Datenfluß im PC

Nachfolgende Abbildung zeigt, dass der Arbeitsspeicher wie eine Tabelle funktioniert.

Speicher- Speicher-Inhalt
Adressen (Daten)
0x00..00 0x10
Adresse 1 2 0x00..01 0x2F
z.B. 0x00..02
0x00..02 0x4B 11
0x00..03 5 0xC3
3 0x00..04 10 0x96
Steuer- Lesen
0x00..05 0x83
leitungen Schreiben
8
4

9
0x4B 6 0xFF..FF 0x5D
Daten
7 0x4B Datum (1 Byte)

Abb. 64: Speicher

Um auf Daten im Arbeitsspeicher zuzugreifen, muss man dem Speicher zuerst mitteilen, auf welches
Datum der Zugriff erfolgen soll. Dazu legt man am Eingang Adresse die Adresse der gewünschten
Speicherstelle an (1). Diese sog. Adressierung hat zur Folge, dass im Speicher die Speicher-Stelle mit
dem gewünschten Datum ausgewählt wird (2).

− Soll das ausgewählte Datum aus dem Speicher ausgelesen werden, muss man dies dem Spei-
cher durch ein Signal auf der Steuerleitung Lesen mitteilen (3). Der Speicher reagiert darauf, in-
dem er zwischen der adressierten Speicherstelle und der mit Daten gekennzeichneten Spei-

51
cher-Schnittstelle eine Verbindung freischaltet (4), so dass das gewünschte Datum nach aussen
geleitet wird (5) und dann dort abgegriffen werden kann (6).

− Soll an die ausgewählte Stelle jedoch ein neues Datum geschrieben werden, muss dieses Da-
tum zunächst an die Daten-Schnittstelle angelegt werden (7). Durch ein Signal auf der Steuer-
leitung Schreiben (8) wird dann eine Verbindung zwischen der Daten-Schnittstelle und der
adressierten Speicherstelle hergestellt (9), über die das Datum dann transportiert wird (10). Das
Datum wird anschliessend an der adressierten Speicherstelle abgespeichert (11).

Die Daten-Schnittstelle zum Speicher muss also bidirektional ausgelegt sein, d.h. sie dient beim Lesen
als Ausgang und beim Schreiben als Eingang.
Die Adress- und Steuer-Schnittstelle des Speichers ist unidirektional. Sie dient immer nur als Eingang
und niemals als Ausgang.

Neben der zuvor besprochenen Eigenschaft, dass der Arbeitsspeicher ein nicht flüchtiger Speicher ist,
gibt es noch eine weitere Eigenschaft, die ihn von anderen Speichermedien wie z.B. Festplatte oder
DVD unterscheidet: Ganz egal, auf welche Speicherstelle man gerade geschrieben hat oder von wel-
cher Speicherstelle man gerade gelesen hat, dauert der Zugriff auf eine beliebige andere Speicher-
stelle immer gleich lang. Man spricht deshalb auch von einem Speicher mit wahlfreiem Zugriff, was im
englischen mit RAM (Random Access Memory) abgekürzt wird.

Im Gegensatz dazu muss bei einer Festplatte in Abhängigkeit der Position des gerade adressierten
Datums zur Adressierung eines anderen Datums der Schreib- und Lesekopf einmal mehr, einmal we-
niger weit verschoben werden, was natürlich Zeit kostet. Darüberhinaus kann nach der Positionierung
des Schreib- Lesekopfs erst dann auf den gewünschten Sektor zugegriffen werden, wenn sich dieser
unter dem Schreib-Lesekopf befindet.
Bei DVD-Laufwerken, bei denen die DVD mit gleicher Linear-Geschwindigkeit, also mit unterschiedli-
7
cher Winkel-Geschwindigkeit rotiert, muss zusätzlich noch die Geschwindigkeit erhöht bzw. verringert
werden.

RAMs lassen sich in zwei Gruppen einteilen:

− SRAMs (= Statisches RAMs) und

− DRAMs (Dynamisches RAMs).

Eine SRAM-Speicherzelle benötigt zur Abspeicherung eines Bits sechs Transistoren, von denen sich
vier gegenseitig Sperren bzw. Durchschalten, wie in nachfolgender Abbildung gezeigt.

Zeilenleitung (Auswahl)

UB
Spaltenleitung invertiert

P1 P2
Spaltenleitung

N1 N2
N3 N4

Bit Bit

Abb. 65: SRAM-Speicherzelle

Die Speicherzelle wird über die sog. Zeilenleitung (oder auch Auswahlleitung) adressiert. Das Bit wird
dann über die Spaltenleitungen (Bit bzw. Bit invertiert) ein- und ausgelesen.

7
Sollen die auf der DVD geschriebenen Daten vom Laser mit konstanter Rate abgetastet werden, muss sich die DVD umso
schneller drehen, je weiter innen auf der DVD die Daten gelesen werden.

52
Nachfolgende Abbildung zeigt, wie man in dieser rückgekoppelten Transistor-Schaltung ein Bit ab-
speichern kann. Spannungspegel auf der Höhe der Versorgungsspannung sind dabei mit „+“, Masse
durch „–“ gekennzeichnet.

Zeilenleitung (Auswahl)
1 -
4 + UB

Spaltenleitung invertiert
19 - 12 16
+ 15 +
- 11 + P2
5 P1 6
+ 13 Y +

Spaltenleitung
+
+ N1 - N2 -
7 X 9 18 8
N3 -
10 + N4
14 - 17

2 Bit = 1 (+) 3 Bit = 0 (-)

Abb. 66: Abspeichern eines Bits im SRAM

Im Grundzustand liegt die Zeilenleitung auf Masse (1). Da an den Gates der beiden N-Kanal-
Transistoren N1 und N2 dann ebenfalls Masse anliegt, sperren beide. Die aus den vier Transistoren
P1, P2, N3 und N4 aufgebaute Rückkopplungsschaltung ist somit von der Aussenwelt isoliert.

Will man ein Bit mit dem Wert „1“ in dieser Speicherzelle abspeichern, legt man zunächst den Eingang
Bit auf 1, also auf den Pegel der Versorgungsspannung UB (2) und den Eingang Bit invertiert auf 0,
also auf Masse (3).

Wählt man anschließend durch Anlegen der Versorgungsspannung an die Zeilenleitung (4) die SRAM-
Zelle aus, liegen die Gates der beiden Transistoren N1 und N2 auf UB (5, 6).
Da die Spaltenleitung Bit auf UB liegt (2), liegt auch am Source-Anschluss von N1 UB an (7), weswe-
gen dieser sperrt. Punkt X wird von N1 also auf keinen bestimmten Spannungspegel gezogen.
Da die Spaltenleitung Bit invertiert auf Masse liegt (3), liegt der Source-Anschluss von N2 ebenfalls
auf Masse (8). Da das Gate von N2 auf UB-Pegel liegt (6) schaltet N2 durch und zieht den Punkt Y auf
Masse (9). Aus diesem Grund werden auch die Gates von N3 und P1 auf Masse gezogen (10, 11).

Da bei N3 sowohl Gate (10) als auch Source auf Masse liegen, sperrt dieser. Bei P1 hingegen liegt
Source auf UB (12), so dass P1 leitend wird und der Punkt X auf UB-Potential gezogen wird (13).

Dies hat wiederum zur Folge, dass die Gates von N4 und P2 ebenfalls auf UB-Potential liegen (14,
15). Da bei P2 jetzt sowohl Source (16) als auch Gate (15) auf UB-Potential liegen, sperrt dieser.

N4 leitet jedoch, da sein Gate auf UB-Potential (14) und Source auf Masse (17) liegt. Daraus folgt,
dass Punkt Y auch dann auf Masse-Pegel bleibt (18), wenn an der Zeilenleitung wieder UB-Pegel an-
gelegt wird (19), die Transistoren N1 und N2 damit nicht mehr durchschalten und die aus P1, P2, N3
und N4 bestehende Rückkopplungsschaltung wieder von der Aussenwelt abtrennen.

Durch die Rückkopplung der vier Transistoren P1, P2, N3 und N4 liegt Punkt X somit auf +UB und
Punkt Y auf Masse. Dieser Zustand entspricht dem abgespeicherten Wert „1“. Läge Punkt X auf Mas-
se und Punkt Y auf +UB, entspräche das dem abgespeicherten Wert „0“.

53
Wie der im SRAM gespeicherte Wert wieder ausgelesen werden kann, zeigt die nachfolgende Abbil-
dung.

UB/2 UB/2
5 5
4 + 4 +
N5 N6
Precharge
2 -
3 +
7 -
6 6
UB/2 UB/2
Zeilenleitung (Auswahl)
1 -
8 + UB

Spaltenleitung invertiert
16 -
P1 P2
Y
Spaltenleitung

N1 N2
X
N3 N4

Bit Bit

10 -
- +UB ⇒ 1 11
- UB ⇒ 0 12
+ +
9

Abb. 67: Auslesen einer SRAM-Speicherzelle

Um das gespeicherte Bit auszulesen, muss getestet werden, ob

− entweder Punkt X auf positivem Potential und damit Punkt Y auf negativem Potential liegt (dann
ist eine „1“ gespeichert),

− oder Punkt X auf negativem Potential und damit Punkt Y auf positivem Potential liegt (dann ist
eine „0“ gespeichert).

Für diesen Test werden durch Anlegen von +UB an die Zeilenleitung (8) die beiden Transistoren N1
und N2 durchgeschaltet und die Potentiale der Punkte X und Y an einen Differenzverstärker weiterge-
leitet (9, 10), dessen Ausgang dann je nach abgespeichertem Bit entweder +UB (abgespeichertes Bit
war eine 1) oder auf -UB (abgespeichertes Bit war eine 0) liefert (11, 12).

Damit beim Durchschalten der Transistoren N1 und N2 am Differenzverstärker möglichst schnell die
Pegeldifferenz der Punkte X und Y anliegt, sollten die beiden Spaltenleitungen (Bit und Bit invertiert)
vor dem Durchschalten auf selbem Potential liegen.

− Da die beiden Spaltenleitungen aufgrund der daran angeschlossenen Transistoren und der
Verdrahtung über eine gewisse Kapazität verfügen, ist auf ihnen stets eine gewisse Ladung ge-
speichert.

− Im ungünstigen Fall hat diese Ladung ein zur Ladung an den Punkten X und Y genau entge-
gengesetztes Vorzeichen.

− Diese Ladung auf den Spaltenleitungen muss beim Durchschalten der Transistoren erst über-
wunden werden, was einen Zeitverlust darstellt.

54
− Liegen beide Spaltenleitungen vor dem Durchschalten von N1 und N2 jedoch auf selbem Po-
tential, genügt bereits der Transport einer sehr geringen Ladungsmenge, um den zwischen den
Punkten X und Y vorhandenen Potentialunterschied durch den Differenzverstärker detektieren
zu können.

− Die Detektion erfolgt dann sehr schnell, was eine sehr kurzen Auslesezeit der Speicherzelle zur
Folge hat.

Im Grundzustand liegen die Zeilenleitung und die Steuerleitung Precharge jeweils auf Masse (1, 2).
Die aus P1, P2, N3 und N4 bestehende Rückkopplungsschaltung ist somit von den Spaltenleitungen
getrennt.

Um die Spaltenleitungen auf gleiches Potential (in diesem Beispiel UB/2) zu legen, wird auf der Steuer-
leitung Precharge für kurze Zeit die Spannung +UB angelegt (3). Da das Gate (4) der Transistoren N5
und N6 dann auf höherem Pegel liegt als die zugehörigen Source-Anschlüsse (5), schalten N5 und N6
durch. Die Spaltenleitungen Bit und Bit invertiert werden somit beide auf UB/2-Potential aufgeladen (6)
und die beiden Transistoren N5 und N6 durch Anlegen von Masse an die Precharge-Leitung (7) da-
nach wieder gesperrt.

Selbst wenn bei einer abgespeicherten „1“ N1 aufgrund des geringen Spannungsunterschiedes (ΔU =
UB – UB/2 = UB/2) zwischen Gate und Source nicht durchschalten sollte, führt die Spaltenleitung Bit
aufgrund der Aufladung zumindest positives Potential. Die Spaltenleitung Bit invertiert wird bei einer
abgespeicherten „1“ hingegen definitiv über N2 auf Masse gezogen, so dass am Differenzverstärker
das Vorzeichen der Pegeldifferenz der Punkte X und Y sofort detektiert werden kann.

55
Im Gegensatz zu SRAM-Speicherzellen sind DRAM-Speicherzellen wesentlich einfacher aufgebaut:
Sie bestehen lediglich aus einem Transistor und einem Kondensator.

Spaltenleitung

Zeilenleitung
C

Abb. 68: DRAM-Speicher

Der Transistor dient – wie die beiden Transistoren N1 und N2 beim SRAM – zur Isolierung des Spei-
cherelements von der Aussenwelt. Das Speicherelement ist hier jedoch nicht eine rückgekoppelte
Transistorschaltung, sondern ein Kondensator.

Um ein Bit im DRAM abzulegen, wird der Transistor durchgeschaltet und der Kondensator über die
Zeilenleitung dann entweder ge- oder entladen. Anschliessend wird der Transistor wieder gesperrt, so
dass die im Kondensator gespeicherte Ladung erhalten bleibt.

Aufgrund von Leckströmen verliert der Kondensator jedoch mit der Zeit seine Ladung, weshalb er
immer wieder aufgefrischt werden muss. Die Speicherzelle muss dabei ausgelesen und dann mit dem
selben Wert wieder beschrieben werden.
-RC/t
Da Laden und Entladen bei Kondensatoren immer Zeit benötigt (U(t) = U0 ⋅ e ), sind Speicherzugrif-
fe auf DRAMs im Vergleich zu Zugriffen auf SRAMs wesentlich langsamer.

Da für DRAM-Speicherzellen vier Bauteile weniger benötigt werden als für SRAM, kann DRAM billiger
hergestellt werden als SRAM. Zudem benötigt eine DRAM-Speicherzelle wesentlich weniger Silizium-
Fläche als eine SRAM-Speicherzelle, weshalb deutlich mehr DRAM-Speicherzellen als SRAM-
Speicherzellen auf einen Chip passen. Aus diesem Grund erreicht man bei einer bestimmten Spei-
chergrösse mit DRAM auch eine höhere Ausbeute als mit SRAM, was den Preis von DRAM im Ver-
gleich zu SRAM weiter senkt.

Gerade diese Wirtschaftlichkeit hat dafür gesorgt, dass als Arbeitsspeicher fast ausschliesslich
DRAM-Speicher verwendet wird.

Da die Zeilen- und Spaltenleitungen des Chips beim Be- und Entladen der Speicherzelle belegt sind
und somit nicht zum Be- und Entladen von anderen Speicherzellen des Speicherchips verwendet wer-
den können, sind die Daten aufeinanderfolgender Adressen in der Regel in verschiedenen Speicher-
chips abgelegt. Auf diese Weise kann bei den häufig auftretenden konsekutiven Speicherzugriffen
(Zugriffe auf aufeinanderfolgende Adressen) die eine Speicherzelle bereits ausgelesen werden, wäh-
rend in die andere noch die beim Auslesen verlorengegangene Ladung zurückgeladen wird.

Solche Verfahren haben zu einer Vielzahl unterschiedlicher DRAM-Speicherarten geführt. Eine von
diesen ist auch das in unserem PC verwendete DDR-RAM (Double-Data-Rate RAM), das eine Wei-
terentwicklung des SD-RAMs (Synchronous DRAM) ist.

56
Wie wir in Abb. 63 auf Seite 51 gesehen haben, werden zwischen Prozessor und Arbeitsspeicher
Daten transportiert. Prozessor und Arbeitsspeicher sind dazu über einen sog. Bus miteinander ver-
bunden. Dass dieser Bus in Abb. 52 auf Seite 44 noch von einem weiteren Chip, dem GMCH (früher
Northbridge genannt), gekreuzt wird, soll uns hier erstmal nicht stören. Wir nehmen zunächst einfach
an, dass der Arbeitsspeicher direkt mit dem Prozessor verbunden ist (vgl. nachfolgende Abbildung).

Arbeitsspeicher
Prozessor (CPU)
Bus

BR: Registerblock
• mit Registern
Steuerwerk/
Leitwerk •
Rechenwerk/
ALU

Abb. 69: Prozessor, Arbeitsspeicher und Bus

Desweiteren betrachten wir zunächst auch nicht den in unserem Rechner real verwendeten Bus, son-
dern wir wählen eine Art „Phantasie-Bus“, mit dem sich das Prinzip der Datenübertragung leichter
verstehen lässt. Wenn Sie das Prinzip des Datenaustauschs über Busse verstanden haben, schauen
wir uns die in unserem Rechner vorkommenden realen Busse an.

• Busse

Ein Bus ist nichts anderes als eine Menge paralleler Leitungen, die in ihrer Gesamtheit eine bestimmte
Funktion erfüllen: Das Übertragen von Daten von einem Sender zu einem Empfänger. In unserem
Beispiel vom Prozessor zum Arbeitsspeicher bzw. vom Arbeitsspeicher zum Prozessor.

Wie viele reale Bussysteme, gliedert sich auch der von uns hier betrachtete Phantasie-Bus in drei Teil-
Busse auf:

− Datenbus: Der Datenbus dient zur Übertragung der Daten, die zwischen dem Prozessor und
dem Arbeitsspeicher ausgetauscht werden sollen.

− Adressbus: Der Adressbus dient zur Adressierung. Unter Adressierung versteht man das Aus-
wählen bestimmter Speicherstellen (oder Geräte – s.u.):
+ Beim Schreiben von Daten in den Speicher werden durch die Adressierung diejenigen
Speicherstellen bestimmt, in die die Daten geschrieben werden sollen.
+ Beim Lesen von Daten aus dem Speicher werden durch die Adressierung diejenigen Spei-
cherstellen bestimmt, aus denen die Daten ausgelesen werden sollen.

57
− Steuerbus: Der Steuerbus steuert die Datenübertragung.

+ Wenn der Prozessor Daten in den Speicher schreibt, gibt bei unserem Phantasie-Bus eine
fallende Flanke auf der Schreibleitung Schreiben an, dass
• die auf dem Datenbus befindlichen Daten gültig sind und vom Speicher übernommen
werden können.
• die auf dem Adressbus befindliche Adresse gültig ist und vom Speicher verwendet wer-
den kann.
• der Schreibvorgang jetzt durchgeführt werden soll.

+ Wenn der Prozessor Daten aus dem Speicher liest, gibt eine fallende Flanke auf der Lese-
leitung Lesen an, dass
• der Datenbus jetzt hochohmig (Tristate) ist, so dass der Speicher Daten auf den Daten-
bus ablegen kann, ohne dass es zu einem Kurzschluss kommt.
• die auf dem Adressbus befindliche Adresse gültig ist und vom Speicher verwendet wer-
den kann.
• der Lesevorgang jetzt durchgeführt werden soll.

+ Wenn der Prozessor Daten aus dem Speicher liest, übernimmt er bei der steigenden Flanke
auf der Leseleitung Lesen die auf dem Datenbus anliegenden Daten und speichert sie in-
tern ab.

Nachfolgende Abbildung zeigt die Verwendung unseres Phantasie-Busses bei einem Schreibvorgang.
Dabei wird der 4-Bit-Wert 10102 an die Speicheradresse 01102 geschrieben.

Adress-Bus: 3
1
Bit 3
0 Adr. Inhalt
1
Bit 2 0
0000
0001
1
Bit 1 0 0010
1
0011
Bit 0 0 0100
8 0101
0110 1010 9
Daten-Bus: 0111
4
1
1000
2 0110 Bit 3
Bus 0 1001
1 1010 1010
1
5 Bit 2 0 1011
Bit 1
1 1100
0
1101
Bit 0
1 1110
0
1111

7
Steuer-Bus:
1
Lesen
0
6
1
Schreiben
0

t
Prozessor schreibt tschreiben
Daten 1010 an
Adresse 0110
und gibt an der
Leitung „Schrei-
ben“ eine fallen- Bus besteht aus Adress-, Spannungs-Pegel auf den Bus- Wert am Adress-Bus wählt
de Flanke aus. Daten- und Steuer-Bus. leitungen in Abhängigkeit der Zeit. die Speicherzelle aus, in die
die Daten geschrieben werden.

Abb. 70: Bussignale und deren Verwendung beim Schreibzugriff

58
Zuerst legt der Prozessor das Datenwort (1), das abgespeichert werden soll, zusammen mit der Ad-
resse (2), an die das Datenwort abgespeichert werden soll, auf den Bus.

Die grau hinterlegten Bereiche (3) und (4) zeigen die Adresse und das Datenwort als Signalpegel auf
den Busleitungen.

Nachdem der Prozessor Datenwort und Adresse am Bus angelegt hat, teilt er dem Speicher durch
eine fallende Flanke (5) auf der Steuer-Bus-Leitung Schreiben (6) mit, dass der Speicher die Daten
jetzt abspeichern kann.

Sobald der Speicher die fallende Flanke auf der Schreib-Leitung detektiert (7), wählt er die durch den
Adressbus adressierte Speicherzelle aus (8) und schreibt dorthin das am Datenbus anliegende Da-
tenwort (9).

Das Einlesen von Daten aus dem Speicher in den Prozessor funktioniert so ähnlich:

Adress-Bus: 2
1
Bit 3
0 Adr. Inhalt
1
Bit 2 0
0000
0001
1
Bit 1 0 0010
1
0011
Bit 0 0 0100
6 0101
0110 1010 7
Daten-Bus: 0111
8
1
1000
1 0110 Bit 3
Bus 0 1001
10 1010 1010
1
Bit 2 0
3 9 1011
Bit 1
1 1100
0
1101
Bit 0
1 1110
0
1111

Prozessor legt 5
Adresse 0110 Steuer-Bus:
auf den Adress- 1
4 9
Bus, hält den Lesen
0
Datenbus hoch-
ohmig und gibt Schreiben 1
0
auf der Leitung
t
Lesen eine fal-
tschreiben
lende Flanke
aus. Damit zeigt
er, dass die
Adresse jetzt
gültig ist und Bus besteht aus Adress-, Spannungs-Pegel auf den Bus- Wert am Adress-Bus wählt
sofort gelesen Daten- und Steuer-Bus. leitungen in Abhängigkeit der Zeit. die Speicherzelle aus, aus der
werden soll. die Daten gelesen werden.

Zunächst legt der Prozessor die Adresse der Speicherstelle (1), von der die Daten eingelesen werden
sollen, auf den Adressbus. Der am Adressbus grau hinterlegte Bereich (2) zeigt, wie das Adresswort
0110 auf dem Bus als Logik- bzw. Spannungs-Pegel übermittelt wird.
Mit einer fallenden Flanke (3) auf der Steuerleitung Lesen (4) signalisiert der Prozessor dem Arbeits-
speicher, dass dieser den Inhalt der zur am Adressbus anliegende Adresse gehörigen Speicherstelle
auf den Daten-Bus legen soll. Detektiert der Arbeitsspeicher die fallende Flanke auf der Lesen-Leitung
(5), wählt er die adressierte Speicherstelle aus (6) und legt dann die dort abgespeicherten Daten (7)
am Datenbus an (8).
Der Prozessor wartet eine bestimmte Zeit und generiert dann auf der Lesen-Leitung eine steigende
Flanke (9), die er selber dazu benutzt, die auf dem Datenbus anliegenden Daten zu übernehmen (10).

59
Busse sind jedoch viel universeller, als dass sie nur die Datenübertragung zwischen Prozessor und
Arbeitsspeicher übernehmen könnten: Über Busse können auch alle im PC installierten Geräte ange-
steuert werden. Der Verdrahtungsaufwand ist dabei gering, da alle Kommunikationsteilnehmer sich
einfach an den Busleitungen „einklinken“ können, jede Busleitung also mit jedem Gerät verbunden ist.

Die nachfolgende Abbildungen zeigen, wie Daten nicht nur zwischen Prozessor und Speicher, son-
dern auch zwischen Prozessor und einem beliebigen Peripherie-Gerät übertragen werden können.

Das Schreiben von Daten in ein Peripheriegerät funktioniert dabei wie in nachfolgendem Beispiel: Der
Prozessor schreibt das Datenwort 1010 an die Adresse 0110. Die Adresse 0110 ist in diesem Fall
jedoch nicht dem Arbeitsspeicher, sondern einer bestimmten Speicherstelle in einem der vier an den
Bus angeschlossenen Geräte zugeordnet.

Adress-Bus: 2
1
Bit 3 Gerät 1
0
3 7
1 0110 Adresse ==
Bit 2 0 meine?
1010 ja nein
1
6 8
Bit 1 0

1
Bit 0 0

Gerät 2
3 7
0110 Adresse ==
Daten-Bus: 5 meine?
1010 ja 9 nein
1
1 0110 Bit 3
0
6 12
Bus 1010
4 1010
1
10 Bit 2 0

Bit 1
1 Gerät 3
0
3 7
1 0110 Adresse ==
Bit 0 meine?
0
1010 ja nein
6 8

Steuer-Bus:

Lesen
1
Gerät 4
0
3 7
11 0110 Adresse ==
1
Schreiben meine?
0
1010 ja nein
Prozessor schreibt t 6 8
Daten 1010 an tschreiben
die Adresse 0110
und gibt an der
Leitung „Schrei-
ben“ eine fal- Bus besteht aus Adress-, Pegel auf den Busleitungen Am Bus angeschlossene Ge-
lende Flanke Daten- und Steuer-Bus. in Abhängigkeit der Zeit. räte überprüfen die Adresse
aus. und übernehmen ggf. die Daten.

Abb. 71: Schreiben von Daten in ein am Bus angeschlossenes Gerät (z.B. Steuerbefele fürs DVD-ROM)

Wie zuvor beim Schreibzugriff auf den Arbeitsspeicher legt der Prozessor zuerst die Adresse auf den
Adress-Bus (1). Die Adresse wandert über den Adressbus (2) und liegt dann bei allen am Bus ange-
schlossenen Geräten an (3).
Als nächstes legt der Prozessor die zu schreibenden Daten (4) auf den Daten-Bus (5), so dass auch
diese an allen am Bus angeschlossenen Geräten anliegen (6).

Jedes der am Bus angeschlossenen Geräte überprüft nun, ob es für die auf dem Adress-Bus anlie-
gende Adresse (3) zuständig ist (7). In unserem Beispiel erkennen die Geräte 1, 3 und 4, dass sie
nicht für die am Adress-Bus anliegende Adresse zuständig sind, weshalb sie nichts unternehmen (8).

60
Gerät 2 erkennt jedoch, das die am Bus anliegende Adresse von ihm selber verwendet wird (9) und
bereitet sich darauf vor, die am Datenbus anliegenden Daten zu übernehmen.

Sobald der Prozessor das Übernahme-Signal (10) generiert und es über die Steuerleitung Schreiben
(11) an die am Bus angeschlossenen Geräte gelangt, übernimmt Gerät 2 die am Datenbus anliegen-
den Daten in seine durch 0110 adressierte Speicherstelle (12).

Das Lesen von Daten aus am Bus angeschlossenen Geräten funktioniert sehr ähnlich:

Adress-Bus: 2
1
Bit 3 Gerät 1
0
3 4
1 0110 Adresse ==
Bit 2 0 meine?
ja nein
1 5
Bit 1
0

1
Bit 0 0

Gerät 2
3 4
0110 Adresse ==
Daten-Bus: 10 meine?
1010 ja 6 nein
1
1 0110 Bit 3
0
9
Bus 1010
12 1010
1
7 Bit 2 0
11
Bit 1
1 Gerät 3
0
3 4
1 0110 Adresse ==
Bit 0 meine?
0 ja nein
5

Steuer-Bus:
8 11
Lesen
1
Gerät 4
0
3 4
0110 Adresse ==
1
Schreiben meine?
0 ja nein
t 5

Prozessor liest
Daten aus der
Speicherstelle
0110 eines ex- Bus besteht aus Adress-, Pegel auf den Busleitungen Am Bus angeschlossene Ge-
ternen Geräts Daten- und Steuer-Bus. in Abhängigkeit der Zeit. räte überprüfen die Adresse
ein. und legen ggf. die Daten auf
den Bus.
Abb. 72: Einlesen von Daten von einem am Bus angeschlossenen Gerät (z.B. Daten vom DVD-ROM)

Zuerst legt der Prozessor die Adresse, von der er etwas einlesen will, auf den Bus (1). Die Adresse
wird über den Bus übertragen (2) und liegt dann an allen am Bus angeschlossenen Geräten an (3).

Jedes Gerät überprüft nun, ob es für diese Adresse zuständig ist (4). In obiger Abbildung sind wieder
die Geräte 1, 3 und 4 nicht für die am Bus befindliche Adresse zuständig und ignorieren somit die
Anfrage (5). Gerät 2 erkennt, dass es für die am Bus anliegende Adresse zuständig ist (6) und macht
sich für weitere Schritte bereit.

Um den Datentransfer einzuleiten, legt der Prozessor eine fallende Flanke (7) auf die Steuerleitung
Lesen. Die Flanke wird vom Bus übertragen (8) und dann von den Geräten detektiert. Sobald das
Gerät 2 die fallende Flanke erkennt, legt es die an der Adresse 0110 gespeicherten Daten auf den
Datenbus (9), über den sie dann übertragen werden (10) und schliesslich am Prozessor anliegen. Mit
der auf die fallende Flanke folgenden steigenden Flanke (11) übernimmt der Prozessor die auf dem
Datenbus befindlichen Daten (12).

61
Nachdem wir nun wissen, wie der Prozessor Peripheriegeräte ansprechen kann, können wird das in
Abb. 69 auf Seite 57 gezeigte Bild wie nachfolgend angegeben erweitern:

Arbeitsspeicher

B4

C9 Bios-Programm
(Flash)
Bus
Bios-Daten
• (batteriegepuffert)
Prozessor (CPU) in C enthalten
• •
Peripherie:
A

• DL Diskettenlaufwerk

BR: Registerblock
• mit Registern • FP Festplatte
Steuerwerk/
Leitwerk •
DR
Rechenwerk/
ALU
• DB
CD-/DVD-Laufwerk

• C1 LAN, USB, FireWire

c:\>

Bildschirm

• GK
D5 Tastatur

Abb. 73: Vereinfachter Aufbau eines Computers

Der Prozessor ist über einen Bus mit der Aussenwelt verbunden. Der Bus dient als einziges Kommu-
nikationsmittel zwischen dem Prozessor und den restlichen Komponenten und wird (bis auf DMA-
Zugriffe) vom Prozessor gesteuert. Die restlichen Komponenten gliedern sich in drei Gruppen:

− Im Flash-Speicher-Chip (C9), der sich auf der Hauptplatine befindet, sind diejenigen Befehle
abgespeichert, die nach dem Start des Computers als erstes ausgeführt werden; man spricht
hier vom sog. BIOS (Basic Input Output System), da in diesem Chip Programme abgelegt sind,
die eine rudimentäre Ansteuerung von Ein- und Ausgabegeräten ermöglichen. Benutzerdefinier-
te Einstellungen, die beim Starten des Rechners durchgeführt werden sollen, sind dabei in ei-
nem batteriegepufferten RAM abgelegt, das bei unserem Computer im ICH5 (Input Output Con-
troller Hub der 5. Generation – das durch „C“ gekennzeichnete Bauelement) untergebracht ist.

− Der Arbeitsspeicher (B4) nimmt sowohl Daten als auch Befehle auf. In ihm stehen neben den
Programmen, die der Prozessor ausführt, auch die Daten, mit denen der Prozessor seine Be-
rechnungen anstellt.

− Die Peripherie dient zur Ein- und Ausgabe von Daten

62
+ zwischen Mensch und Maschine (Tastatur und Bildschirm).
+ zwischen Maschine und Maschine (Festplatte, CD, DVD, Diskette, LAN-Adapter, USB- oder
FireWire-Adapter).

Der gesamte Ablauf in einem Computersystem lässt sich damit im wesentlichen auf drei Schritte zu-
rückführen:

− Der Prozessor liest Daten aus dem Speicher oder einem Peripherie-Gerät ein.
− Der Prozessor verarbeitet diese Daten oder führt sie als Programm aus.
− Der Prozessor speichert verarbeitete Daten ab oder schickt sie an ein Peripherie-Gerät.

Wenn wir unseren Computer einschalten, beginnt der Prozessor automatisch damit, Befehle aus einer
bestimmten Speicheradresse zu holen und dann als Programm auszuführen. Diese allererste Spei-
cheradresse liegt im Hauptplatinen-BIOS. Der Prozessor führt also zunächst Befehle aus, die in dem
auf der Hauptplatine aufgelöteten Flash-Speicher abgelegt sind. Mit diesen Befehlen wird zunächst
die Hardware der Hauptplatine überprüft (POST = Power On Self Test).

Im Anschluss überprüft der Prozessor den Arbeitsspeicher auf Kapazität (Menge des verfügbaren
Speichers) und Funktionsfähigkeit.

Um die auf der Hauptplatine befindliche Hardware einzustellen, werden die im batteriebepufferten
BIOS-Daten-RAM gespeicherten Einstellungen ausgelesen, verarbeitet und die Ergebnisse dann auf
bestimmte Speicheradressen geschrieben, die auf Befehls- und Daten-Register des Chipssatzes zei-
gen. Auf diese Weise werden im Chipsatz z.B. Einstellungen für das Ansprechen des Arbeitsspeichers
(Verzögerungszeiten etc.) oder für die Zugriffsweise auf den PCI-Bus getätigt.

Die Ausführung des im BIOS abgelegten Codes sorgt auch dafür, dass die BIOS-Bausteine der
Steckkarten und Peripherie-Geräte ausgelesen werden und der dort abgelegte Befehlscode vom Pro-
zessor teilweise ausgeführt wird. Bei der Ausführung dieses Codes werden dann die zugehörigen
Steckkarten bzw. Peripherie-Geräte initialisiert. Dazu schreibt der Prozessor wieder Daten an Adres-
sen, die auf Speicherstellen in den Steckkarten (z.B. Grafikkarte) bzw. in den Peripherie-Geräten ver-
weisen. Diese Daten werden von den entsprechenden Geräten dann als Befehle interpretiert und
ausgeführt, was beispielsweise zu einer Grund-Einstellung der Grafikkarte führt.
Desweiteren werden aus den BIOS-Bausteinen rudimentäre Treiber für die zugehörigen Steckkarten
bzw. Geräte ausgelesen und im Arbeitsspeicher abgelegt. Der Begriff „rudimentär“ meint dabei, dass
die Treiber einen sehr eingeschränkten Funktionsumfang aufweisen und lediglich dafür Sorge tragen,
dass beim Starten des PCs die betreffenden Geräte in ihrer Grundfunktionalität verwendet werden
können.
Sollen beim Starten des Computers Funktionen einer Steckkarte ausgeführt werden, verzweigt der
Programmfluss in den Treiber, der dann die Kommunikation mit der Karte übernimmt, ihr die durchzu-
führende Aktion mitteilt und evtl. ein Ergebnis zurückliefert. Beispielsweise ermöglicht der Treiber des
Grafikkarten-BIOS, Text und einfache Grafik-Ausgaben auf dem Bildschirm auszugeben, was zur
Überwachung des PC-Startvorgangs vollkommen ausreichend ist. Erst beim Laden des Betriebssys-
tems werden von der Festplatte dann die „richtigen“ Treiber für die Grafikkarte geladen, mit denen sich
das volle Leistungsspektrum der Grafikkarte ausschöpfen lässt.
8
Da es wesentlich günstiger ist, Treiber von der Festplatte zu laden, als jede Steckkarte bzw. jedes
Gerät mit einem Flash-Speicherchip auszurüsten, verfügen nur diejenigen Steckkarten/Geräte über
einen BIOS-Chip, die bereits beim Booten des Rechners funktionieren müssen:

− Grafikkarten, da diese evtl. Fehlermeldungen auf dem Bildschirm ausgeben müssen.


− Netzwerkkarten, da der Rechner evtl. über das Netzwerk gestartet werden soll, der sog. Boot-
loader (s. u.) sich somit auf einem anderen Rechner befindet und erst über die Netzwerkkarte in
den Arbeitsspeicher geladen werden muss.

8
Zum Einen ist es preislich günstiger, da Speicherplatz auf einem Flash-Speicher wesentlich teuerer ist als Speicherplatz auf
einer Festplatte. Zum Anderen ist es bei einem Treiber-Update wesentlich einfacher, eine Datei aus dem Internet herunterzula-
den und in einem bestimmten Ordner abzulegen, als den Flash-Speicher neu zu programmieren.

63
Nach dem Laden/Ausführen der BIOS-Routinen der Steckkarten sorgt das im Hauptplatinen-BIOS
abgelegte Programm dafür, dass an die Festplatte Daten geschickt werden, die von dieser als Befehle
zur Adressierung des Bootrecords (Zylinder 0, Kopf 0 und Sektor 1 der ersten IDE-Festplatte) erkannt
werden. Im Bootrecord steht der sog. Bootloader, das Programm, das das Betriebssystem von der
Festplatte in den Arbeitsspeicher lädt.

Ist der Bootloader gefunden, sorgt das BIOS-Programm dafür, dass der Bootloader in den Arbeits-
speicher geladen und dann vom Prozessor ausgeführt wird. Die Kontrolle geht in diesem Moment vom
BIOS-Programm an den Bootloader über, der zunächst die Festplatte nach einem gültigen Betriebs-
system durchsucht und den Programmcode des Betriebssystems dann ebenfalls in den Arbeitsspei-
cher lädt und dann vom Prozessor ausführen lässt. Jetzt geht die Kontrolle vollständig an das Be-
triebssystem über, das der Reihe nach immer mehr Daten von der Festplatte in den Arbeitsspeicher
lädt und dann als Programm ausführt. Dabei werden neben Betriebssystem-Code insbesondere auch
die auf der Festplatte gespeicherten Treiber der Peripherie-Geräte in den Arbeitsspeicher geladen
(und z.T. ausgeführt), so dass die am PC angeschlossenen Geräte über diese Treiber-Schnittstelle
angesprochen/verwendet werden können.

Aber nicht nur beim Starten des PCs dreht sich alles darum, dass der Prozessor Daten aus dem Ar-
beitsspeicher oder den Peripherie-Geräten einliest, verarbeitet (oder ausführt) und dann wieder aus-
gibt:

Wir haben zuvor gesehen, dass die ganze Darstellung des Bildschirminhalts darauf basiert, dass der
Prozessor Daten in den Video-Speicher der Grafikkarte schreibt.
Drückt man eine Taste auf der Tastatur wird dies dem Prozessor gemeldet und über den Bus wird
dann der Wert der gedrückten Taste ausgelesen.
Beim Bewegen der Maus wird dem Prozessor über den Bus mitgeteilt, um wieviele Längeneinheiten
die Maus nach links/rechts bzw. vorne/hinten bewegt wurde. Der Prozessor berechnet dann aus die-
ser Information die neue Position des Maus-Cursors, rendert im Arbeitsspeicher die neue Bildschirm-
ansicht, die den verschobenen Mauszeiger darstellt und überträgt dieses Bild dann wieder in den Vi-
deo-Speicher der Grafikkarte.

Da sich im PC also alles nur darum dreht, Daten von einem Ort zum anderen zu transportieren, ist
auch die Architektur eines PCs auf genau diesen Zweck ausgelegt.

Die auf der nächsten Seite noch einmal abgebildete Rechner-Architektur entspricht der realen Imple-
mentierung der in Abb. 73 auf Seite 62 gezeigten stark vereinfachten Rechner-Architektur.

Die Unterschiede sind klar erkennbar:

In unserem vereinfachten Modell (Abb. 73) sind alle Komponenten direkt an den Prozessor ange-
schlossen. Es gibt nur einen Bus, über den alle Komponenten und Peripherie-Geräte miteinander und
mit dem Prozessor verbunden sind. Unabhängig davon, wie schnell die einzelnen Geräte Daten ver-
arbeiten oder übertragen können. So ein System wäre prinzipiell lauffähig, aber sehr langsam, da die
langsamen Geräte am Bus die schnellen ausbremsen.

Die reale Rechner-Architektur aus Abb. 74 verwendet mehrere verschiedene Busse, die unterschied-
lich schnell sind und über sog. Bridges miteinander verbunden sind. Die englische Bezeichnung
Bridge trifft die Funktion dieser Bausteine auf den Kopf: Bridges sind Brücken, die verschiedene Bus-
syteme miteinander verbinden. Dabei werden die Daten, die über den sehr schnellen FSB mit dem
9
spezifischen FSB-Protokoll an den GMCH geschickt werden und nicht für ein direkt mit dem GMCH
verbundenes Gerät bestimmt sind, in das Bus-Protokoll des etwas langsameren HI-Busses gepackt
und dann an den ICH5 übertragen. Sind die Daten auch für keine direkt im ICH5 integrierte Kompo-
nente gedacht, werden die Daten in das entsprechend nächste Protokoll gepackt und dann auf dem
entsprechenden Bus weitergeschickt. Beispielsweise werden die mit dem HI-Protokoll an den ICH5
gelieferten Daten in das PCI-Bus-Protokoll eingebettet und dann über den PCI-Bus an eine Steckkarte
geschickt. Der auf der Steckkarte befindliche Controller entpackt die Daten dann wieder aus dem PCI-
Protokoll und verarbeitet sie.

9
Unter einem Bus-Protokoll versteht man die Regeln, nach denen die Kommunikation über den Bus abläuft. Beispiele für sol-
che Regeln sind: Zuerst legt der Sender die Adresse für mindestens 20 ms auf den Adress-Bus. 5 ms, nachdem die Adresse
am Bus anliegt, folgt ein fallender Pegel auf der Lesen-Leitung...

64
Die gesamte Rechner-Architektur ist also gekennzeichnet durch ein von Bridges aufgespanntes Ver-
bindungsnetzwerk, dessen Übertragungsrate höher wird, je näher man dem Prozessor kommt und
niedriger wird, je weiter man sich vom Prozessor entfernt.

A
Prozessor

NT Rechen- Steuer-
Werk Werk
230 V ~ Netzteil Adress-Umsetzer
Befehls- Daten-
Cache Cache
FSB Logik/Treiber
Prozessor-Bus
FS (Front Side Bus)
B
TFT- GMCH
Bildschirm
B1
DVI Analoger VGA- Grafik-
Anschluss Controller B4
DDR-RAM
B2
AGP- DDR-RAM
Grafikkarte AGP-Port Kanal A DDR-RAM B4
2,1 GByte/s Controller Controller 3,2 GyteB/s
GK
B4
Gigabit-Ethernet- CSA- DDR-RAM
Controller Controller
B3 266 MByte/s Kanal B DDR-RAM B4
HI Controller 3,2 GByte/s
1 GBit/s
HI = Hub Interface
HI 266 MByte/s
LA
LAN- C
Anschluss
ICH
C6
Takt-Generator
100 MBit/s Ethernet- System- CPU, PCI, …
Controller Managmnt.

C1 Anschlüsse 480 MBit/s USB2.0- PCI- C7


6 PCI-Slots FireWire-
für USB 2.0 Controller Controller PCI-Bus Adapter
FP 133 MByte/s FW
C2
2 Anschlüsse 150 MByte/s 2 SATA- CMOS-
C8
Festplatte Batterie
für Serial-ATA Controller RAM

DR C3 100 MByte/s
DVD- 2 Anschlüsse ATA Bios-interf.
Flash-Bios C9
ROM für ATA Controller Controller

DVD- Audio SMBus SMBus 2.0/


Audio-Codec
Brenner C4 Controller Controller I2C-Bus
DB
LPC-interface
Controller

LPC-Interface
(Low Pin Count)
D
Super
Input/Output
Controller
D4 DL
D1 Anschluss für RS 232 Floppy Anschluss Dis- Disketten-
seriellen Port Controller Controller ketten-Laufwerk Laufwerk

D2 Anschluss für LPT Tastatur PS/2 Anschluss D5


Tastatur Tastatur
parallelen Port Controller Controller

Anschluss für Drehzahl- Maus PS/2 Anschluss


D3 Ventilator regelung Controller Maus Maus
D6

Abb. 74: Architektur eines Computers

65
Im Folgenden sind die Funktionen der Haupt-Bridges stichpunktartig zusammengestellt.

10
• GMCH = Graphics and Memory Controller Hub (B)
− ist direkt am Prozessor angeschlossen ⇒ „Datenverteiler“ für sehr schnelle Geräte
− führt für den Prozessor Zugriffe auf den Arbeitsspeicher (engl. Memory, hier: DDR-RAM) aus
− verfügt über einen integrierten Grafik-Controller (eine integrierte Grafik-„Karte“), mit der der Pro-
zessor Bilder auf einem Monitor ausgeben kann ⇒ Begriff „Graphics“ in GMCH
− kann externe Grafikkarten über den AGP-Port ansprechen, so dass der Prozessor Bilder auch
auf diesem Weg auf einem Monitor ausgeben kann ⇒ Begriff „Graphics“ in GMCH
− bietet eine Anschlussmöglichkeit für einen Gigabit-Ethernet-Controller, über den der Prozessor
Daten mit bis zu 1 GBit/s über ein Netzwerk übertragen kann
− kann vom Prozessor konfiguriert (eingestellt) werden
− früher auch Northbridge genannt (North, da „oben beim Prozessor“ und Bridge, da Verbindung
zwischen zwei Bussen [Brückenfunktion])

• ICH = Input/Output Controller Hub (C)


− „Datenverteiler“ für mittel schnelle bis schnelle Geräte
11 12
− verfügt über diverse Ein- und Ausgabe-Controller, insbesondere für PCI und IDE
− internes batteriegepuffertes RAM zur Sicherung von Konfigurationsdaten (z.B. BIOS-
Einstellungen)
− bietet Anschlussmöglichkeit für den Flash-BIOS-Chip, der den System-Startup-Code enthält
− früher auch Southbridge genannt, (South, da unterhalb der Northbridge und Bridge, da Brü-
ckenfunktion zwischen verschiedenen Bussen)

• SIO-Controller = Super Input/Output Controller (D)


− „Datenverteiler“ für langsame Geräte
− verfügt insbesondere über die Controller für serielle/parallele Schnittstellen, Floppy, Tastatur
und Maus

10
Controller = aktive Komponente, die andere Elemente steuert (engl. to control = steuern).
11
PCI = Peripheral Component Interconnect: Standardisierter Peripheriebus ⇒ Peripherie-Geräte (z.B. Erweiterungskarten)
werden nicht direkt an den Prozessor oder den FSB angeschlossen, sondern über den standardisierten PCI-Bus. Der grosse
Vorteil besteht darin, dass bereits angeschaffte Peripherie-Geräte auch über mehrere Prozessorgenerationen hin verwendet
werden können. Bei der Entwicklung neuer Prozessoren, die evtl. auch über einen geänderten FSB verfügen, muss dann nur
ein neuer GMCH bzw. ICH eingesetzt werden, der aus den neuen FSB-Signalen dann wieder die standardisierten PCI-Signale
erzeugt. Die ganzen Peripherie-Geräte können dann trotz geändertem FSB weiterhin am (standardisierten) PCI-Bus betrieben
werden.
12
IDE = Integrated Drive Electronics: Standardisierte Schnittstelle zum Anschluss von Festplattenlaufwerken (sowie CD, DVD
etc.). Der Name „Intergrated Drive Electronics“ begründet sich darin, dass Festplatten vor IDE-Zeiten über keine eigenen Con-
troller-Chip verfügten, also direkt vom Prozessor gesteuert wurden. Mit der Einführung von IDE wurden die Steueraufgaben der
Festplatte (z.B. Kopfpositionierung) von einer im Festplattengehäuse untergebrachten Steuerelektronik (dem Controller) erle-
digt, was zu einer starken Entlastung des Hauptprozessors führte. Durch die Standardisierung von IDE und der Entkoppelung
vom Prozessor/FSB ergeben sich die selben Vorteile wie beim PCI-Bus.

66
1.2 Von Neumann-Architektur
Die Architektur unseres Rechners geht unter anderem auf den Mathematiker John von Neumann zu-
rück, weswegen sie auch von Neumann-Architektur genannt wird.

John von Neumann wurde 1903 in Budapest/Ungarn geboren, wo er als Sohn des Bankiers Max
Neumann aufwuchs. Da John von Neumanns Vater Max Neumann im Budapest zu Beginn des 19. Jh.
zu einer bedeutenden Figur geworden war (Adelstitel als Ehrung) und die Angewohnheit hatte, aus-
gewählte Kunden seiner Bank zu sich nach Hause zum Abendessen einzuladen und seiner Familie
auch Proben oder Modelle neuer industrieller Unternehmungen, die er finanzierte, mit nach Hause
brachte, erfuhr John von Neumann schon sehr früh von Joseph-Marie Jacquard, dessen Lochkarten-
betriebene Webstühle in Abhängigkeit der Codierung der Lochkarte jedes beliebige Muster weben
konnte. Dieser Webstuhl kann als der erste Computer angesehen werden.

John von Neumann war ein Wunderkind. Bereits zu Schulzeiten konnte ihm kein Mitschüler auch nur
annähernd das Wasser reichen. Während seine Kameraden auf dem Pausenhof spielten, stand der
kleine Johnny eher abseits und analysierte das Verhalten seiner Mitschüler. Sein Vater förderte ihn,
indem er Professoren anstellte, die Johnny nach der Schule daheim unterrichteten.

Johnny wollte Mathematiker werden, doch sein Vater drängte ihn, in Berlin Chemieingenieur zu studie-
ren, da diesem Beruf gute Zukunftsaussichten nachgesagt wurden. Johnny entschloss sich schließlich
für einen ehrgeizigen Kompromiss, der ihn zum Einen absicherte, zum Anderen aber auch alle Karrie-
re-Chancen offen ließ: Noch bevor er sich für das Studium als Chemieingenieur einschrieb, schrieb er
sich an der Universität Budapest als Doktorand in Mathematik ein. Er hatte vor, als Student und Dok-
torand gleichzeitig zu arbeiten – und zwar in zwei mehreren hundert Kilometer auseinanderliegenden
Städten. Um diese Unverfrohrenheit auf die Spitze zu treiben, wollte der damals 17-jährige Gymnasi-
ast in seiner Doktorarbeit die Axiomatisierung der Mengenlehre Georg Cantors versuchen – das strit-
tigste Themen der zeitgenössischen Mathematik, das bereits einige berühmte Professoren aufs Glatt-
eis geführt hatte. Das Studium als Chemieingenieur in Berlin sah John von Neumann eher als lästige
Nebentätigkeit an, weshalb er es auch nach zwei Jahren ohne Abschluss beendete und dafür im
Herbst 1923 die Aufnahmeprüfung für das zweite Jahr des Vierjahreskurses „Chemieingenieur“ an der
13
rennomierten ETH (Eidgenössische Technische Hochschule) Zürich bestand.

John von Neumann hatte eine aussergewöhnliche Begabung: Er konnte sich sehr schnell in fremde
Thematiken einlesen und dann die in diesem Bereich tätigen Forscher mit seinem Wissen meilenweit
überholen.

Abb. 75: John von Neumann

13
Albert Einstein – mit dem John von Neumann später in Princeton zusammenarbeitete – versagte 1895 bei der Aufnahmeprü-
fung der ETH, woraufhin er eine Stelle im Berner Patentamt annahm. Dort entwickelte er dann die Spezielle Relativitätstherorie.

67
Das gelang ihm auch in nicht technischen Disziplinen: Er leistete mit seinem Buch über Spieltheorie
und der Niederschrift zu seinem Vortrag „Über gewisse Gleichungen in der Ökonomie und eine Verall-
gemeinerung von Brouwers Fixpunkt-Theorem“ wichtigste Beiträge zu den Wirtschaftswissenschaften.
Ende der 1980er Jahre wurde die genannte Niederschrift von berühmten Wirtschaftswissenschaftlern
als „der wichtigste Artikel auf dem Gebiet der mathematischen Ökonomie, der jemals geschrieben
wurde“ bezeichnet.

John von Neumanns Beiträge zur Computertechnik liegen insbesondere in der Programmierbarkeit
von Computern. Bevor John von Neumann die Computertechnik revolutionierte, waren Computer da-
rauf ausgerichtet, die Lösung für ein ganz bestimmtes Problem zu berechnen. Die Computer wurden
damals „programmiert“, indem die Kabelverbindungen zwischen den Komponenten des Computers
geändert wurden. John von Neumann erinnerte sich an die in seiner Kindheit kennengelernten Web-
stühle von Joseph-Marie Jacquard, die in Abhängigkeit einer Lochkarte jedes beliebige Muster weben
konnten und übertrug dieses Prinzip auf die von Eckert und Mauchly am IAS (Institute for Advanced
Studies) in Princeton gebauten festverdrahteten Rechner. Seitdem konnten Rechner in Abhängigkeit
von Lochkarten unterschiedliche Programme ausführen. Die Rechner waren damit nicht mehr auf ein
bestimmtes Problem zugeschnitten, sondern universell verwendbar. Das aufwendigen Umstecken von
Verbindungskabeln wich der Programmierung durch Lochkarten. Es waren keine Änderungen an der
Verkabelung der Rechner mehr nötig. Der Aufbau des Rechners war plötzlich unabhängig vom zu
lösenden Problem geworden.

Die Befehle auf den Lochkarten waren alle immer nach dem selben Prinzip aufgebaut. Anders als bei
der deutschen Sprache war der Sinn der einzelnen Befehle nicht vom Kontext abhängig, in dem der
Befehl stand. Betrachtet man beispielsweise im Satz „Fliegen ist schön.“ lediglich das erste Wort
„Fliegen“, so kann man nicht sagen, ob damit das Verb „fliegen“ gemeint ist, oder der Plural von „die
Fliege“. Man erkennt erst am zweiten Wort („ist“ und nicht „sind“), dass nicht über schöne Insekten,
sondern über die Fortbewegung in der Luft geredet wird.

Als John von Neumann vor dem Problem stand, Computerbefehle in einer Sprache zu formulieren, die
keine Mehrdeutigkeiten der gezeigten Art aufweist, kam ihm der Lateinunterricht zugute, den er auf
dem Lutheraner-Gymnasium in Budapest genossen hatte: Er übertrug die klare Regelmäßigkeit der
Lateinischen Sprache (z.B. Verb steht fast immer am Satzende) auf Computerbefehle und legte damit
das erste Befehlsformat der Welt fest.

(Die Befehle des MMIX-Prozessors, den wir im Laufe der Vorlesung noch kennenlernen werden, hat
ein äußerst regelmäßiges Befehlsformat: Das erste Byte ist immer der Befehl, die nächsten drei Byte
sind immer die Operanden.)

John von Neumann schlug vor, den von Eckert und Mauchly am IAS gebauten Computer um die Pro-
grammierbarkeit in einer kontextfreien Sprache zu erweitern. Nachdem er den Vorschlag schriftlich
festgehalten hatte, verschickte ein Kollege diesen Vorschlag als Publikation. Da von Neumann diesen
Vorschlag jedoch nur für interne Zwecke am IAS gedacht hatte, fehlten auf ihm die Namen von Eckert
und Mauchly, auf deren Computer sich die Erweiterungen bezogen. John von Neumann wurden somit
fälschlicherweise Ehren zugesprochen, die eigentlich Eckert und Machly zugestanden hätten, da der
von Eckert und Mauchly entwickelte Computer von aller Welt nun als von Neumanns Werk angesehen
wurde. Das ging soweit, dass die Rechner, die in Folge der „von Neumann-Veröffentlichung“ gebaut
wurden und in groben Zügen immer noch der Architektur unserer heutigen Rechner entsprechen, von
Neumann-Architektur genannt werden.

68
Der in der von Neumann-Veröffentlichung beschriebene Rechner hatte vier Funktionseinheiten, die bis
in unsere heutige Zeit als Rechnerkomponenten erhalten geblieben sind.

Speicher für Daten und Befehle

Ein- und
Registerblock c:\>

mit Registern Ausgabe


Steuerwerk/
Leitwerk
Rechenwerk/
ALU
Prozessor

Abb. 76: von Neumann-Architektur

− Das Rechenwerk verknüpft die Operanden, indem es Operationen auf sie anwendet. Beispiele
hierfür sind die vier Grundrechenarten (Addition, Subtraktion, Multiplikation und Division) und
Schiebeoperationen (links schieben/rechts schieben). Allein mit den vier Grundrechenarten las-
sen sich auch die kompliziertesten Formeln und Funktionen berechnen. Beispiele hierfür sind
die Verwendung von Potenzreihen zur Berechnung von Sinus und Cosinus:

x3 x5 x7 x2n+1
sin x = x − + − + ... + (−1)n ⋅ + ...
3! 5! 7! (2n + 1)!

− Im Speicher stehen sowohl die Befehle, als auch die Operanden/Daten. Beide sind als Zahlen
codiert. Bei einem Blick in den Speicher kann man somit keinen Unterschied zwischen Befehlen
und Operanden/Daten erkennen. Dass eine Bitfolge ein Befehl ist, erkennt man erst dann, wenn
sie vom Steuerwerk in das Befehlsregister geladen und dann ausgeführt worden ist.

− Das Steuerwerk steuert den Ablauf im Prozessor/Rechner. Es lädt die Befehle aus dem Spei-
cher, analysiert sie, lädt die entsprechenden Operanden aus oder in den Speicher, teilt dem
Rechenwerk mit, welche Operation es ausführen soll und leitet das Ergebnis wieder an die ge-
wünschte Stelle.

− Das Ein- und Ausgabewerk (E/A-Werk) ist die Schnittstelle zwischen Rechner und Peripherie-
Gerät, zu von Neumanns Zeit also die Anbindung des Rechners an den Lochkartenleser. Im
letzten Abschnitt haben wir gesehen, dass bei unseren weiterentwickelten von Neumann-
Architekturen das Ein- Ausgabewerk über verschiedene Bussysteme auf mehrere Chips
(GMCH, ICH, SIO) verteilt ist. Die Funktion ist prinzipiell aber noch genau die gleiche.

Zu vier genannten klassischen Funktionseinheiten ist später noch der Bus dazugekommen, der somit
nicht zu den original von Neumannschen Funktionseinheiten gehört.

69
Im Folgenden sind einige für von Neumann-Maschinen typische Merkmale aufgeführt:

− Der Aufbau des Rechners ist unabhängig vom Problem. Durch Laden eines bestimmten Pro-
gramms in den Speicher kann der Rechner zu Lösung jedes beliebigen Problems verwendet
werden. Die Hardware (z.B. Verbindungsleitungen) muss also nicht mehr auf die jeweilige Prob-
lemstellung angepasst werden.

− Alle Daten (nicht nur die Operanden, sondern auch die Adressen und insbesondere auch die
Befehle) werden als Zahlen binär kodiert und im Speicher abgelegt. Der Speicher besteht dabei
aus gleich grossen, durchnumerierten Zellen.

− Die zu einem Programm gehörigen Befehle stehen sequentiell (einer nach dem anderen) im
Speicher und werden der Reihe nach ausgeführt. Lediglich bei Sprüngen findet eine Verzwei-
gung statt.
14
Da von Neumann auf eine Patentierung seiner Erweiterungen verzichtete , konnte jede Forschungs-
anstalt/Firma ohne Lizenzgebühren auf diesen Erweiterungen aufbauen und sie weiter vorantreiben.
Es war genau dieser Sachverhalt, der sich als sehr fruchtbarer Boden für Weiterentwicklungen erwies
und damit zum Siegeszug der von Neumann-Architektur führte.

14
Eckert und Mauchly hatten hingegen vor, ihren Rechner als Patent anzumelden, was spätestens dann zum Scheitern verur-
teilt war, nachdem die von Neumann-Erweiterungen (unauthorisiert) publiziert wurden.

70
1.3 Harvard-Architektur
Der gemeinsame Speicher für Programme und Daten macht die Entwicklung und den Test von Pro-
grammen auf einer von Neumann-Architektur sehr einfach: Man schreibt in einem Texteditor ein Pro-
gramm, übersetzt es in Maschinencode und kann es dann sofort ausführen. Während des Vorgangs
des Übersetzens sind die Befehle des generierten Maschinencodes die Daten, die das Übersetzungs-
programm erzeugt. Diese Daten werden erst zu einem Programm, wenn sie vom Prozessor in das
Befehlsregister geladen werden und dann ausgeführt werden. Da Daten und Programme nicht unter-
scheidbar im selben Speicher liegen, bedeutet es keinen zusätzlichen Aufwand, Daten als Programm
auszuführen.

Es ergibt sich jedoch auch ein Nachteil: Da Programme und Daten im selben Speicher liegen, müssen
beide über den gleichen Bus zum Prozessor transportiert werden. Während ein Befehl vom Speicher
in den Prozessor geladen wird, kann nicht gleichzeitig ein Datum aus dem Speicher gelesen oder in
den Speicher geschrieben werden. Befehle und Daten behindern sich somit gegenseitig, was insbe-
sondere Programme mit hohem Datenvolumen (z.B. Videodecoder) ausbremst.

Abhilfe kann hier eine Architektur schaffen, bei der Daten und Befehle in separaten Speichern stehen:
Die sog. Harvard-Architektur.

Speicher für Daten

Prozessor
Ein- und
Registerblock c:\>

mit Registern Ausgabe


Steuerwerk/
Leitwerk
Rechenwerk/
ALU

Speicher für Befehle

Abb. 77: Harvard-Architektur

Da Daten- und Befehlsspeicher bei dieser Architektur getrennt sind, können sie über separate Busse
an den Prozessor angebunden werden. Somit kann gleichzeitig auf Befehle und Daten zugegriffen
werden, was insbesondere die Ausführung von Programmen mit hohem Datenverkehr beschleunigt.
Da solche Programme (z.B. ein Videodecoder in einer Set-Top-Box) besonders oft auf spezialisierten
Signalprozessoren ablaufen, verfügen Digitale Signalprozessoren (DSPs) ebenso wie Mikrocontrol-
15
ler häufig über eine Harvard-Architektur. Programme für DSPs und Mikrocontroller werden in der
Regel auf einem gewöhnlichen PC entwickelt (Cross-Plattform) und dann in den Befehls-Speicher des
Prozessors geladen. Da es zeitlich keinen Unterschied macht, ob die Befehle vom PC aus in den Da-
ten- oder den Befehls-Speicher eines Signalprozessors geladen werden, hat die Verwendung einer
16
Harvard-Architektur für Embedded-Prozessoren keine Nachteile. Bei der Verwendung einer Harvard-
Architektur als PC-Prozessor hingegen müsste nach der Übersetzung eines Programms der Pro-
grammcode erst vom Daten- in den Befehlsspeicher kopiert werden, was die Programmentwicklung
verlangsamen und umständlich machen würde.

15
Mikrocontroller sind Mikroprozessoren, die über zusätzliche Peripherie auf dem Chip (z.B. Ein- und Ausgabe-Ports, A/D-
Wandler, Timer, Befehls- und Datenspeicher) verfügen. Mikrocontroller werden im Embedded-Bereich beispielsweise zur Steue-
rung von Waschmaschinen, Kochfeldern etc. verwendet.
16
Unter Embedded-Prozessoren bzw. Prozessoren für den Embedded-Bereich versteht man Prozessoren, die nicht in PCs,
sondern in anderen eigenständigen Geräten wie beispielsweise einer Mikrowelle, einer Waschmaschine oder einem DVD-
Player integriert (eingebettet) sind.

71
1.4 Vom Algorithmus zum Prozessor – Abstraktionsebenen

Nachdem wir bisher nur den Aufbau und die Architektur von Rechnern untersucht haben, betrachten
wir ab diesem Abschnitt, wie dieser Rechner zur Lösung von Problemen eingesetzt werden kann.

Nachfolgende Abbildung dient uns dabei als Wegweiser durch die nächsten Kapitel.

i = n, x = 0

Grundl. d. Informatik
i>0 Problemlösung
Algorithmus-Ebene in Algorithmus-
x = x + aibi
i =i–1 Form

Übersetzung durch
den Menschen
Problemlösung
Hochsprachen-Ebene *.c *.c in Hochsprache
Beim Entwurf

(z.B. C)
Übersetzung Com-
durch Compiler piler
Maschinen-
Assembler-Ebene *.asm *.asm nahe Form der

Computertechnik/Computersysteme
Problemlösung
Übersetzung Assem-
durch Assembler bler
Biblio-
thek *.obj *.obj
*.obj Maschinencode
Befehlssatz-Ebene Linker Linker der Problem-
lösung

*.exe

Interpretation oder Inter-


direkte Ausführung pretation
durch die Hardware Aufbau des
Hardware- Mikro- Problemlösers
Mikroarchitektur-Ebene (Rechner/Pro-
Steuerung programm
zessor) aus
Elektr. Speicher, ALU …
Steuerung
Signale
Aufbau von
Speicher, ALU..
Zur Laufzeit

Ebene der digitalen Logik Gatter/Hardware


aus Logik-
Gattern
Integr. Schaltungen

Aufbau von
Logik-Gattern
Transistor-Ebene Transistoren
aus Tran-
sistoren

Aufbau von
Transistoren
Layout-Ebene Halbleiter-Strukturen
aus n- und p-
Schichten

Abb. 78: Abstraktionsebenen

72
Die Abbildung zeigt im oberen Teil, wie ein Problem abstrakt dargestellt (Algorithmus-Ebene) und
dann von einem Programmierer in einer Hochsprache wie z.B. der Programmiersprache C (Hochspra-
chen-Ebene) formuliert werden kann.

Aufgabe der Algorithmus-Ebene ist es, Informationen und Anweisungen, die zur Lösung des betrach-
teten Problems notwendig sind, in einer einheitlichen Darstellung festzuhalten.

Beispiele für solche Darstellungen sind z.B. Lösungsformeln


2 3
b1
⇥ ⇤ 6 b2 7
6
7
x = a1 a2 . . . a n · 6 . 7 = a 1 · b1 + a 2 · b 2 + · · · + a n · b n
4 .. 5
bn
Abb. 79: Formel zur Berechnung eines Skalarprodukts

oder Diagramme.

i = n, x = 0
i>0
x = x + aibi
i =i–1

Abb. 80: Nassi-Shneiderman-Diagramm/Struktogramm

Ist die gewählte Darstellungsart hinreichend bekannt, kann sie zur Weitergabe von Informationen oder
Lösungsverfahren genutzt werden. Wenn Sie beispielsweise wissen, wie man die in Abb. 79 darge-
stellten Buchstaben, Zahlen (Indices) und Symbole interpretieren muss und zusätzlich über die Infor-
mation verfügen, dass die in Abb. 79 dargestellte Formel zur Berechnung von Skalarprodukten dient,
können sie automatisch auch Skalarprodukte berechnen.

Die Darstellungen auf der Algorithmus-Ebene dienen also zum Informationsaustausch zwischen Men-
schen.

Für Maschinen (Computer) sind diese Darstellungsarten zu abstrakt.

Ein Computer kommt mit einer Problem-Beschreibung auf Hochsprachen-Ebene wesentlich besser
zurecht. Das liegt insbesondere daran, dass bei der Entwicklung von Hochsprachen darauf geachtet
wurde, dass sie nicht nur vom Menschen (Programmierer), sondern auch vom Computer (Compiler)
gut verstanden werden kann. Eine Hochsprache ist also eine definierte Schnittstelle zwischen Mensch
und Maschine.
Nachfolgende Abbildung zeigt, wie ein Programmierer einen ihm als Nassi-Shneiderman-Diagramm
übermittelten Algorithmus in die Hochsprache C übersetzt.

i = n, x = 0
i>0
x = x + aibi
i =i–1

*.c *.c

Abb. 81: Übersetzen eines Algorithmus’ auf Hochsprachen-Ebene

73
Der vom Programmierer erzeugte Hochsprachen-Code kann beispielsweise wie folgt aussehen:

void main()
{
int w, x;
const int n = 4; // Vektordimension
int a[n]={1,2,3,4}, b[n]={10,20,30,40};

w = n;
x = 0;
while(w)
{
w = w - 1;
x = x + a[w] * b[w];
}
// in x steht jetzt der Wert des Skalarprodukts
}

Diese Darstellung ist für einen Menschen etwas schwieriger zu lesen als die Darstellung als Formel
oder Nassi-Shneiderman-Diagramm. Für eine Maschine ist diese Darstellung jedoch wesentlich ange-
nehmer, da sie beispielsweise nur aus ASCII-Zeichen besteht.

Hochsprachen sind aber keineswegs die „Muttersprache“ eines Computer, also keine Sprache, die
Computer direkt verstehen können. Hochsprachen sind ein Kompromiss zwischen „für den Menschen
verständlich“ und „für den Computer verständlich“. Damit ein Computer den Sinn von Hochsprachen-
Anweisungen verstehen kann, müssen diese in Maschinen-Code, die „Muttersprache der Computer“
übersetzt werden.

Dazu wird zunächst die Hochsprache mit Hilfe eines Compilers in Assembler-Befehle übersetzt.

Nachfolgende Abbildung zeigt den Ausschnitt aus Abb. 78, der in *.c-Dateien abgespeicherten C-
Quellcode in Assembler-Code übersetzt.

*.c *.c

Compiler

*.asm *.asm

Abb. 82: Compilation

Das entspricht einer Wandlung von Anweisungen der Hochsprachen-Ebene auf die Assembler-Ebene.

Die Darstellung auf der Assembler-Ebene hat dieselbe Struktur wie der zuvor als „Muttersprache der
Computer“ bezeichnete Maschinen-Code. Zusätzlich zu den vom Prozessor unterstützten Befehlen
findet man auf der Assembler-Ebene jedoch noch Anweisungen für den Assembler, also Anweisungen
für das Programm, das den Assembler-Code in Maschinen-Code übersetzt. Diese Anweisungen die-
nen zum Einen dazu, den Code lesbarer zu machen, zum Anderen, um festzulegen, wo im Speicher
das übersetzte Programm zur Ausführung abgelegt werden soll.

74
Im Folgenden ist der Assembler-Code des oben angegebenen C-Programms abgebildet.

LOC Data_Segment
GREG @

N OCTA 4 Vektordimension
ADR_A1 OCTA 1 a1
OCTA 2 a2
OCTA 3 a3
OCTA 4 a4
ADR_B1 OCTA 10 b1
OCTA 20 b2
OCTA 30 b3
OCTA 40 b4

u IS $1 Für Parameter 1
v IS $2 Für Parameter 2
w IS $3 Für Parameter 3
x IS $4 Für das Ergebnis
y IS $5 Für Zwischenberechnungen
z IS $6 Für Zwischenberechnungen

LOC #100
Main SETL x,0 Initialisierung
LDA u,ADR_A1 Referenz auf a1 in u speichern
LDA v,ADR_B1 Referenz auf b1 in v speichern
LDO w,N Vektordimension laden
MUL w,w,8 verwendete Worte haben 8 Byte
Start BZ w,Ende wenn fertig -> Ende
SUB w,w,8 w = w - 8
LDO y,u,w y = <u + w>
LDO z,v,w z = <v + w>
MUL y,y,z y = <u + w> * <v + w>
ADD x,x,y x = x + <u + w> * <v + w>
JMP Start

Ende TRAP 0,Halt,0 Ergebnis steht in x

Das Assembler-Programm ist wesentlich länger als das C-Programm. Das liegt daran, dass Hoch-
sprachen-Anweisungen wesentlich mächtiger sind (mehr „können“) als Assembler-Anweisungen. Aus
diesem Grund wird eine C-Anweisungen in mindestens eine, meist jedoch mehrere Assembler-
Anweisungen übersetzt.

Damit ein Prozessor Assembler-Anweisungen verstehen kann, müssen diese erst in Maschinen-Code
übersetzt werden, der dann in einer Programm-Datei abgelegt wird. Diese Aufgabe wird vom Assemb-
ler übernommen. Besteht ein Programm aus mehreren Programm-Dateien, müssen diese zusätzlich
von einem Linker zu einer einzigen Programm-Datei (unter Windows die *.exe-Datei) zusammenge-
fügt werden. Nachfolgende, der Abb. 78 entnommene Darstellung verdeutlicht diesen Vorgang.

75
*.asm *.asm

Assem-
bler
Biblio-
thek *.obj *.obj
*.obj
Linker Linker

*.exe

Abb. 83: Übergang von der Assembler- zur Befehlssatz-Ebene

In der ausführbaren Programmdatei stehen neben den Maschinen-Befehlen unter anderem auch An-
weisungen für das Betriebssystem (den Loader), der das Programm in den (Befehls-) Speicher lädt
und dann an einer bestimmten Stelle mit der Ausführung beginnt.

Nachfolgende Abbildung zeigt den Inhalt der zum oben angegebenen Assembler-Code gehörigen
Programmdatei.

98 09 01 01 3E B7 E8 DB 98 01 20 01 00 00 00 00
00 00 00 00 00 00 00 04 00 00 00 00 00 00 00 01
00 00 00 00 00 00 00 02 00 00 00 00 00 00 00 03
00 00 00 00 00 00 00 04 00 00 00 00 00 00 00 0A
00 00 00 00 00 00 00 14 00 00 00 00 00 00 00 1E
00 00 00 00 00 00 00 28 98 01 00 01 00 00 01 00
98 06 00 03 73 6B 61 6C 70 72 6F 64 2E 6D 6D 73
98 07 00 18 E3 04 00 00 23 01 FE 08 23 02 FE 28
8D 03 FE 00 19 03 03 08 42 03 00 00 25 03 03 08
8C 05 01 03 8C 06 02 03 18 05 05 06 20 04 04 05
F1 FF FF FA 98 04 00 07 98 07 00 25 00 00 00 00
98 0A 00 FE 20 00 00 00 00 00 00 00 00 00 00 00
00 00 01 00 98 0B 00 00 20 3A 50 50 50 50 40 20
41 20 44 20 52 20 5F 30 41 09 31 08 83 20 42 09
31 28 84 40 40 20 45 20 6E 20 64 02 65 01 30 8B
40 40 30 4D 20 61 20 69 02 6E 01 00 81 09 4E 00
82 20 53 20 74 20 61 10 20 72 02 74 01 14 8C 10
1F 75 01 85 1F 76 02 86 1F 77 03 87 1F 78 04 88
1F 79 05 89 0F 7A 06 8A 98 0C 00 18

Die Programmdatei ist für einen Menschen kaum noch lesbar. Ein Computer hingegen interpretiert die
angegebenen Zahlen als Befehle, Operanden und Daten und führt entsprechende Aktionen aus.

Abb. 78 können Sie entnehmen, dass wir nun den kompletten oberen Bereich „Beim Entwurf“ durch-
laufen haben. Von der Algorithmus-Ebene bis zur Befehlssatz-Ebene haben wir uns dabei stets mit
der Darstellung von Information beschäftigt. Wir haben die Informationsdarstellung schrittweise von
„für den Menschen gut lesbar, aber für den Computer schlecht lesbar“ bis „für den Menschen schlecht
lesbar, aber für den Computer gut lesbar“ verändert.

Die gezeigten Umwandlungen von einer Darstellung in eine andere finden immer beim Entwurf statt,
also während der Entwicklung des Programms.

76
Im Gegensatz dazu beschäftigt sich der in Abb. 78 unter der horizontalen Trennlinie befindliche Teil
mit Aktionen, die zur Laufzeit des Programms (oder bei der Entwicklung des Prozessors), jedoch nicht
bei der Entwicklung des Programms stattfinden.

Der angesprochene Bereich, der sich von der Mikroarchitektur- bis hin zur Layout-Ebene erstreckt,
beschreibt den Aufbau von Prozessoren.

Die Mikroarchitektur-Ebene abstrahiert dabei die darunter liegenden Schichten durch logische Bau-
einheiten, welche die als Nullen und Einsen codierten Programme interpretieren und ausführen.

Nachfolgende Darstellung zeigt die Mikroarchitektur des MMIX-Prozessors, mit dem wir uns im Laufe
der Vorlesung beschäftigen werden.

77
BZ übernehmen Ergebnisauswahl

4 Steuerung
64 24..31 ALU-Funktion
Add
64

64 Registerblock
Schreib- 8 Daten-
BZ Daten $X Speicher
64 16..23 64
Schreiben/ Lese- Schreib-
Lesen $X Daten $X Daten

Befehls- 32 8..15 Lese-


64
Lesen $Y
64
Speicher Daten $Y
64 Lese-
ALU Adr.
Daten 0
Daten 64
0..7 Lesen $Z
Lese-
Daten $Z
1
Adresse 64
64

Abb. 84: Einfacher MMIX-Datenpfad

Die einzelnen Elemente dieses sog. Datenpfads sowie deren Zusammenwirken werden im Laufe der
nächsten Kapitel erklärt werden.

Nachdem wir verstanden haben, wie ein Prozessor (ein Datenpfad) auf Mikroarchitektur-Ebene funk-
tioniert, werden wir die Elemente des Datenpfads genauer untersuchen. Ausgehend von der Funktion
der Elemente werden wir deren Realisierung als Logikschaltung kennenlernen, die sog. Ebene der
digitalen Logik.

Ein Beispiel für die Realisierung eines dieser Elemente als Logikschaltung ist der in nachstehender
Abbildung angegebene Aufbau des Befehlszählers.

D0
Q0

D1
Q1

BZ D2
Q2

D63
Q63

Abb. 85: Aufbau des Befehlszählers aus Logik-Gattern

78
Da Logikgatter immer als Transistorschaltung aufgebaut werden, werden wir im Anschluss auf der
Transistor-Ebene noch die Implementierung einiger Logikgatter mit Transistoren kennenlernen. Um
einen ersten Eindruck davon zu bekommen, ist in der nachfolgenden Abbildung bereits der Aufbau
eines NOR-Gatters in CMOS-Technik gezeigt.

Abb. 86: NOR-Gatter in CMOS-Technik

Nachdem wir den MMIX-Prozessor von der Mikroarchitektur-Ebene bis hin zur Transistor-Ebene ken-
nengelernt haben und uns einen Eindruck davon verschafft haben, wie sich das Funktionsvermögen
eines Prozessors aus Transistoren entwickeln lässt, zeigen wir kurz anhand der sog. Layout-Ebene,
wie Transistoren auf einem Chip integriert werden können.

Eine kleine Vorschau gibt das nachstehende Layout der bereits kennengelernten Implementierung
eines NOR-Gatters:

VDD

Eingang 1

Ausgang

Eingang 2

GND

Abb. 87: Layout eines NOR-Gatters

Wir haben jetzt die Meilensteine der Vorlesung „Computertechnik“ kennengelernt, anhand derer wir
den Aufbau und die Funktionsweise von Prozessoren verstehen werden.

Damit ist es in „Computertechnik“ aber noch nicht getan. Im Kapitel „Performance“ werden wir erfah-
ren, wie man die Leistungsfähigkeit von Prozessoren messen und bewerten kann. Im Anschluss wer-
den wir dieses Wissen anwenden, um in den Kapiteln „Cache“ und „Pipeline“ gängige Verfahren zur
Leistungssteigerung von Prozessoren zu erarbeiten.

Zunächst schließen wir jedoch an die im Fach „Grundlagen der Informatik“ kennengelernte Algorith-
mus- und Hochsprachen-Ebene an, indem wir die darunter liegende Assembler- und Befehlssatz-
Ebene zunächst allgemein untersuchen.

79
80

Pipeline-Datenpfad . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 107

11.4 Cache . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 115


Motivation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 115
Direkt abgebildeter Cache . . . . . . . . . . . . . . . . . . . . . . . . . 118
Set-Assoziativer/Mengen-Assoziativer Cache . . . . . . . . . . . . . . . 121
81

1 Aufgaben ‘‘Wie funktioniert ein Computer’’

Netzteil

a) Welche Spannungen werden von PC-Netzteilen bereitgestellt?

b) Warum können PC-Netzteile hohe Leistungen liefern, obwohl die eingebauten


Transformatoren nur relativ klein sind?

c) Wie sind Schaltnetzteile aufgebaut? Skizzieren Sie ein Blockschaltbild!


82 1 Aufgaben ‘‘Wie funktioniert ein Computer’’

Grafikkarten

a) Was sind die Hauptaufgaben einer Grafikkarte?

b) Was ist ein ‘‘Back-Buffer’’, was ist ein ‘‘Front-Buffer’’?

Optische Laufwerke

a) Was sind Pits und Land?

b) Was reflektiert Licht: Pits, Land oder beides?

c) Welche Tiefe müssen die Pits haben, damit man die mit Pits und Land gespeicherte
Information sinnvoll auslesen kann? Warum?
83

Festplatte

a) Was ist eine Festplatten-Spur?

b) Was ist ein Festplatten-Zylinder?

c) Was ist ein Festplatten-Sektor?

d) Was sind typische Sektor-Größen?

e) Was für Informationen werden in Sektoren neben den Nutzdaten noch zusätzlich
abgespeichert?
84 1 Aufgaben ‘‘Wie funktioniert ein Computer’’

f) Skizzieren Sie grob einen Regelkreis der zur Positionierung des Festplatten-Arms
verwendet werden kann.
85

Prozessor

a) Aus welchen logischen Grundeinheiten besteht ein Prozessor?

b) Welche Schritte führt ein Prozessor aus, wenn er den nächsten Befehl aus dem
Speicher lädt?

c) Wo können die Operanden eines Befehls generell abgelegt sein?


86 1 Aufgaben ‘‘Wie funktioniert ein Computer’’

Bussystem

a) In welche drei Busse lässt sich ein Bussystem oft aufgliedern?

b) Was ist die Funktion dieser drei Busse?

c) Welche dieser Busse sind unidirektional, welche bidirektional?


87

Rechner-Architekturen

a) Was ist der Haupt-Unterschied zwischen einer Harvard- und einer von Neumann-
Architektur?

b) Wie kann man die Aussage verstehen, dass heutige Rechnersysteme oft sowohl
eine Harvard- als auch eine von Neumann-Architektur haben?
88 1 Aufgaben ‘‘Wie funktioniert ein Computer’’
2.1 Bits, Byte, Datenworte und Logikpegel 89

2 Darstellung von Zahlen und Zeichen

Computer- bzw. Prozessorsysteme führen Transformationen durch, die Eingaben X auf


Ausgaben Y abbilden, d.h. Y = f (X ).

Programm
Eingabe X Ausgabe Y
Prozessor

Die Art und Weise, wie diese Transformationen durchgeführt werden, ist durch die
Programme festgelegt, die von einem Prozessor ausgeführt werden. Beispiele:
• Dokument drucken:
• X: Dokument bzw. Datensatz in einer Applikation
• Y: Befehle/Daten, die an den Drucker geschickt werden müssen, damit
dieser das (durch X repräsentierte) Dokument druckt
• Programm: Applikation, aus der heraus das Dokument gedruckt wird
(z.B. Textverarbeitungsprogramm) sowie der Druckertreiber

• Rastern von Grafiken: X = Repräsentation eines Objekts (z.B. Linie);


Y = Farbintensitätswerte von Pixeln

Linie von (x1, y1) nach (x2, y2), 255 190 0


Dicke: d, Farbe: RGB = (0, 0, 0),
Hintergrund: weiß 255 190 0
X Y 255 190 0

• Berechnungen: Y aus X berechnen; z.B. X = zwei Vektoren, Y = Skalarprodukt

10

1 2 3 · 20 = 1·10 + 2·20 + 3·30 = 140

30

X Y

X und Y sind Daten, die als Zahlen oder als Zeichen interpretiert werden können. Sie
werden in Computersystemen durch sog. Bits repräsentiert.
90 2 Darstellung von Zahlen und Zeichen

2.1 Bits, Byte, Datenworte und Logikpegel


Daten werden in Computersystemen durch Bits dargestellt bzw. als Bits verarbeitet. Der
Begriff Bit steht für binary digit und meint Binärziffer, d.h. Ziffern, die nur Werte 0 und
1 annehmen können. Bei der Verarbeitung von Daten durch elektrische Schaltungen
entspricht ‘‘0’’ oft dem sog. Low-Pegel, z.B. -0,3 ... +1,3 Volt, und ‘‘1’’ dem sog.
High-Pegel, z.B. +2,3 ... +5,3 Volt.

5V
High

Low
0V

Darüber hinaus findet man auch andere Zuordnungen/Spannungsbereiche. Bei der


seriellen Schnittstelle RS-232 beispielsweise entsprechen Spannungen zwischen +3 V
... +15 V dem Low-Pegel, während Spannungen zwischen -15 V ... -3 V High-Pegel
darstellen.

Mit einem einzelnen Bit können nur zwei Zustände, High und Low, dargestellt werden.
Um mehr als zwei Zustände gleichzeitig abzubilden, werden mehrere Bits zu einem
Datenwort zusammengefasst. Mit einem Datenwort der Breite n Bits lassen sich 2n
verschiedene Low-/High-Kombinationen darstellen.
Nachfolgende Abbildung zeigt ein Datenwort der Breite n = 32 Bit sowie die entspre-
chende Darstellung in Hexadezimal-Schreibweise.

32 Bit breites Datenwort: 0010 1100 1010 0011 0000 1000 1011 1111

Prefix
Hexadezimale Darstellung: 0x 2 6 A 3 0 8 B F

Die hexadezimale Darstellung wird häufig verwendet, da hier immer vier Bits (sog. Nibble)
zu einer einzelnen Ziffer zusammengefasst werden:

0: 0000 1: 0001 2: 0010 3: 0011 4: 0010 5: 0101 6: 0110 7: 0111

8: 1000 9: 1001 A: 1010 B: 1011 C: 1010 D: 1101 E: 1110 F: 1111


2.1 Bits, Byte, Datenworte und Logikpegel 91

So lassen sich auch längere binäre Datenworte ohne großen Platzbedarf darstellen.
Gleichzeitig kann durch die feste 4-zu-1-Abbildung der Wert der einzelnen Bits direkt
extrahiert werden.
Zur Kennzeichnung einer hexadezimalen Codierung wird das Prefix ‘‘0x’’ verwendet,
d.h. hexadezimal codierten Zahlen wird ‘‘0x’’ vorangestellt.

Seltener findet man oktale Codierungen. Hier wird das Prefix ‘‘0’’ verwendet. Bei oktaler
Codierung werden immer 3 Bits zu einer Ziffer zusammengefasst.

24 Bit breites Datenwort: 001 110 000 111 101 110 011 100

Prefix
Oktale Darstellung: 0 1 6 0 7 5 6 3 4

0: 000 1: 001 2: 010 3: 011 4: 010 5: 101 6: 110 7: 111

In Computersystemen werden häufig Worte der Breite 8, 16, 32 oder 64 Bit verwendet.
Datenworte mit der Wortbreite 8 Bit werden Byte genannt. Ein Byte wird dabei oft
als elementare Datenwortgröße angesehen. Alle anderen Datenworte sind dann ein
ganzzahliges Vielfaches eines Bytes.

Nachfolgende Abschnitte zeigen, wie in Computersystemen mit solchen binären Daten-


worten Zahlen und Zeichen dargestellt werden. Die darauf folgenden Kapitel zeigen, wie
diese Datenworte/Zahlen/Zeichen von Prozessoren verarbeitet werden.
92 2 Darstellung von Zahlen und Zeichen

2.2 Zeichen
Zeichen sind Symbole (z.B. ‘a’, ‘b’, ‘c’, ...), mit deren Hilfe Dinge beschrieben werden
können. Zur Darstellung von Texten werden Zeichen zu Zeichenketten (Worte) kombi-
niert und Zeichenketten in Anordnungen (Sätze) gruppiert. Die ‘‘Beschreibung’’ findet
dadurch statt, dass unser Gehirn beim Lesen lernen die Bedeutung der verschiedenen
Zeichenketten (Symbol-Kombinationen) sowie die Bedeutung verschiedener Anord-
nungen gelernt hat. In Computersystemen werden Zeichen durch Bits repräsentiert.
Nachfolgende Tabelle zeigt die Codierung von Zeichen gemäß ASCII-Standard.

0x0… 0x1… 0x2… 0x3… 0x4… 0x5… 0x6… 0x7…

…0 NUL DLE SP 0 @ P ` p

…1 SOH DC1 ! 1 A Q a q

…2 STX DC2 " 2 B R b r

…3 ETX DC3 # 3 C S c s

…4 EOT DC4 $ 4 D T d t

…5 ENQ NAK % 5 E U e u

…6 ACK SYN & 6 F V f v

…7 BEL ETB ' 7 G W g w

…8 BS CAN ( 8 H X h x

…9 HT EM ) 9 I Y i y

…A NL SUB * : J Z j z

…B VT ESC + ; K [ k {

…C NP FS , < L \ l |

…D CR GS - = M ] m }

…E SO RS . > N ^ n ~

…F SI US / ? O _ o DEL
2.2 Zeichen 93

‘‘ASCII’’ (oft auch US-ASCII) steht für American Standards Code for Information In-
terchange und ist ein weit verbreiteter Standard zur Codierung von 128 ausgewählten
Zeichen durch 7 Bit breite Datenworte.
Druckbare Zeichen, d.h. Zeichen, die auch am Bildschirm/Drucker ausgegeben werden
können, befinden sich ab Bitkombination 0x20, d.h. Zeichen 33 - 128.
Die unteren 32 Zeichen, d.h. Bitkombinationen 0x00, 0x01, ... , 0x1F definieren sog.
Steuerzeichen. Steuerzeichen wurden früher dafür verwendet um Fernschreiber anzu-
steuern.

0x00 (NUL): Null 0x10 (DLE): Data link escape

0x01 (SOH): Start of header 0x11 (DC1): Device control 1

0x02 (STX): Start of text 0x12 (DC 2): Device control 2

0x03 (ETX): End of text 0x13 (DC 3): Device control 3

0x04 (EOT): End of transmission 0x14 (DC 4): Device control 4

0x05 (ENQ): Enquiry 0x15 (NAK): Negative acknowledge

0x06 (ACK): Acknowledge 0x16 (SYN): Synchronous idle

0x07 (BEL): Bell 0x17 (ETB): End of transmission block

0x08 (BS): Backspace 0x18 (CAN): Cancel

0x09 (HT): Horizontal tab 0x19 (EM): End of medium

0x0A (LF): Line feed; new line 0x1A (SUB): Substitute

0x0B (VT): Vertical tab 0x1B (ESC): Escape

0x0C (FF): Form feed; new page 0x1C (FS): File separator

0x0D (CR): Carriage return 0x1D (GS): Group separator

0x0E (SO): Shift out 0x1E (RS): Record separator

0x0F (SI): Shift in 0x1F (US): Unit separator

Die meisten Steuerzeichen werden heute nur noch selten verwendet. Häufig verwendet
wird beispielsweise 0x00 wird, um das Ende von Zeichenketten anzuzeigen, 0x0A um
einen Zeilenumbruch zu markieren, 0x09 für Tabulatoren.
94 2 Darstellung von Zahlen und Zeichen

Der ASCII-Code definiert ausschließlich die Codierung der in Amerika häufig verwen-
deten Zeichen. Codierungen für international verwendete Zeichen wie bspw. deutsche
Umlaute ‘‘ä’’, ‘‘ö’’ und ‘‘ü’’ sowie ‘‘ß’’ etc. werden nicht definiert. Dazu muss der ASCII-
Zeichensatz erweitert werden. Beispiele hierzu sind der Standard ISO 8859-1 (Latin-1)
oder Zeichentabellen, wie sie unter MS-DOS eingesetzt wurden (z.B. Codepage 850 für
Westeuropa).

Heute wird häufig der Unicode-Zeichensatz verwendet. Dieser hat zum Ziel, jedem auf
der Welt verwendeten Schriftzeichen eine eindeutige Zahl zuzuweisen.

Zur Codierung dieser Zahlen werden häufig UTF-8 und UTF-16 eingesetzt. Diese
Verfahren codieren den Unicode-Zeichensatz in variable Wortbreiten. So können zur
Codierung häufig vorkommender Zeichen geringere Wortbreiten verwendet werden als
zur Codierung seltener vorkommender Zeichen. Diese Form der Komprimierung sorgt
dafür, das Text aus Sprachen, die auf dem lateinischen Alphabet basieren, effizient
abgespeichert bzw. über das Internet übertrag werden können.

Nachfolgende Abbildung zeigt die Codierung gemäß UTF-8.

Codierung Unicode-Zeichen

0xxxxxxx 0x00 - 0x7F (entspricht ASCII)

110xxx 10xxxxxx 0x080 - 0x7FF

1110xxx 10xxxxxx 10xxxxxx 0x0800 - 0xFFFF

11110xxx 10xxxxxx 10xxxxxx 10xxxxxx 0x010000 - 0x10FFFF

Im Gegensatz dazu wird in UTF-32 jedes Unicode-Zeichen mit 32 Bit codiert. Vorteil:
Einfach zu codieren; Nachteil: Hoher Speicherbedarf für Texte.
2.3 Zahlen 95

2.3 Zahlen

Zahlen dienen zur Darstellung von Größen/Beträgen. Sie werden durch Ziffern dargestellt.

Zahl: 1 0 2 4

Ziffer Ziffer Ziffer Ziffer

Ziffern sind Zeichen, die jedem Element einer Symbol-Menge (z.B. {‘0’, ‘1’, ‘2’, ‘3’, ‘4’,
‘5’, ‘6’, ‘7’, ‘8’, ‘9’} ) ein Vielfaches eines Grundbetrags als Wert zuordnen. Beispiel: ‘0’ ist
‘‘nichts’’ bzw. keinmal der Grundbetrag, ‘1’ ist der Grundbetrag, ‘2’ ist zweimal so viel
wie der Grundbetrag; ‘3’ ist dreimal so viel wie der Grundbetrag, etc.

0 := 5 :=

1 := 6 :=

2 := 7 :=

3 := 8 :=

4 := 9 :=

Die Menge der in einem Zahlensystem vorgesehenen Symbole wird Basis b genannt.
Beispiel: Im Zahlensystem zur Basis b = 2 gibt es nur zwei Symbole: ‘0’ und ‘1’.
Mit einer Ziffer können nur b verschiedene Dinge/Werte dargestellt werden. Um mehr
als b verschiedene Werte abzubilden werden mehrere Ziffern aneinandergereiht. Dabei
erhöht sich mit jeder weiteren Ziffer die Anzahl unterschiedlicher Symbol-Kombinationen
um den Faktor b. Durch Aneinanderreihung von n Ziffern zu einer n Stellen langen Zahl
· ... · b} = b n verschiedene Symbolkombinationen und damit b n verschie-
| · b {z
lassen sich b
n mal
dene Werte/Beträge darstellen.

Nachfolgende Abbildung zeigt die Symbole zur Darstellung von Beträgen mit zwei Ziffern
aus der Symbolmenge ‘0’, ‘1’, ‘2’, ‘3’, ‘4’, ‘5’, ‘6’, ‘7’, ‘8’, ‘9’.
96 2 Darstellung von Zahlen und Zeichen

00 01 02 03 04 05 06 07 08 09

10 11 12 13 14 15 16 17 18 19

20 21 22 23 24 25 26 27 28 29

30 31 32 33 34 35 36 37 38 39

40 41 42 43 44 45 46 47 48 49

50 51 52 53 54 55 56 57 58 59

60 61 62 63 64 65 66 67 68 69

70 71 72 73 74 75 76 77 78 79

80 81 82 83 84 85 86 87 88 89

90 91 92 93 94 95 96 97 98 99

• Der kleinste Wert wird dadurch repräsentiert, dass alle Ziffern das Symbol des
niedrigsten Werts darstellen.
• Ausgehend vom kleinsten Wert wird der nächst höhere Wert stets dadurch
repräsentiert, dass bei der rechtesten Ziffer das dem nächst höheren Ziffern-
Wert entsprechende Symbol ausgewählt wird.
• Ist bei einer Ziffer bereits das werthöchste Symbol ausgewählt, wird bei dieser
Ziffer das wertniedrigste Symbol ausgewählt. Gleichzeitig wird die links an-
grenzende Ziffer durch das dem nächst höheren Ziffern-Wert entsprechende
Symbol ersetzt.

Durch dieses Vorgehen haben die einzelnen Ziffern-Positionen unterschiedliche Wertig-


keiten. Numeriert man die Ziffern-Positionen i von rechts nach links durch, beginnend
mit i = 0, dann hat jede Ziffernposition den Wert b i . Beispiel mit b = 10:

Zahl: 1 0 2 4

Stellen- 103 102 101 100


Wertigkeit: =1000 =100 =10 =1

Der Wert der Zahl ergibt sich zu 1 · 1000 + 0 · 100 + 2 · 10 + 4 · 1 = 1024.


2.3 Zahlen 97

Im Gegensatz zu Ziffern-Positionen links von i = 0 stellen Ziffern-Positionen rechts


von i = 0, d.h. i < 0, nicht ein Vielfaches des Grundelements dar, sondern einen
Bruchteil des Grundelements. Nachfolgende Abbildung zeigt am Beispiel b = 10, wie
die Stellenwertigkeit von links nach rechts auf b i , d.h. b 1 , b 2 , b 3 , ... reduziert wird.

Aufteilen des Grund-


elements in b = 10
gleich große Teile

Grundelement
b0 = 1

b-1 = 0,1 b-2 = 0,01 b-3 = 0,001

Sind Stellen i < 0 vorhanden, so wird der Übergang (i = 0) ! (i < 0) durch das
Komma-Symbol gekennzeichnet.

Zahl: 1 0 2 4 , 2 5

Stellen- 103 102 101 100 Komma 10-1 10-2


Wertigkeit: = 1000 = 100 = 10 =1 = 0,1 = 0,01

Da es unendlich viele Zahlen gibt, verfügen Zahlen (theoretisch) über unendlich viele
Stellen vor bzw. nach dem Komma. Für in der Praxis auftretende Zahlen werden in der
Regel jedoch nur wenige Stellen vor und wenige Stellen nach dem Komma benötigt.
Die restlichen (unendliche vielen) führenden bzw. nachlaufenden Nullen werden nicht
dargestellt.
98 2 Darstellung von Zahlen und Zeichen

2.4 Codierung von Festkommazahlen


Festkommazahlen sind Zahlen, bei denen das Komma an einer zuvor vereinbarten, d.h.
festen Position steht. Nachfolgende Abbildung zeigt eine solche Festkommazahl:

n-1 0

Y Y … Y X X X X X X X X , 0 0 … 0

Annahme unendlich vieler füh- n Stellen zur Aufnahme von n Ziffern; Komma Annahme unendlich vieler nach-
render Stellen, die nicht dar- X = 0…b-1; führende Nullen werden nach der folgender Nullen, die nicht dar-
gestellt/abgespeichert werden bei Darstellungen oft weggelassen Einer-Stelle gestellt/abgespeichert werden

X steht für die Ziffern 0, 1, ... , b-1, wobei b die Basis des verwendeten Zahlensystems
darstellt (z.B. b = 2 für Binärzahlen, b = 10 für Dezimalzahlen, ...).
n ist die Wortbreite, d.h. es stehen n Bits zum Abspeichern der Zahl zur Verfügung.
Y steht für die unendlich vielen Stellen, die nicht mit abgespeichert werden.

Festkommazahlen funktionieren nach dem zuvor beschriebenen Prinzip ‘‘Vielfaches ei-


nes Grundelements’’. Aus diesem Grund sind die Abstände zwischen zwei benachbarten
Zahlen stets gleich groß (Äquidistanz).

Vorzeichenlose Festkommazahlen
Vorzeichenlose Festkommazahlen haben kein Vorzeichen, d.h. sie sind stets positiv. Der
Wert v (v = value) einer vorzeichenlosen Festkommazahl ergibt sich zu:

v = (an 1 · bn 1
+ · · · + a1 · b 1 + a0 · b 0 ) · b r

• n ist die Stellenzahl, d.h. die maximale Menge an Ziffern, die zur Darstellung
bzw. Abspeicherung der Zahl vorgesehen ist. In Prozessoren wird häufig eine
Stellenzahl von n = 8, 16, 32 oder 64 (Binär-) Stellen verwendet.
In der Mathematik gibt es keine begrenzte Stellenzahl; dort gilt n ! 1.
• b ist die Basis des Zahlensystems, z.B. 10 für das Dezimalsystem (Ziffern
0 ... 9) oder 2 für Binärzahlen (Ziffern 0 und 1). Ziffern an der Stelle i haben die
Wertigkeit b i . In Prozessoren wird aufgrund der Darstellung von Werten durch
2.4 Codierung von Festkommazahlen 99

Logik-Pegel ‘‘Low’’ und ‘‘High’’ als Basis b = 2 verwendet.


• Die Koffizienten ai sind die Ziffern an den Stellen i. Die Werte der Ziffern liegen
im Bereich 0...(b 1) und geben an, wie oft die Wertigkeit der jeweiligen Stelle
zum Wert der Zahl beiträgt.
• Der Wert von r (r = radix) legt die Position des Kommas fest:
• r = 0: Dieser Fall ist der Normalfall: Durch Multiplikation mit b r = b 0 = 1
bleibt v = an 1 · b n 1 + · · · + a1 · b 1 + a0 · b 0 . Das Komma steht hinter
der Einer-Stelle und wird weggelassen. Es werden ganze Zahlen mit
den Werten 0, 1, ... , b n 1 dargestellt.
• r > 0: Durch Multiplikation mit b r können größere Zahlen dargestellt
werden, jedoch auf Kosten geringerer Genauigkeit. Die Ziffern der Zahl
werden um r Stellen nach links geschoben, die frei werdenden Posi-
tionen werden mit Nullen aufgefüllt. Das Komma wird weggelassen.
Darstellungsbeispiel einer Festkommazahl für n = 8 und r = 3:
xxxxxxxx000. Die Zeichen ‘‘x’’ stehen dabei jeweils für eine der Ziffern
an 1 ... a0 .
• r < 0: Da r < 0, entspricht die Multiplikation mit b r einer Division
durch b |r | , d.h. das (nach der Einer-Stelle implizit stehende) Komma
wird um r Stellen nach links geschoben. Die Genauigkeit erhöht sich
auf Kosten der größtmöglich darstellbaren Zahl. Darstellungsbeispiel
für n = 8 und r = 3: xxxxx,xxx.

Im folgenden werden nur noch Dezimalzahlen (b = 10) und Binärzahlen (b = 2) betrachtet.


100 2 Darstellung von Zahlen und Zeichen

Nachfolgender Zahlenring zeigt die Zuordnung von Binär- zu Dezimalzahlen für diese
Codierung:

1111 0000
1110 0001
15 0
1101 14 1 0010
13 2
1100 0011
12 3 Richtung
steigender
11 4 Werte
1011 0100
10 5

1010 9 6 0101
8 7

1001 0110
1000 0111

Die Darstellung zeigt, dass die Richtung steigender Werte bei beiden Codierungen (Binär
und Dezimal) identisch ist. Als Folge können bei dieser Darstellung für die gewählte
Binärcodierung dieselben Rechenregeln angewendet werden, wie bei Dezimalzahlen.
Beispiel:
• 210 + 110 = 310
• 00102 + 00012 = 00112
2.4 Codierung von Festkommazahlen 101

Aufgaben
Die folgenden Aufgaben betrachten Binärzahlen, d.h. b = 2.

a) Welches ist die kleinste darstellbare vorzeichenlose Festkommazahl?

b) Wieviele unterschiedliche vorzeichenlose Festkommazahlen können mit n Bit dar-


gestellt werden?

c) Geben Sie für r = 0 den Wert der größten vorzeichenlosen Festkommazahl in


Abhängigkeit von n an.

d) Geben Sie für n = 8 und r = 2 den Wert der größten vorzeichenlosen Festkomma-
zahl an.

e) Betrachten Sie den Zahlenring. Wie kann man einen Überlauf von vorzeichenlosen
Zahlen feststellen?

f) Sind alle Abstände vorzeichenloser Binärzahlen zum nächst kleineren und nächst
größeren Nachbarn äquidistant? Skizzieren Sie für r = 2 und n = 3 die entspre-
chenden Werte auf dem Zahlenstrahl.

0
102 2 Darstellung von Zahlen und Zeichen

Im Folgenden gilt n = 8 und r = 0.

g) Wandeln Sie folgende Dezimalzahlen in vorzeichenlose Binärzahlen um.

Dezimal Binär vorzeichenlos

75

127

128

255

256

h) Wandeln Sie folgende hexadezimale Zahlen in vorzeichenlose Binärzahlen um.

Hexadezimal Binär vorzeichenlos

0x52416352

0x7A8F23DE

i) Berechnen Sie 24 + 17 = 3 im Binärsystem.


2.4 Codierung von Festkommazahlen 103

Im Folgenden gilt n = 6 und r = 3

j) Wandeln Sie folgende Dezimalzahlen in vorzeichenlose Binärzahlen um.

Dezimal Binär vorzeichenlos

0,125

1,75

3,375

k) Berechnen Sie 2,25 + 4,375 im Binärsystem.


104 2 Darstellung von Zahlen und Zeichen

Aufgaben Tutorium

Im Folgenden gilt n = 8, r = 0.

T a) Wandeln Sie folgende Dezimalzahlen in vorzeichenlose Binärzahlen um.

Dezimal Binär vorzeichenlos

67

126

253

T b) Berechnen Sie 17 + 23 im Binärsystem.


2.4 Codierung von Festkommazahlen 105

T c) Geben Sie für n = 6 und r = 3 den Wert der größten vorzeichenlosen Festkomma-
zahl an.

Im Folgenden gilt n = 8 und r = 3

T d) Wandeln Sie die angegebenen Dezimalzahlen in vorzeichenlose Binärzahlen um.

Dezimal Binär vorzeichenlos

0,375

7,25

10

12,5

17,625

T e) Berechnen Sie 1,75 + 3,125 im Binärsystem.


106 2 Darstellung von Zahlen und Zeichen

Vorzeichenbehaftete Festkommazahlen
Es gibt verschiedene Möglichkeiten, binäre vorzeichenbehaftete Festkommazahlen dar-
zustellen:
• Vorzeichen und Betrag
• Einer-Komplement
• Zweier-Komplement

Vorzeichen und Betrag


Bei dieser Darstellung werden Vorzeichen und Betrag der Zahl separat abgespeichert:
• Das Vorzeichen wird repräsentiert durch das höherwertigste Bit: Hat das Bit
den Wert 0, ist die Zahl positiv, hat das Bit den Wert 1, ist die Zahl negativ.
• Der Betrag der Zahl wird durch die restlichen Bits dargestellt.

Ob eine Zahl positiv oder negativ ist, kann direkt am MSB abgelesen werden. Zur
Negation einer Zahl muss nur das höherwertigste Bit geändert werden.

Ein Problem bei dieser Darstellung ist die doppelte Null:


• 00 ... 0002 ) +0
• 10 ... 0002 ) 0

Nachfolgende Abbildung zeigt für n = 4 die Zuodnung von Binär- zu Dezimalzahlen.


• Für positive Zahlen ist die Richtung steigender Werte für Binär- und Dezimal-
zahlen die selbe.
• Für negative Zahlen ist die Richtung jedoch unterschiedlich; Beispiel:
• 10102 + 00012 = 10112 : Bewegung im Uhrzeigersinn
• 210 + 110 = 110 : Bewegung gegen den Uhrzeigersinn
• Ergebnis falsch: 110 6= 10112
2.4 Codierung von Festkommazahlen 107

1111 0000
1110 0001
-7 0
1101 -6 1 0010
-5 2

1100 -4 3 0011
negativ positiv
-3 4
1011 0100
-2 5

1010 -1 6 0101
-0 7

1001 0110
1000 0111

Aufgaben

a) Welche Auswirkungen hat es, dass für negative Zahlen die Richtung steigender
Werte nicht übereinstimmt?

b) Ist der Wertebereich symmetrisch? Begründung!


108 2 Darstellung von Zahlen und Zeichen

c) Geben Sie den Wertebereich für r = 0 in Abhängigkeit von n an.

d) Codieren Sie für n = 8 und r = 0 die folgenden Zahlen binär in die Darstellung
‘‘Vorzeichen und Betrag’’.

Dezimal Binär

-10

20

e) Codieren Sie für n = 6 und r = 2 die folgenden Zahlen in die binäre Darstellung
‘‘Vorzeichen und Betrag’’.

Dezimal Binär

-2,25

5,5
2.4 Codierung von Festkommazahlen 109

Aufgaben Tutorium

T a) Codieren Sie für n = 8 und r = 0 die folgenden Zahlen binär in die Darstellung
‘‘Vorzeichen und Betrag’’.

Dezimal Binär

-17

-5

17

T b) Codieren Sie für n = 6 und r = 2 die angegebenen Zahlen in die binären


Darstellung ‘‘Vorzeichen und Betrag’’.

Dezimal Binär

-3,75

-0,5

7,25
110 2 Darstellung von Zahlen und Zeichen

Einer-Komplement
Bei dieser Darstellung werden zur Negierung einer Zahl alle Bits invertiert. Um eine
eindeutige Unterscheidung zwischen positiven und negativen Zahlen zu gewährleisten,
ist der Betrag der Zahlen auf 2n 1 1 beschränkt. Dadurch kann das Vorzeichen der
Zahl wieder direkt am MSB abgelesen werden (0 ) positiv; 1 ) negativ).
Der Vorteil dieser Darstellung im Vergleich der Darstellung ‘‘Vorzeichen und Betrag’’
liegt darin, dass die Codierung der negativen Zahlen in derselben Richtung erfolgt wie
die Codierung der positiven Zahlen, so dass positive und negative Zahlen auf die gleiche
Art und Weise addiert (bzw. subtrahiert) werden können.

1111 0000
1110 0001
-0 0
1101 -1 1 0010
-2 2

1100 -3 3 0011
negativ positiv
-4 4
1011 0100
-5 5

1010 -6 6 0101
-7 7

1001 0110
1000 0111
2.4 Codierung von Festkommazahlen 111

Aufgaben

a) Geben Sie den Wertebereich der Einer-Komplement-Darstellung für r = 0 in


Abhängigkeit von n an.

b) Geben Sie den Wertebereich der Einer-Komplement-Darstellung allgemein in


Abhängigkeit von r und n an.

c) Geben Sie den Wertebereich der Einer-Komplement-Darstellung für r = 2 und


n = 8 an.

d) Ist der Wertebereich asymmetrisch?

e) Codieren Sie für n = 8 und r = 0 die folgenden Zahlen binär im Einer-Komplement.

Dezimal Binär

-10

20
112 2 Darstellung von Zahlen und Zeichen

f) Codieren Sie für n = 6 und r = 2 die folgenden Zahlen im Einer-Komplement.

Dezimal Binär

-2,25

5,5

g) Zeigen Sie an einem Beispiel, wie sich bei dieser Codierung zur Addition von Bin-
ärzahlen derselbe Algorithmus verwendet lässt wie zur Addition von Dezimalzahlen
– sowohl bei positiven als auch bei negativen Werten.

h) Wann gibt es bei Verwendung der Einer-Komplement-Codierung Probleme bei der


Addition?

i) Wie könnte man das Problem lösen?


2.4 Codierung von Festkommazahlen 113

Aufgaben

T a) Codieren Sie für n = 8 und r = 0 die folgenden Zahlen binär im Einer-Komplement.

Dezimal Binär

-17

-5

17

T b) Codieren Sie für n = 6 und r = 2 die folgenden Zahlen binär im Einer-


Komplement.

Dezimal Binär

-3,75

-0,5

7,25
114 2 Darstellung von Zahlen und Zeichen

Zweier-Komplement
Beim Zweier-Komplement wird zunächst das Einer-Komplement gebildet und dann
noch binär der Wert 1 addiert. Auf diese Weise wird die doppelte Null vermieden. Der
Wertebereich wird asymmetrisch, was jedoch kein Problem darstellt. Berechnungen
können in dieser Codierung mit demselben Algorithmus durchgeführt werden wie im
Dezimalsystem. Aus diesem Grund werden vorzeichenbehaftete Festkomma-Zahlen in
der Regel im Zweier-Komplement codiert.

1111 0000
1110 0001
-1 0
1101 -2 1 0010
-3 2

1100 -4 3 0011
negativ positiv
-5 4
1011 0100
-6 5

1010 -7 6 0101
-8 7

1001 0110
1000 0111
2.4 Codierung von Festkommazahlen 115

Aufgaben

a) Codieren Sie für n = 8 und r = 0 die folgenden Zahlen binär im Zweier-


Komplement.

Dezimal Binär

-10

20

b) Codieren Sie für n = 6 und r = 2 die folgenden Zahlen im Zweier-Komplement.

Dezimal Binär

-2,25

5,5

c) Wie lässt sich im Zweier-Komplement ein Überlauf feststellen?


116 2 Darstellung von Zahlen und Zeichen

d) Berechnen Sie 37 - 53 im Zweier-Komplement.


2.4 Codierung von Festkommazahlen 117

Aufgaben Tutorium

T a) Codieren Sie für n = 8 und r = 0 die folgenden Zahlen binär im Zweier-


Komplement.

Dezimal Binär

-17

-5

17

T b) Codieren Sie für n = 6 und r = 2 die folgenden Zahlen binär im Zweier-


Komplement.

Dezimal Binär

-3,75

-0,5

7,25

T c) Berechnen Sie 17 - 23 im Zweier-Komplement.


118 2 Darstellung von Zahlen und Zeichen

2.5 Codierung von Gleitkommazahlen nach IEEE 754


Durch die fest definierte Kommastelle sind bei Festkommazahlen die Abstände zwischen
den einzelnen Zahlenwerten äquidistant. Aus diesem Grund (und aufgrund der endlichen
Anzahl an Stellen n) können mit Festkommazahlen nicht gleichzeitig sehr große Zahlen
und sehr kleine Zahlen dargestellt werden.
Bei Gleitkommazahlen ist diese Einschränkung aufgehoben. Die Abstände zwischen den
einzelnen Zahlenwerten sind um den Wert 0 herum sehr klein. Für große Zahlen werden
die Abstände sehr groß, wie in nachstehender Grafik skizziert.

Erreicht wird diese Eigenschaft dadurch, dass die Position des Kommas nicht im Voraus
festgelegt ist, sondern in der Zahl durch Angabe eines Exponenten e definiert wird.
Der Exponent legt fest, um wieviel die Kommastelle nach links oder rechts verschoben
werden muss.

Gleitkommazahlen werden wie folgt codiert:

s e f

Bei 32 Bit breiten Gleitkommazahlen (einfache Genauigkeit) gilt die Aufteilung


• s = 1 Bit
• e = 8 Bit
• f = 23 Bit,

bei 64 Bit breiten Gleitkommazahlen (doppelte Genauigkeit) gilt die Aufteilung


• s = 1 Bit
• e = 11 Bit
• f = 52 Bit.

Als Wert ergibt sich für


• für normalisierte Gleitkommazahlen (Normal-Fall) v = ( 1)s · 1,f · 2e K,

• für de-normalisierte Gleitkommazahlen (Spezial-Fall) v = ( 1)s · 0,f · 21 K.


2.5 Codierung von Gleitkommazahlen nach IEEE 754 119

Die Konstante K hat


• bei einfacher Genauigkeit (32 Bit) den Wert K = 127,
• bei doppelter Genauigkeit (64 Bit) den Wert K = 1023.

Eine Gleitkommazahl gilt als normalisiert, wenn beim Exponenten e weder alle Bits
gesetzt noch alle Bits gelöscht sind, d.h.
• 0 < e < 255 bei 32 Bit
• 0 < e < 2047 bei 64 Bit.

Eine denormalisierte Gleitkommazahl liegt vor, wenn e = 0 und gleichzeitig f > 0.

Spezialfälle:
• 0:
• e=0
• f =0

• ±1:
• s: +1 ) 0; 1)1
• e: alle Bits gesetzt ) 255 bei 32 Bit, 2047 bei 64 Bit
• f: alle Bits 0

• NaN (Not a Number)


• e: alle Bits gesetzt ) 255 bei 32 Bit, 2047 bei 64 Bit
• f: > 0

Aufgaben

Format von Gleitkommazahlen

a) Welchen Wert hat eine Zahl, die in 64 Bit Gleitkomma-Notation mit


0xC028000000000000 codiert wird?
120 2 Darstellung von Zahlen und Zeichen

b) Welchen Wert hat eine Zahl, die in 64 Bit Gleitkomma-Notation mit


0x0004000000000000 codiert wird?

c) Welchen Wert hat eine Zahl, die in 32 Bit Gleitkomma-Notation mit 0x7F80000
codiert wird?

d) Was ist eine denormalisierte Gleitkommazahl, wie wird sie codiert und wie berech-
net sich ihr Wert?

e) Welchen Nutzen haben denormalisierte Gleitkommazahlen?

f) Geben Sie ein Beispiel an, wie es zu einem Ergebnis kommen kann, das ‘‘keine
Zahl’’ ist.
2.5 Codierung von Gleitkommazahlen nach IEEE 754 121

Rechnen mit Gleitkommazahlen

a) Codieren Sie 3,625 und 13,5 als 32 Bit breite Gleitkommazahlen und tragen Sie
das Bitmuster in die angegebene Tabelle ein.

3,625:

13,5:
122 2 Darstellung von Zahlen und Zeichen

b) Berechnen Sie 3,625 + 13,5 im Binärsystem bei Verwendung einer 32 Bit Gleit-
kommacodierung.

Bitmuster des Ergebnisses:


2.5 Codierung von Gleitkommazahlen nach IEEE 754 123

c) Bestimmen Sie aus dem Ergebnis-Bitmuster das Ergebnis der Addition 3,625 +
13,5

T d) Codieren Sie 1,75 und 5,125 als 64 Bit breite Gleitkommazahlen und tragen Sie
das Bitmuster in die angegebene Tabelle ein.

1,75

5,125
124 2 Darstellung von Zahlen und Zeichen

T e) Berechnen Sie 1,75 + 5,125 im Binärsystem bei Verwendung einer 64 Bit Gleit-
kommacodierung.

Bitmuster des Ergebnisses:


2.5 Codierung von Gleitkommazahlen nach IEEE 754 125

T f) Bestimmen Sie aus dem Ergebnis-Bitmuster das Ergebnis der Addition 1,75 +
5,125
126 2 Darstellung von Zahlen und Zeichen
3.1 Schaltungselemente 127

3 Arithmetische Schaltungen

3.1 Schaltungselemente

Logikgatter
Treiber; gibt am Ausgang denselben Logikpegel aus, der auch am
Eingang anliegt

Inverter; gibt am Ausgang den Logikpegel des Eingangs invertiert aus

UND-Verknüpfung; gibt am Ausgang 1 aus, wenn beide Eingänge auf


1 liegen, anderenfalls 0; die Anzahl der Eingänge kann auch > 2 sein

NICHT-UND-Verknüpfung; gibt am Ausgang 0 aus, wenn beide Ein-


gänge auf 1 liegen, anderenfalls 1; die Anzahl der Eingänge kann auch
> 2 sein

ODER-Verknüpfung; gibt am Ausgang 1 aus, wenn mindestens ein


Eingang auf 1 liegt, anderenfalls 0; die Anzahl der Eingänge kann auch
> 2 sein

NICHT-ODER-Verknüpfung; gibt am Ausgang 1 aus, wenn kein Ein-


gang auf 1 liegt, anderenfalls 0; die Anzahl der Eingänge kann auch
> 2 sein

Exklusiv-ODER-Verknüpfung/Antivalenz; gibt am Ausgang 1 aus, wenn


beide Eingänge unterschiedliche Pegel aufweisen, anderenfalls 0

Exklusiv-NICHT-ODER-Verknüpfung/Äquivalenz; gibt am Ausgang 1


aus, wenn beide Eingänge identische Pegel aufweisen, anderenfalls 0

Multiplexer
Multiplexer wählen einen von mehreren Eingängen aus und leiten den dort anliegenden
Logikpegel an den Ausgang weiter. Nachfolgende Abbildung zeigt einen 1 Bit 2-auf-1-
Multiplexer, einen 1 Bit 4-auf-1-Multiplexer, einen n Bit 4-auf-1-Multiplexer sowie die
zugehörigen Wertetabellen. Der Steuereingang s legt fest, welcher der Eingänge a, b, ...
an den Ausgang durchgereicht wird.
128 3 Arithmetische Schaltungen

s s s
s y 2 s y
a 0 0 a a 0 a 0 00 a
n
y
b 1 1 b b 1 b 1 01 b
y yn y
c c n 10 c
2 n
2
d 3 d 3 11 d
n

a) Tragen Sie in nachfolgende Abbildung ein, wie sich ein 4 Bit 4-auf-1 Multiplexer
aus vier 1 Bit 4-auf-1 Multiplexer aufbauen lässt.

0
1
2
3

0
1
2
3

0
1
2
3

0
1
2
3
3.1 Schaltungselemente 129

b) Tragen Sie in nachfolgende Abbildung die Realisierung eines 1 Bit 4-auf-1 Multi-
plexers aus Logikgattern ein.

2
130 3 Arithmetische Schaltungen

Demultiplexer
Demultiplexer haben einen Eingang und leiten dessen Logikpegel an einen von mehreren
Ausgängen weiter. Nachfolgende Abbildung zeigt einen 1 Bit 1-auf-4-Demultiplexer
sowie die zugehörige Wertetabelle.

s
s a b c d
0 a 00 x 0 0 0
1 b 01 0 x 0 0
x
2 c 10 0 0 x 0
3 d 11 0 0 0 x

a) Tragen Sie in nachfolgende Abbildung die Realisierung eines 1 Bit 1-auf-4 Demul-
tiplexers aus Logikgattern ein.

2
3.1 Schaltungselemente 131

Decoder
Decoder sind Demultiplexer, deren Eingang x permanent auf 1 liegt und deswegen
weggelassen wird. Decoder werden zur Auswahl von Alternativen verwendet.

s
s a b c d
0 a 00 1 0 0 0
1 b 01 0 1 0 0
2 c 10 0 0 1 0
3 d 11 0 0 0 1
132 3 Arithmetische Schaltungen

Speicherelemente: Flipflops und Register


Wenn man zwei Inverter rückgekoppelt zusammenschließt, so dass der Ausgang des
einen Inverters mit dem Eingang des anderen Inverters verbunden ist, lässt sich ein
einzelnes Bit speichern.

Der Wert des gespeicherten Bits ist jedoch nicht veränderbar. Um einen bestimmten
Wert abzuspeichern, muss die Rückkopplung an einer Stelle aufgelöst werden und der
abzuspeichernde Wert angelegt werden.

Verwendet man Logik-Bauteile mit mehr als zwei Eingängen (NICHT-ODER (NOR),
NICHT-UND (NAND), kann auf die Unterbrechung der Rückkopplung verzichtet werden.

a x a1 a1 a2 y
a2 y
0 0 1
0 1 0
b y 1 0 0
1 1 0

Nachstehende Tabelle zeigt eine Änderung der Eingangswerte der rückgekoppelten


NOR-Schaltung über der Zeit. Zum Zeitpunkt t1 wird Eingang a auf 1 gelegt, zum
Zeitpunkt t2 wieder auf 0. ⌧ ist die Gatterlaufzeit.

a) Tragen Sie in die Tabelle die zu den jeweiligen Zeiten gehörenden Ausgangswerte
x und y ein.

t 0 t1 t1 + ⌧ t1 + 2⌧ t1 + 3⌧ ... t2 t2 + ⌧ ...

a 0 1 1 1 1 ... 0 0 ...

b 0 0 0 0 0 ... 0 0 ...

x ? ? 0 0 0 ... 0 0 ...

y ? ? ? 1 1 ... 1 1 ...
3.1 Schaltungselemente 133

Zum Zeitpunkt t3 wird Eingang b auf 1 gelegt, zum Zeitpunkt t4 wieder auf 0.

b) Tragen Sie in die Tabelle die zu den jeweiligen Zeiten gehörenden Ausgangswerte
x und y ein.

t t3 t3 + ⌧ t3 + 2⌧ t3 + 3⌧ ... t4 t4 + ⌧ ...

a 0 0 0 0 ... 0 0 ...

b 1 1 1 1 ... 0 0 ...

x 0 0 1 1 ... 1 1 ...

y 1 0 0 0 ... 0 0 ...

Zum Zeitpunkt t5 werden beide Eingange a und b auf 1 gesetzt.

c) Tragen Sie in die Tabelle die zu den jeweiligen Zeiten gehörenden Ausgangswerte
x und y ein.

t t5 t5 + ⌧ t5 + 2⌧ ...

a 1 1 1 ...

b 1 1 1 ...

x 1 0 0 ...

y 0 0 0 ...

Mit den beiden Eingänge a und b lässt sich der in der Schaltung abgespeicherte
Wert einstellen. Man nennt diese Schaltung auch asychrones Set-/Reset-Flipflop oder
asynchrones RS-Flipflop.

S Q S Q

R Q

R Q
134 3 Arithmetische Schaltungen

Der Begriff asynchron meint, dass an den Set-/Reset-Leitungen angelegte Signale sofort
berücksichtigt werden. Das ist oft nicht gewollt. Mit einem taktzustandsgesteuerten
RS-Flipflop können die Set-/Reset-Leitungen blockiert oder freigeschaltet werden. Im
blockierten Zustand (C = 0) haben Änderungen an S bzw. R keine Auswirkung. Im
freigeschalteten Zustand (C = 1) werden Änderungen übernommen.

S Q
C
R

d) Tragen Sie in nachstehende Abbildung geeignete Gatter und Verbindungsleitungen


ein, damit sich das Verhalten eines taktzustandsgesteuerten RS-Flipflops ergibt.

S Q

Bei obiger Aufgabe wurden zum Zeitpunkt t5 beide Eingangswerte auf 1 gesetzt. Beide
Ausgänge waren Null. Damit ist der in der Schaltung abgespeicherte Wert nicht definiert.
S und R dürfen somit nicht gleichzeitig auf 1 gesetzt werden.
Ein D-Flipflop hat statt zweier Eingangsleitungen S und R nur eine einzige Eingangslei-
tung, über die das Verhalten gesteuert wird. Damit können keine undefinierten Zustände
auftreten.

D Q
C
3.1 Schaltungselemente 135

e) Tragen Sie in nachstehende Abbildung geeignete Schaltungselemente und Ver-


bindungen ein, damit sich das Verhalten eines D-Flipflops ergibt.

D Q
S Q
C C
R

Beim D-Flipflop wird über den Eingang D festgelegt, welcher Zustand abgespeichert
werden soll (0 oder 1). Änderungen werden übernommen, wenn C = 1. Das nennt man
zustandsgesteuert.
Oft sollen Werte aber nur zu einem bestimmten Zeitpunkt übernommen werden. Mit
einem taktflankengesteuerten D-Flipflop werden Werte nur übernommen, wenn C von
0 auf 1 wechselt. Die nächste Abbildung zeigt ein solches taktflankengesteuertes D-
Flipflop. Dass die Übernahme von Daten nur bei steigender Flanke erfolgt, wird mit
einem kleinen Dreieck angezeigt.

D Q

f) Tragen Sie in nachstehende Abbildung geeignete Bauteile und Verbindungen ein,


damit sich das Verhalten eines taktflankengesteuerten D-Flipflops ergibt.

D Q D Q
D C C
136 3 Arithmetische Schaltungen

Soll nicht nur ein einziges Bit abgespeichert werden, sondern mehrere Bits, spricht
man von einem Register. Nachfolgende Abbildung zeigt ein Register, in dem n Bit
abgespeichert werden können.

D Q
n n

g) Tragen Sie in nachstehende Abbildung ein, wie sich ein Register zur Abspeicherung
von n Datenbits aus D-Flipflops aufbauen lässt.

D Q
n n
3.2 Halbaddierer (HA) 137

3.2 Halbaddierer (HA)


Ein Halbaddierer ist eine Schaltung, die zwei Eingangs-Bits xi und yi zu einem Summen-
Bit si und einem Überlauf-Bit ci (c wie carry = Überlauf) addiert.

Eingang xi Eingang yi Summe si Überlauf ci (carry)


0 0 0 0
0 1 1 0
1 0 1 0
1 1 0 1

Die Summe si entspricht einer XOR-Verknüpfung von xi und yi , der Überlauf ci der UND-
Verknüpfung von xi und yi . Damit lässt sich ein Halbaddierer wie folgt implementieren:
xi yi

xi yi

HA
ci si

ci si

Bei der Addition zweier Zahlen müssen nicht nur die einzelnen Stellen xi und yi der
beiden Summanden addiert werden, sondern auch noch ein evtl. auftretender Übertrag
aus der vorangehenden Stelle i 1. Beispiel x = 011011012 , y = 001101102 :

0 1 1 0 1 1 0 1
+ 0 0 1 1 0 1 1 0
1 1 1 1 1

1 0 1 0 0 0 1 1

Es müssen also drei Summanden-Bits (xi , yi , ci 1 ) zu einem Summen-Bit si und einem


Übertragsbit ci addiert werden. Damit ist ein einzelner Halbaddierer zur Addition zweier
Binärzahlen x = xn 1 · 2n 1 + · · · + xi · 2i + · · · + x0 · 20 und y = yn 1 · 2n 1 + · · · + yi · 2i +
· · · + y0 · 20 nicht ausreichend. Ein Halbaddierer kann die Addition einer Binärstelle nur
halb bewerkstelligen.
2.5
138Volladdierer (VA) 111
3 Arithmetische Schaltungen

2.5
3.3 Volladdierer
Volladdierer (VA)
(VA)
Ein
Ein Volladdierer
Volladdierer addiert
addiert drei
drei Summanden
Summanden (x (xii,, yyii und
und ccii 11)) zu
zu einer
einer Summe
Summe und
und einem
einem
Übertrag addiert und damit die Addition einer Binärstelle vollumfänglich bewerkstelligen.
Übertrag und kann damit die Addition einer Binärstelle vollumfänglich bewerkstelligen.

a)
a) Vervollständigen
Vervollständigen Sie
Sie nachfolgende
nachfolgende Wertetabelle
Wertetabelle eines
eines Volladdierers.
Volladdierers.

ci 1 yi xi ci si

0 0 0 0 0

0 0 1 0 1

0 1 0 0 1

0 1 1 1 0

1 0 0 0 1

1 0 1 1 0

1 1 0 1 0

1 1 1 1 1

b) Kann die durchgeführte Addition vom entworfenen Halbaddierer gelöst werden?

b) Tragen Sie in nachfolgende Abbildung (links) eine Implementierung einer


Volladdierer-Schaltung ein.
c) Wie müsste ein Addierer aussehen, damit die oben durchgeführte Addition be-
xi kann? yi
rechnet werden ci-1

xi yi ci-1

VA

ci si

ci si
3.4 Ripple-Carry-Addierer/Subtrahierer 139

c) Wieviele Gatterlaufzeiten ⌧ benötigt der Volladdierer, bis an seinen Ausgängen


jeweils das korrekte Signal anliegt?

3.4 Ripple-Carry-Addierer/Subtrahierer
Beim Ripple-Carry-Addierer werden mehrere Volladdierer so verschaltet, dass sich damit
die Summe zweier Summanden berechnen lässt.

a) Skizzieren Sie, wie n Volladdierer zusammengeschaltet werden müssen, damit aus


den zwei n Bit langen Summanden x und y die n Bit lange Summe s berechnet
wird.

xn-1 … x2 x1 x0

yn-1 … y2 y1 y0

xi yi ci-1 xi yi ci-1 xi yi ci-1 xi yi ci-1

VA VA VA VA

ci si ci si ci si ci si

sn-1 … s2 s1 s0

Die Ripple-Carry-Schaltung wendet – unabhängig von der verwendeten Zahlencodie-


rung – stets die selben Operationen auf die angelegten Bits an. Da bei vorzeichen-
loser Codierung binärer Festkommazahlen und bei der Zahlencodierung im Zweier-
140 3 Arithmetische Schaltungen

Komplement identische Bewegungen auf dem Zahlenring identische Wertänderungen


zur Folge haben, liefert die Ripple-Carry-Schaltung nicht nur bei vorzeichenlose Fest-
kommazahlen korrekte Ergebnisse, sondern auch bei vorzeichenbehafteten Zahlen im
Zweier-Komplement. (Das gilt jedoch nur, wenn keine Überläufe auftreten.)
Die Ripple-Carry-Schaltung kann also nicht nur addieren, sondern auch subtrahieren.
Dazu muss der zu subtrahierenden Wert zunächst negiert (Vorzeichen ändern) und
anschließend addiert werden: x y = x + ( y ).

b) Tragen Sie in nachstehende Schaltung Verbindungslinien und Schaltungselemente


ein, so dass die Ripple-Carry-Schaltung nicht nur addieren sondern auch subtra-
hieren kann.

xn-1 … x2 x1 x0

yn-1 … y2 y1 y0

xi yi ci-1 xi yi ci-1 xi yi ci-1 xi yi ci-1

VA VA VA VA

ci si ci si ci si ci si

sn-1 … s2 s1 s0

c) Zeichnen Sie in obige Ripple-Carry-Schaltung den kritischen Pfad ein. Wieviele


Gatterlaufzeiten ⌧ benötigt die Ripple-Carry-Schaltung zur Subtraktion zweier n
Bit breiter Festkommazahlen? Wieviel im Fall n = 64?
3.5 Carry-Look-Ahead 141

3.5 Carry-Look-Ahead
Bei der Carry-Look-Ahead-Technik werden die Überträge der einzelnen Volladdierer
durch zusätzliche Logik im Voraus (engl. to look ahead = vorausschauen) berechnet.
Dadurch verringert sich die Ausführungszeit, da das ‘‘durchrippeln’’ des Übertrags von
der niederwertigsten bis zur höchstwertigsten Stelle vermieden wird.
Die Grundidee ist folgende: Ein Volladdierer VAi liefert an seinem Ausgang ci genau
dann einen Übertrag, wenn
• der Volladdierer VAi den Übertrag ci aus den Eingangswerten xi und yi selbst
generiert (engl. generate, gi = 1), oder
• der Volladdierer VAi den Übertrag ci nicht selbst aus xi und yi generiert,
aber aufgrund der Werte von xi und yi einen am Eingang ci 1 anliegenden
Überlauf an den Ausgang ci weiterleitet (engl. propagate, pi = 1) und gleichzeitig
Volladdierer VAi 1 einen Überlauf generiert (gi 1 = 1), oder
• VAi und VAi 1 einen Übertrag weiterleiten (pi = 1, pi 1 = 1) und VAi 2 einen
Überlauf generiert (gi 2 = 1), oder
• VAi , VAi 1 und VAi 2 einen Übertrag weiterleiten (pi = 1, pi 1 = 1, pi 2 = 1)
und VAi 3 einen Überlauf generiert (gi 3 = 1), oder ...

Der Überlauf ci eines Volladierers lässt sich damit wie folgt bestimmen:

ci = gi _ (pi ^ gi 1) _ (pi ^ pi 1 ^ gi 2) _ (pi ^ pi 1 ^ pi 2 ^ gi 3) _ ...

Nachfolgende Abbildung zeigt ein Modell des generate/propagate-Schemas. ci = 1


entspricht einer leuchtenden Lampe, im Fall ci = 0 leuchtet die Lampe nicht.

gi gi 1 gi 2 gi 3

pi pi 1 pi 2 pi 3

Es gilt:
• gi = 1: VAi generiert aus den Eingangssignalen xi und yi einen Überlauf ci .
• gi = 0: Die Werte der an VAi anliegenden Eingangssignale xi und yi generieren
nicht ‘‘aus sich heraus’’ einen Überlauf ci . Ein Überlauf ci wird aber trotzdem
noch generiert, wenn bei VAi durch xi und yi ein Überlauf weitergeleitet wird
(d.h. bei VAi gilt pi = 1) und bei VAi gleichzeitig gilt ci 1 = 1.
142 3 Arithmetische Schaltungen

• pi = 1: VAi leitet den am Eingang ci 1 anliegenden Wert an den Ausgang ci


weiter.
• pi = 0: VAi der am Eingang ci 1 von VAi anliegende Wert hat keinen Einfluss
auf den Ausgang ci von VAi .

Betrachten Sie nachfolgende Implementierung eines Volladdierers.


xi yi ci-1

ci si

a) Wann generiert der Volladdierer einen Überlauf, d.h. bei welchen Werten von xi
und yi gilt ci = 1?

b) Wann leitet der Volladdierer einen Überlauf weiter, d.h. bei welchen Werten von xi
und yi gilt für einen Volladdierer ci = ci 1 ?
3.5 Carry-Look-Ahead 143

Einstufige Carry-Look-Ahead-Schaltung
Nachfolgende Abbildung zeigt den Aufbau eines 4 Bit Carry-Look-Ahead-Addierers.
x2 x2 x1 x0

y2 y2 y1 y0

0 1 0 1 0 1 0 1

c3 sub/
add

g3 p3 g2 p2 g1 p1 g0 p0

x3 y3 c2 x2 y2 c1 x1 y1 c0 x0 y0 c-1

VA VA VA VA
c3 s3 c2 s2 c1 s1 c0 s0

s3 s2 s1 s0

Die von den Volladdierern berechneten Überträge ci werden nicht verwendet. Stattdes-
sen werden die Eingänge ci 1 der Volladdierer VAi aus den Generate- und Propagate-
Signalen, welche wiederum aus xi und yi bestimmt werden, abgeleitet. Mit steigender
Wortbreite n steigt die Komplexität der zur Bestimmung der Eingangssignale ci 1 not-
wendigen Schaltungen jedoch stark an: Mit zunehmender Stellenzahl n steigt
• die Anzahl der Gatter, die für einen Volladdierer zur Bestimmung der Überträge
benötigt werden,
• die Anzahl der pro Gatter benötigten Eingänge (Limitierung durch Fan-In),
• die Anzahl der an pi und gi angeschlossenen Gatter (Limitierung durch Fan-Out).

Limitierungen durch Fan-In/Out können durch eine baumartige Verzweigung der Signale
mit zusätzlichen Gattern/Treibern aufgehoben werden. Der hohen Anzahl an Gattern
kann durch eine Kaskadierung entgegengewirkt werden.
144 3 Arithmetische Schaltungen

Bei der gezeigten Carry-Look-Ahead-Schaltung muss das Signal p0 auf n Gatter verteilt
werden. Nehmen Sie an, dass an einen Gatterausgang maximal vier Gattereingänge
angeschlossen werden dürfen, d.h. Fan-Out = 4.

a) Skizzieren Sie die für n = 64 notwendige Baumstruktur, über die p0 verteilt wird.
Zeichnen Sie den kritischen Pfad ein. Wieviele zusätzliche Gatterlaufzeiten ergeben
sich durch die Baumstruktur auf dem kritischen Pfad?

Bei der gezeigten Carry-Look-Ahead-Schaltung wird das Signal c3 durch die ODER-
Verknüpfung von fünf Signalen bestimmt. Im Fall n = 64 wird c63 (Überlauf-Bit Carry-Out)
aus der ODER-Verknüpfung von 65 Signalen bestimmt. Nehmen Sie an, dass Gatter
mit > 4 Eingängen in Baumstruktur aus Gattern mit 1, 2, 3 oder 4 Eingängen aufgebaut
werden.

b) Skizzieren Sie für n = 64 eine baumartige Realisierung der ODER-Verknüpfung


zur Erzeugung des Signals c63 . Wieviele Gatterlaufzeiten werden auf dem längsten
Pfad für die ODER-Verknüpfung benötigt?
3.5 Carry-Look-Ahead 145

Kaskadierung von Carry-Look-Ahead-Schaltungen


Mit einer Kaskadierung kann der mit großer Wortbreite einhergehenden großen An-
zahl an Gattern entgegengewirkt werden. Dazu werden Carry-Look-Ahead-Schaltungen
hoher Wortbreite aus mehreren Carry-Look-Ahead-Schaltungen niedrigerer Wortbreite
zusammengesetzt. Nachfolgende Abbildung zeigt eine Erweiterung der bekannten 4 Bit
Carry-Look-Ahead-Schaltung zur Ausgabe von Generate- und Propagate-Signalen.
x y

3 2 1 0
3 3 2 2 1 1 0 0

0 1 0 1 0 1 0 1

G inv

g3 p3 g2 p2 g1 p1 g0 p0

x3 y3 c2 x2 y2 c1 x1 y1 c0 x0 y0 c-1

VA VA VA VA
c3 s3 c2 s2 c1 s1 c0 s0
P C

3 2 1 0

Zur Zusammenfassung mehrerer Carry-Look-Ahead-Schaltungen werden die Generate-


/Propagate-Signale mit einer sog. Carry-Look-Ahead-Einheit verbunden.

x
y
4 4 4 4 4 4 4 4 inv.
1

CLA CLA CLA CLA

4 4 4 4
s
G3P3 C3 G2P2 C2 G1P1 C1 G0P0 C0
Carry-Look-Ahead-Einheit
GG0 PP0 CC0
146 3 Arithmetische Schaltungen

Die Carry-Look-Ahead-Einheit berechnet aus den Eingangssignalen CC0 , P0 , P1 , P2 , P3 ,


G0 , G1 , G2 und G3 die Überträge C0 , C1 , C2 und C3 und leitet diese an die jeweiligen
Carry-Look-Ahead-Schaltungen weiter.
Da Generate-/Propagate-Signale auf zwei unterschiedlichen Hierarchie-Ebenen berech-
net werden, spricht man von einer zweistufigen Carry-Look-Ahead-Schaltung. Über die
Ein-/Ausgänge CC0 , PP0 und GG0 können mehrere 16 Bit Carry-Look-Ahead-Schaltungen
zu einer Carry-Look-Ahead-Schaltung mit noch größerer Wortbreite, z.B. 64 Bit, zusam-
mengesetzt werden.

a) Wie muss die zweistufigen Carry-Look-Ahead-Schaltung zur Subtraktion beschal-


tet werden?

b) Hängen die Signale G und P von Carry-In-Signal C ab? Warum?

c) Bestimmen Sie die Anzahl der Gatterlaufzeiten ⌧ für die einstufige 4 Bit Carry-
Look-Ahead-Schaltung bei einer Subtraktion für den Fall Fan-In = 4.
3.5 Carry-Look-Ahead 147

d) Bestimmen Sie die Anzahl der Gatterlaufzeiten ⌧ falls Fan-In = 2.


148 3 Arithmetische Schaltungen

Im Folgenden wird die Carry-Look-Ahead-Einheit betrachtet.

x
y
4 4 4 4 4 4 4 4 inv.
1

CLA CLA CLA CLA

4 4 4 4
s
G3P3 C3 G2P2 C2 G1P1 C1 G0P0 C0
Carry-Look-Ahead-Einheit
GG0 PP0 CC0

e) Bestimmen Sie die Signale C0 , C1 , C2 und C3 in Abhängigkeit der Signale CC0 , P0 ,


P1 , P2 , P3 , G0 , G1 , G2 und G3 .

f) Bestimmen Sie die Signale GG0 und PP0 in Abhängigkeit der Signale P0 , P1 , P2 ,
P3 , G0 , G1 , G2 und G3 .
3.5 Carry-Look-Ahead 149

g) Bestimmen Sie für Fan-In = 4 die Anzahl der Gatterlaufzeiten ⌧ der Carry-Look-
Ahead-Einheit von den Eingängen zu den Ausgängen C3 , GG0 und PP0 .

h) Skizzieren Sie für Fan-In = 2 eine Gatterschaltung zur Bestimmung von PP0 .
Bestimmen Sie die maximale Anzahl an Gatterlaufzeiten ⌧ .

i) Skizzieren Sie für Fan-In = 2 eine Gatterschaltung zur Bestimmung von GG0 .
Zeichnen Sie den kritischen Pfad ein und bestimmen Sie die maximale Anzahl an
Gatterlaufzeiten ⌧ .
150 3 Arithmetische Schaltungen

T j) Skizzieren Sie für Fan-In = 2 eine Gatterschaltung zur Bestimmung von C3 .


Zeichnen Sie den kritischen Pfad ein und bestimmen Sie die maximale Anzahl an
Gatterlaufzeiten ⌧ .

Nehmen Sie die für Fan-In = 4 bestimmten Gatterlaufzeiten an, vgl. c), f), g).

k) Bestimmen Sie die maximale Gatterlaufzeit der zweistufigen 16 Bit Carry-Look-


Ahead-Schaltung zur korrekten Bestimmung von s.

l) Bestimmen Sie die maximale Gatterlaufzeit der zweistufigen 16 Bit Carry-Look-


Ahead-Schaltung zur korrekten Bestimmung von PP0 .
3.5 Carry-Look-Ahead 151

m) Bestimmen Sie die maximale Gatterlaufzeit der zweistufigen 16 Bit Carry-Look-


Ahead-Schaltung zur korrekten Bestimmung von GG0 .

Nachfolgende Abbildung zeigt eine dreistufige Carry-Look-Ahead-Schaltung zur Verar-


beitung von 64 Bit breiten Zahlen.
x y
64 64

add/sub

CLA-Einheit d CLA-Einheit c CLA-Einheit b CLA-Einheit a


GG3 PP3 CC3 GG2 PP2 CC2 GG1 PP1 CC1 GG0 PP0 CC0

CLA-Einheit e

CC4
Überlauf-
Erkennung

64
s

n) Bestimmen Sie die max. Gatterlaufzeit zur Berechnung von CC3 für Fan-In = 4.
152 3 Arithmetische Schaltungen

o) Bestimmen Sie die maximale Gatterlaufzeit zur korrekten Bestimmung von s für
Fan-In = 4.

p) Bestimmen Sie die maximale Gatterlaufzeit zur korrekten Bestimmung des Carry-
Outs CC4 für Fan-In = 4.
3.7 Kombinatorischer Multiplizierer 153

3.6 Addition und Subtraktion von Gleitkommazahlen


Zur Addition von Gleitkommazahlen wird auf Festkomma-Addierer und -Subtrahierer
zurückgegriffen. Zwei positive Gleitkommazahlen können wie folgt addiert werden:
• Als Exponent des Ergebnisses wird der größere Exponent verwendet
• Bilden der Differenz der beiden Exponenten
• Mantisse der Zahl mit dem kleineren Exponenten zusammen mit der führenden
‘‘1,’’ um die zuvor berechnete Differenz nach rechts schieben
• Beide Mantissen addieren
• Falls Ergebnis nicht in Form ‘‘1,...’’ ist, Mantisse um 1 Stelle nach rechts
schieben und 1 zum Ergebnis-Exponenten addieren (= Re-Normalisieren)

Um Gleitkommazahlen zu subtrahieren, kann wie oben vorgegangen werden, wenn der


Subtrahend negiert wird. Das gleiche gilt für die Addition von Zahlen unterschiedlichen
Vorzeichens.

3.7 Kombinatorischer Multiplizierer


Bei der Multiplikation gilt allgemein:
Multiplikator · Multiplikand = Produkt

Mit Multiplikator x und Multiplikand y berechnet sich bei vorzeichenlosen Zahlen das
Produkt z zu:

x3 x2 x1 x0 · y3 y2 y1 y0
x 0 · y3 x0 · y 2 x0 · y1 x 0 · y0
+ x1 · y3 x 1 · y2 x1 · y 1 x1 · y0
+ x2 · y 3 x2 · y2 x 2 · y1 x2 · y 0
+ x 3 · y3 x3 · y 2 x3 · y1 x 3 · y0
= z7 z6 z5 z4 z3 z2 z1 z0

Die Multiplikation zweier n Ziffern breiter Zahlen ergibt ein 2n breites Produkt. Das
Produkt berechnet sich als Summe von n Teilprodukten.
Die Multiplikation der Einzel-Terme xi · yj entspricht einer logischen UND-Verknüpfung.
Die Addition der Teilprodukte xi · yj kann mit Halb- und Volladdierern durchgeführt
werden.
154 3 Arithmetische Schaltungen

a) Tragen Sie in nachfolgende Abbildung Verbindungen zur Realisierung der vorzei-


chenlosen Multiplikation ein.
x3 x2 x1 x0 · y3 y2 y1 y0
x 0 · y3 x0 · y 2 x0 · y1 x 0 · y0
Eigene Lösung: + x1 · y3 x 1 · y2 x1 · y 1 x1 · y0
+ x2 · y 3 x2 · y2 x 2 · y1 x2 · y 0
+ x 3 · y3 x3 · y 2 x3 · y1 x 3 · y0
= z7 z6 z5 z4 z3 z2 z1 z0

x3 x2 x1 x0 · y3 y2 y1 y0

a b a b cin a b cin a b

HA VA VA HA
cout s cout s cout s cout s

a b cin a b cin a b cin a b

VA VA VA HA
cout s cout s cout s cout s

a b cin a b cin a b cin a b

VA VA VA HA
cout s cout s cout s cout s

z7 z6 z5 z4 z3 z2 z1 z0
3.7 Kombinatorischer Multiplizierer 155

Zur Mitschrift:

x3 x2 x1 x0 · y3 y2 y1 y0
x 0 · y3 x0 · y 2 x0 · y1 x 0 · y0
+ x1 · y3 x 1 · y2 x1 · y 1 x1 · y0
+ x2 · y 3 x2 · y2 x 2 · y1 x2 · y 0
+ x 3 · y3 x3 · y 2 x3 · y1 x 3 · y0
= z7 z6 z5 z4 z3 z2 z1 z0

x3 x2 x1 x0 · y3 y2 y1 y0

a b a b cin a b cin a b

HA VA VA HA
cout s cout s cout s cout s

a b cin a b cin a b cin a b

VA VA VA HA
cout s cout s cout s cout s

a b cin a b cin a b cin a b

VA VA VA HA
cout s cout s cout s cout s

z7 z6 z5 z4 z3 z2 z1 z0
156 3 Arithmetische Schaltungen

b) Tragen Sie in die Multiplizierer-Schaltung den längsten Pfad ein. Wie lange (in
Gatterlaufzeiten ⌧ ) dauert die Ausführung?

Der Hardwareaufwand der gezeigten Schaltung ist sehr hoch: Mit steigender Wortbreite
n steigt der notwendige Hardwareaufwand mit ca. n2 .
3.8 Sequentieller Multiplizierer 157

3.8 Sequentieller Multiplizierer


Mit einer sequentiellen Schaltung kann der Hardwareaufwand reduziert werden. Die
nächste Abbildung skizziert eine sequentielle Schaltung, die zur Multiplikation vorzei-
chenloser Zahlen der Wortbreite n = 4 verwendet werden kann.

MR y3 y2 y1 y0

Add PR0

PR 0 0 0 0 0 x3 x2 x1 x0

Das Multiplikand-Register MR ist n = 4 Bit breit, das Produkt-Register PR ist 2n + 1 = 9


Bit breit. PR0 ist das niederwertigste Bit des im Produktregister gespeicherten Werts.
Der sequentielle Ablauf ist wie folgt:
• Zunächst wird der Multiplikand im Multiplikand-Register MR und der Multipli-
kator in den unteren n Bits des Produkt-Registers abgelegt. Die restlichen Bits
des Produktregisters werden mit 0 initialisiert.
• Anschließend wird iterativ n = 4 mal folgendes ausgeführt:
• Wenn PR0 = 1, dann
• wird der in MR stehende Wert zu den Bits PR7 ... PR4 des
Produktsregisters addiert; ein ggf. auftretender Überlauf wird
in PR8 abgelegt; anschließend
• wird das gesamte Produktregister um eine Stelle nach rechts
geschoben; dabei wird von links mit Nullen aufgefüllt.

• Wenn PR0 = 0, dann


• wird keine Addition durchgeführt, sondern lediglich das ge-
samte Produktregister um eine Stelle nach rechts geschoben;
dabei wird wieder von links mit Nullen aufgefüllt.

• Nach n = 4 Iterationen (=Runden) steht im Produktregister das Ergebnis.


158 3 Arithmetische Schaltungen

a) Tragen Sie in folgende Abbildung für n = 4 die Registerinhalte ein, die sich für die
Multiplikation 13 · 5 = 65 ergeben.

Add

Initialisierung

Nach Addition: Erste Runde

Nach Schieben: Erste Runde

Nach Addition: Zweite Runde

Nach Schieben: Zweite Runde

Nach Addition: Dritte Runde

Nach Schieben: Dritte Runde

Nach Addition: Vierte Runde

Nach Schieben: Vierte Runde


3.8 Sequentieller Multiplizierer 159

Nachfolgende Abbildung zeigt den (unvollständigen) Aufbau einer Schaltung zur Imple-
mentierung des gezeigten Multiplikationsverfahrens.

b) Vervollständigen Sie die Schaltung so, dass sie vorzeichenlose Binärzahlen multi-
pliziert.

Steuerung

Multiplikator
3.7 Multiplizierer 141
n
Init/>>1
Sequentielle
0..n-1 Schaltung zur 0..n-1
Multiplikation vorzeichenloser Zahlen
PR
Mit einer sequentiellen Schaltung kann der Hardwareaufwand deutlich reduziert werden.
Die nächste Abbildung skizziert eine sequentielle Schaltung, die zur Multiplikation von
n..2n n..2n-1
vorzeichenloser Zahlen der Wortbreite n = 4 verwendet werden kann:
Produkt
MR y3 y2 y1 y0

2n
Add PR0

PR 0 0 0 0 0 x3 x2 x1 x0
Addierer
MR Das Multiplikand-Register MR ist n = 4 Bit breit, das Produkt-Register PR ist 2n + 1 = 9
Bit breit. PR0 ist das niederwertigste Bit des im Produktregister gespeicherten Werts.
Multiplikand
Der Ablauf ist wie folgt:
n • Zunächst wird der Multiplikand im Multiplikand-Register MR und der Multipli-
kator in den unteren n Bits des Produkt-Registers abgelegt. Die restlichen Bits
des Produktregisters werden mit 0 initialisiert.
• Anschließend wird iterativ n = 4 mal folgendes ausgeführt:
• Wenn PR0 = 1, dann
• wird der in MR stehende Wert zu den Bits PR7 ... PR4 des
Produktsregisters addiert; ein ggf. auftretender Überlauf wird
in PR8 abgelegt; anschließend
• wird das gesamte Produktregister um eine Stelle nach rechts
geschoben; dabei wird von links mit Nullen aufgefüllt.

• Wenn PR0 = 0, dann


• wird keine Addition durchgeführt, sondern lediglich das ge-
samte Produktregister um eine Stelle nach rechts geschoben;
dabei wird wieder von links mit Nullen aufgefüllt.

• Nach n = 4 Iterationen (=Runden) steht im Produktregister das Ergebnis.


160 3 Arithmetische Schaltungen

c) Vervollständigen Sie nachfolgend abgebildeten Zustands-Automaten so, dass er


den Multiplizierer wie gewünscht steuert. Nehmen Sie an, dass Sie zur Detektion
des Schleifen-Abbruchs das Signal Runde_n zur Verfügung haben, das Ihnen
anzeigt, ob Sie bereits alle Runden durchlaufen haben (Runde_n = 1) oder noch
nicht (Runde_n = 0).

1 2 3
Initialisierung Initialisierung Addieren
clk_mkand= clk_mkand= clk_mkand=
clk_produkt= clk_produkt= clk_produkt=
multiplexer= multiplexer= multiplexer=
init/>>1= init/>>1= init/>>1=

6 5 4
Schieben Schieben Addieren
clk_mkand= clk_mkand= clk_mkand=
clk_produkt= clk_produkt= clk_produkt=
multiplexer= multiplexer= multiplexer=
init/>>1= init/>>1= init/>>1=

7
Ende
clk_mkand=
clk_produkt=
multiplexer=
init/>>1=
3.8 Sequentieller Multiplizierer 161

Multiplexer-basierte Implementierung der Steuerung


Für den Fall n = 4 soll die Steuerung wie folgt implementiert werden:

clk_mkand
clk_produkt
Kombinatorische multiplexer
Schaltung init/>>1

3
2
...
D4 Q4
D3 Q3
D2 Q2

D0 Q0

clk
...
2
3

PR0

Das Zustandsregister speichert die Information über


• den aktuellen Zustand (d.h. in welchem Zustand des Zustandsdiagramms sich
die Steuerung gerade befindet) und
• den Rundenzähler (d.h. welche Iterations-Runde gerade ausgeführt wird).

a) In welchen Bits des Zustandsregisters wird


• der aktuelle Zustand und
• die aktuelle Runde

gespeichert?
162 3 Arithmetische Schaltungen

b) Tragen Sie in nachfolgende Abbildung die Eingangswerte des Multiplexers ein, die
die Ausgangs-Funktion der Steuerung implementieren. Womit muss der Steuerein-
gang des Multiplexers verbunden werden?

0
4

1
4

2 3
4 clk_mkand
3 2
4
clk_produkt
4 1
4 multiplexer
4
0
init/>>1
5
4

6
4

7
4
3.8 Sequentieller Multiplizierer 163

c) Tragen Sie in nachfolgende Abbildung diejenigen Eingangswerte ein, welche die


Zustands-Übergangs-Funktion aller unbedingter Verzweigungen implementieren.

Aktueller
Zustand
3

0
3

1
3

2
3
2
3
3 1
3
4 0
3

5
3

6
3

7
3

d) Tragen Sie in nachfolgende Abbildung ein Schaltung ein, die den Folgezustand
des Zustands 2 liefert.

Folgezustand
PR0
3 von Zustand 2
164 3 Arithmetische Schaltungen

e) Tragen Sie in nachfolgende Abbildung eine Schaltung ein, die im Zustand 5 den
Eingang Runde um 1 erhöht und den neuen Rundenwert am Ausgang bereitstellt
(00 ! 01, 01 ! 10, 10 ! 11, 11 ! 00). In Zuständen 6= 5 soll die am Eingang
angelegte Runde an den Ausgang durchgereicht werden.

Zustand
(Bit 2 ... 0) 3

Neue Runde
2 (Bit 4, 3)

Runde
(Bit 4, 3) 2

f) Tragen Sie in nachfolgende Abbildung eine Implementierung des Runde_n-


Detektors ein, der in Runde 1, 2 und 3 den Ausgang auf Low-Pegel legt und
in Runde 4 auf High-Pegel (Runde 1 , 01, Runde 2 , 10, Runde 3 , 11, Runde
4 , 00).

Runde Runde_n
(Bit 4,3) 2 1
3.8 Sequentieller Multiplizierer 165

g) Tragen Sie in nachfolgende Abbildung eine Multiplexer-basierte Schaltung ein, die


in Abhängigkeit der Eingänge Runde_n und PR0 den auf Zustand 6 folgenden
Zustand am Ausgang ausgibt.

Runde_n
1

Folgezustand
von Zustand 6
3

PR0
1

h) Tragen Sie in nachfolgende Abbildung eine Schaltung ein, die den auf Zustand
6 folgenden Zustand mit Hilfe eines Inverters und zweier ODER-Gatter bestimmt
und am Ausgang ausgibt.

Runde_n
1

Folgezustand
3 von Zustand 6

PR0
1
166 3 Arithmetische Schaltungen

ROM-basierte Implementierung der Steuerung


In diesem Abschnitt soll die Multiplizierer-Steuerung mit nachfolgend abgebildeter ROM-
basierten Schaltung implementiert werden.

clk_mkand
clk_produkt
multiplexer
init/>>1

D4
D3
D2
D1
8 7 6 5 4 3 2 1 0 D0

clk
ROM
Q4
Q3
Q2
Q1
Q0

5 4 3 2 1 0

PR0

immer PR0 = 1
1 2 3
Initialisierung Initialisierung Addieren
clk_mkand= 0 clk_mkand= 1 clk_mkand= 0
clk_produkt= 0 clk_produkt= 1 clk_produkt= 0
multiplexer= 0 multiplexer= 0 multiplexer= 1
init/>>1= 0 init/>>1= 0 init/>>1= 0
Runde_n = 0 && PR0 = 0 PR0 = 0 immer

6 5 4
Schieben Schieben Addieren
clk_mkand= 0 clk_mkand= 0 clk_mkand= 0
clk_produkt= 1 clk_produkt= 0 clk_produkt= 1
multiplexer= X multiplexer= X multiplexer= 1
init/>>1= 1 init/>>1= 1 init/>>1= 0
immer immer
Runde_n = 1

7
Ende
clk_mkand= 0
clk_produkt= 0
Runde_n = 0 && PR0 = 1
multiplexer= X
init/>>1= X
immer
3.8 Sequentieller Multiplizierer 167

a) Welche Organisation hat das ROM?

Im ROM wird durch die Adress-Bits 0, 1 und 2 der Zustand festgelegt, durch die
Adress-Bits 3 und 4 der Rundenzähler, der die Anzahl der Iterationen mitzählt.
Zum Start der Multiplikation wird das Zustandsregister mit [Q0, Q1] = [0, 0] und [Q2, Q3,
Q4] = [0, 0, 1] initialisiert, d.h. Runde 00, Zustand 001.

b) Geben Sie den ROM-Inhalt an, der zur Implementierung der Zustände 1 und 2
benötigt wird.

PR0 Runde Zustand Ausgang Folgerunde Folgezust.

Zust. 1

Zust. 2

c) Geben Sie den Inhalt des ROM-Speichers für Zustand 3 an.

PR0 Runde Zustand Ausgang Folgerunde Folgezust.

Zust. 3
168 3 Arithmetische Schaltungen

d) Geben Sie den Inhalt des ROM-Speichers für Zustand 4 an.

PR0 Runde Zustand Ausgang Folgerunde Folgezust.

Zust. 4

e) Geben Sie den Inhalt des ROM-Speichers für Zustand 5 an.

PR0 Runde Zustand Ausgang Folgerunde Folgezust.

Zust. 5
3.8 Sequentieller Multiplizierer 169

f) Geben Sie den Inhalt des ROM-Speichers für Zustand 6 an.

PR0 Runde Zustand Ausgang Folgerunde Folgezust.

Zust. 6

g) Geben Sie den Inhalt des ROM-Speichers für Zustand 7 an.

PR0 Runde Zustand Ausgang Folgerunde Folgezust.

Zust. 7
170 3 Arithmetische Schaltungen

Multiplikation vorzeichenbehafteter Zahlen


Zur Multiplikation vorzeichenbehafteter Zahlen (2er-Komplement) kann auf die Schaltung
für vorzeichenlose Multiplikation zurückgegriffen werden, wenn negative Zahlen zuerst
negiert werden, das Vorzeichen separat berechnet wird (XOR) und das Ergebnis ggf.
noch invertiert wird.
Es gibt jedoch auch noch andere Verfahren wie z.B. den sog. Baugh-Wooley-
Multiplizierer. Dieser ist sehr ähnlich wie der kombinatorische Multiplizierer für vor-
zeichenbehaftete Zahlen aufgebaut, verwendet jedoch an einigen Stellen ein NICHT-
UND-Gatter statt eines UND-Gatters sowie einen zusätzlichen Halbaddierer für die
höherwertigste Ergebnis-Stelle.

Multiplikation von Gleitkomma-Zahlen

• Zur Multiplikation von Gleitkommazahlen müssen die Mantissen inkl. führender


‘‘1,’’ als Festkommazahlen multipliziert werden.
• Die Exponenten werden addiert. Der Offset ‘‘k’’ ist nach der Addition doppelt
berücksichtigt und muss deswegen vom Ergebnis noch einmal subtrahiert
werden.
• Zur Re-Normalisierung wird die Ergebnis-Mantisse nach rechts geschoben und
zum Exponenten die Anzahl der geschobenen Stellen addiert.
3.9 Subtraktion 171

3.9 Subtraktion

Allgemein
Bezeichnungen: Minuend - Subtrahend = Differenz
Die Subtraktion zweier Zahlen wird stellenweise ausgeführt. Dabei kann es vorkommen,
dass eine größere Zahl von einer kleineren Zahl subtrahiert werden muss. Um dies zu
bewerkstelligen, kann aus der nachfolgenden Stelle ein Wert geborgt werden.

Beispiel:

11
2 + 1 1 + 1 11

4 3 2 1
- 1 2 3 4
= 3 0 8 7

• 4 und wieviel ist 1? ) geht nicht ) 1 von 10-er Stelle borgen ) aus 1 wird 11
• 4 und wieviel ist 11? ) 7
• Durch das Borgen steht an der Zehner-Stelle jetzt nur noch eine 1 statt einer 2
• 3 und wieviel ist 1? ) geht nicht ) 1 von 100-er Stelle borgen ) aus 1 an der
Zehner-Stelle wird 11
• 3 und wieviel ist 11? ) 8
• Durch das Borgen steht an der Hunderter-Stelle jetzt nur noch eine 2 statt einer
3
• 2 und wieviel ist 2? ) 0
• 1 und wieviel ist 4 ) 1

Statt beim Borgen die Minuenden-Stellen zu verkleinern, kann die Subtrahenden-Stelle


vergrößert werden (wie Übertrag).

4 3 2 1
- 1 2 3 4
0 1 1
= 3 0 8 7

Das Ergebnis ist das gleiche, da die Differenz zwischen Minuenden-Stelle und
Subtrahenden-Stelle gleich bleibt. Beim Borgen über mehrere Stellen hinweg kann
einem dieses Vorgehen jedoch leichter fallen.
172 3 Arithmetische Schaltungen

a) Subtrahieren Sie 11 - 6 = 5 im Binärsystem bei einer Wortbreite n = 4.

b) Subtrahieren Sie 12 - 5 = 7 im Binärsystem bei einer Wortbreite n = 4.

T c) Subtrahieren Sie 14 - 11 = 3 im Binärsystem bei einer Wortbreite n = 4.


3.9 Subtraktion 173

Halb-Subtrahierer
Ein Halb-Subtrahierer ist ein Schaltung, die ein Eingangs-Bit yi von einem Eingangs-Bit
xi subtrahiert. Das Ergebnis ist ein Differenz-Bit di und ein Borge-Bit bi (b = borgen =
engl. borrow).

Eingang xi Eingang yi Borgen bi Differenz di


0 0 0 0
0 1 1 1
1 0 0 1
1 1 0 0

Die Differenz di entspricht der XOR-Verknüpfung der Eingänge; bi hat den Wert 1, wenn
der Minuend 0 ist und der Subtrahend 1 ist.
xi yi

xi yi

HS
bi di

bi di

Halbsubtrahierer können Binärzahlen nur halb subtrahieren: Der Halbsubtrahierer an


Stelle i erkennt zwar, ob er ein Bit von Stelle i + 1 borgen musste, kann jedoch selbst
nicht berücksichtigen, ob der Halbsubtrahierer an Stelle i 1 von ihm selbst ein Bit
borgen musste.
3.10 Dividierer 157
174 3 Arithmetische Schaltungen

Voll-Subtrahierer
Voll-Subtrahierer
Im Gegensatz zum Halbsubtrahierer kann ein Vollsubtrahierer berücksichtigen, ob die
Im Gegensatz Stelle
vorangegangene zum Halbsubtrahierer kann
i 1 ein Bit borgen ein Vollsubtrahierer berücksichtigen, ob die
musste.
vorangegangene Stelle i 1 ein Bit borgen musste.
a) Vervollständigen Sie nachfolgende Wertetabelle eines Vollsubtrahierers.
a) Vervollständigen
Tabelle, die in die GrafikSie nachfolgende
eingebettet Wertetabelle eines Vollsubtrahierers.
wurde:

xi yi bi 1 bi di

0 0 0 0 0

0 0 1 1 1

0 1 0 1 1

0 1 1 1 0

1 0 0 0 1

1 0 1 0 0

1 1 0 0 0

1 1 1 1 1

b) Tragen Sie in nachfolgende Abbildung (links) eine Implementierung einer


Vollsubtrahierer-Schaltung ein.

b) Tragen Sie in nachfolgende Abbildung (links) eine Implementierung einer


Ripple-Borrow-Subtrahierer
Vollsubtrahierer-Schaltung ein.
a) Berechnen Siex537 - 48 im Dezimalsystem.
y
i i

b) Berechnen Sie
xi yi

c) Vervollständigen Sie nachfolgende Wertetabelle eines

bi bi-1
b bi-1 VS
3.10 Dividierer

di

di
3.9 Subtraktion 175

Ripple-Borrow-Subtrahierer
Beim Ripple-Borrow Subtrahierer werden n Vollsubtrahierer so verschaltet, dass sich
damit die Differenz d = x y zweier n Bit breiter Zahlen berechnen lässt.

xn-1 … x2 x1 x0

yn-1 … y2 y1 y0

xi yi xi yi xi yi xi yi

bi VS bi-1 bi VS bi-1 bi VS bi-1 bi VS bi-1 0


di di di di

dn-1 … d2 d1 d0

Betrachten Sie den Zahlenring für vorzeichenlose Zahlen.

1111 0000
1110 0001
15 0
1101 14 1 0010
13 2
1100 0011
12 3 Richtung
steigender
11 4 Werte
1011 0100
10 5

1010 9 6 0101
8 7

1001 0110
1000 0111

a) Nehmen Sie an, die Eingangswerte des entworfenen Ripple-Borrow-Subtrahierers


sind vorzeichenlos. Welches Zahlenformat hat die Differenz d? Welche Funktion
hat das ‘‘Borrow Out’’?
176 3 Arithmetische Schaltungen

Betrachten Sie den Zahlenring für Zahlen im Zweier-Komplement:

1111 0000
1110 0001
-1 0
1101 -2 1 0010
-3 2

1100 -4 3 0011
negativ positiv
-5 4
1011 0100
-6 5

1010 -7 6 0101
-8 7

1001 0110
1000 0111

b) Funktioniert der Subtrahierer auch mit dem Zweier-Komplement? Wenn ja: Wie
kann man einen Überlauf feststellen? Wenn nein: Warum nicht?
3.9 Subtraktion 177

c) Tragen Sie in nachfolgende Abbildung eine Schaltung ein, die einen Überlauf von
Zahlen im Zweierkomplement feststellt.

xn-1

yn-1 u

dn-1
178 3 Arithmetische Schaltungen

3.10 Division

Allgemein
Bei der Division gilt allgemein:

Dividend / Divisor = Quotient + Rest

Division zur Basis 10, wie in der Schule gelernt:

9 8 7 6 : 0 0 5 4 = 0 1. Runde

1. Teildividend = 9

Passt 54 in 9? Nein, d.h. 0 mal.

2. Runde
9 8 7 6 : 0 0 5 4 = 0 1

2. Teildividend = 98

Passt 54 in 98? Ja ⇒ Wie oft? 98 - 54 = 44 (1 mal)


44 - 54 = -10 (negativ ⇒ bleibt bei 1 mal)

3. Runde
4 4 7 6 : 0 0 5 4 = 0 1 8

3. Teildividend = 447

Passt 54 in 447? Ja ⇒ Wie oft? 447 - 54 = 393 (1 mal)


393 - 54 = 339 (2 mal)
339 - 54 = 285 (3 mal)
285 - 54 = 231 (4 mal)
231 - 54 = 177 (5 mal)
177 - 54 = 123 (6 mal)
123 - 54 = 069 (7 mal)
069 - 54 = 015 (8 mal)
015 - 54 = -039 (negativ ⇒ bleibt bei 8 mal)

4. Runde
0 1 5 6 : 0 0 5 4 = 0 1 8 2 Rest 4 8

4. Teildividend = 156

Passt 54 in 156? Ja ⇒ Wie oft? 156 - 54 = 102 (1 mal)


102 - 54 = 048 (2 mal)
048 - 54 = -006 (negativ ⇒ bleibt bei 2 mal)
3.10 Division 179

Die Division zur Basis 2 folgt demselben Prinzip wie die Division zur Basis 10. Da der
Teildividend jedoch nur 0 oder 1 mal in den Divisor passen kann, ist die Bestimmung der
jeweiligen Quotienten-Stelle wesentlich einfacher.

a) Berechnen Sie binär vorzeichenlos für n = 4 die Division 13/4 = 3 Rest 1.

T b) Berechnen Sie binär vorzeichenlos für n = 4 die Division 10/3 = 3 Rest 1.


180 3 Arithmetische Schaltungen

Kombinatorischer Dividierer

a) Vervollständigen Sie nachfolgende Abbildung um geeignete Bauelemente und


Verbindungen zu einer Schaltung, die zwei vorzeichenlose 4 Bit breite Zahlen zu
einem Quotienten q und einem Rest r dividiert.

x3 x2 x1 x0 : y3 y2 y1 y0

xi yi xi yi xi yi xi yi

VS VS VS HS
di di di di

xi yi xi yi xi yi xi yi

VS VS VS HS
di di di di

xi yi xi yi xi yi xi yi

VS VS VS HS
di di di di

xi yi xi yi xi yi xi yi

VS VS VS HS
di di di di

q3 q2 q1 q0 Rest: r3 r2 r1 r0
3.10 Division 181

Sequentieller Dividierer
Nachfolgende Abbildung skizziert eine sequentielle Schaltung, die zur Division (hier: x/y)
vorzeichenloser Zahlen der Wortbreite n = 4 verwendet werden kann.

D y3 y2 y1 y0

SUB R0

R 0 0 0 0 x3 x2 x1 x0

Das Divisor-Register D ist n = 4 Bit breit, das Rest-Register R ist 2n = 8 Bit breit.
• Zuerst wird der Dividend in der rechten Hälfte des Rest-Registers R abgelegt;
die linke Hälfte wird mit 0 initialisiert
• Der Divisor wird im Divisor-Register D abgelegt
• Anschließend wird iterativ n = 4 mal folgendes durchgeführt:
• Rest-Register R um eine Stelle nach links schieben, dabei von rechts
mit Nullen auffüllen.
• Der Subtrahierer bestimmt mittels Subtraktion R2n 1 ... n D, ob der
Divisor D in den Teil-Dividenden R2n 1 ... n passt.
• Ist das Ergebnis der Subtraktion positiv, d.h. hat der Divisor in den
Teil-Dividenden reingepasst,
• wird R0 auf 1 gesetzt und
• das Ergebnis der Subtraktion (der Rest) in R2n 1 ... n über-
nommen.

• Der Quotient findet sich in der rechten Hälfte des Rest-Regstiers, d.h. Rn 1 ... 0 ,
der Divisions-Rest in der linken Hälfte, d.h. R2n 1 ... n .
182 3 Arithmetische Schaltungen

a) Tragen Sie in folgende Abbildung für n = 4 die Registerinhalte ein, die sich für die
Division 13 : 4 = 3 Rest 1 ergeben.

a b
SUB
a-b

Initialisierung

Nach Schieben: Erste Runde

Nach Schieben: Zweite Runde

Nach Schieben: Dritte Runde

Nach SUB/ODER: Dritte Runde

Nach Schieben: Vierte Runde

Nach Subtr./ODER: Vierte Runde

Nachfolgende Abbildungen zeigen eine Schaltung, welche die sequentielle Division


implementiert, sowie den zugehörigen Zustandsautomaten.

T b) Tragen Sie in den Zustands-Automaten geeignete Übergänge und Ausgangssi-


gnale so ein, dass der Zustandsautomat die Schaltung in gewünschter Weise
steuert.
3.10 Division 183

Steuerung

0 1 0
Dividend
1..n-1
clk_rest
n Clk
init/<<1
Init/<<1 n

0 Rest 0..n-1
0..n-1
n <<1 2n
1 Rest und
n..2n-1
Quotient
n..2n-1
mux
1 0 2n
neg
clk_div

n n
Clk 0
a-b n
Sub
Divisor
b a
Divisor
n

n n

1 2 3 4
Init Init Schieben Schieben
clk_div = clk_div = clk_div = clk_div =
clk_rest = clk_rest = clk_rest = clk_rest =
ini/<<1 = ini/<<1 = ini/<<1 = ini/<<1 =
mux = mux = mux = mux =

6 5 7
Sub; Rest |= 1 Sub; Rest |= 1 Ende
clk_div = clk_div = clk_div =
clk_rest = clk_rest = clk_rest =
ini/<<1 = ini/<<1 = ini/<<1 =
mux = mux = mux =
184 3 Arithmetische Schaltungen

Die Steuerung der Dividierer-Schaltung wird nun für die Wortbreite n = 4 wie folgt
implementiert:

clk_div
clk_rest
init/<<1
Kombinatorische
mux
Logik 3

2
D4
D3

D2
D0

3 2 Clk
Q4
Q3

Q2
Q0

2 3

neg

T c) In welchen Bits des Zustandsregisters wird der aktuelle Zustand und die Anzahl
der bisher durchgeführten Runden abgespeichert?
3.10 Division 185

Implementierung des Zustandsautomaten mit Multiplexern

T a) Geben Sie für die Eingänge des Multiplexers binär die Ausgangsworte an, mit
denen sich die Ausgangsfunktion des Moore-Automaten ergibt.

Zustand
3

00

11

22
Bit 3: clk_div
33 4 Bit 2: clk_rest
Bit 1: init/<<1
4
Bit 0: mux
5

T b) Geben Sie die Folgezustände für alle unbedingten Verzweigungen an.

Zustand
3

00

11

22

33 3
Folgezustand
4

7
186 3 Arithmetische Schaltungen

T c) Geben Sie eine Multiplexer-Schaltung an, die mittels des Signals runde_n die
Folgezustände des Zustands 6 an ihrem Ausgang bereitstellt.

1 3 Folgezustand
runde_n
von Zustand 6

T d) Geben Sie eine Schaltung zur Bestimmung des Folgezustands von Zustands 6 an,
die ohne Multiplexer auskommt.

1 3 Folgezustand
runde_n
von Zustand 6

T e) Geben Sie eine Multiplexer-Schaltung an, die mittels der Signale runde_n und neg
den Folgezustand des Zustands 4 an ihrem Ausgang bereitstellt.

1
neg

3 Folgezustand
von Zustand 4

1
runde_n
3.10 Division 187

T f) Geben Sie eine kombinatorische Schaltung für den Rundenzähler an, der jedesmal,
wenn sich der Moore-Automat im Zustand 3 befindet, die in Bits 3 und 4 des
Zustandsworts gespeicherte Rundenanzahl um Eins erhöht.

Aktueller 3
Zustand

2 Nächste
Runde

Aktuelle 2
Runde

Der Rundenzähler zählt wie folgt: Runde 1 , 012 , Runde 1 , 102 , Runde 3 , 112 und
Runde 4 , 002 .

T g) Tragen Sie in nachfolgende Abbildung eine kombinatorische Schaltung ein, die in


der 4. Runde, aus dem Rundenzähler das Signal runde_n erzeugt.

Aktuelle 2 1
runde_n
Runde
188 3 Arithmetische Schaltungen

Implementierung des Zustandsautomaten mit Speicherbausteinen


Im Folgenden wird anstelle der kombinatorischen Logik ein ROM-Speicher verwendet.

Multiplexer
Clk_Divisor
Clk_Rest
Init/<<1

Datenaus-
ausgang
8 7 6 5 4 3 2 1 0
D4
D3
D2
D1
D0

Clk
ROM-Speicher
Q4
Q3
Q2
Q1
Q0

5 4 3 2 1 0
Adress-
Eingang

neg

Der ROM-Speicher funktioniert wie folgt: Die Bitkombination, die am Adress-Eingang


anliegt, wird als Adresse interpretiert. Am Datenausgang wird dann das Datenwort
ausgegeben, das an der durch den Adress-Eingang spezifizierte Adresse liegt.
Die sog. Speicherorganisation beschreibt den Speicheraufbau:
• Wie breit (in Bit) sind die Datenworte?
• Wieviele Datenworte können abgespeichert werden?

T a) Geben Sie die Organisation des gezeigten ROM-Speichers an.


3.10 Division 189

T b) Geben Sie den ROM-Inhalt an, der zur Implementierung der Zustände 1 und 2
benötigt wird.

neg Runde Zustand Ausgang Folgerunde Folgezust.

Zust. 1

Zust. 2

T c) Geben Sie den ROM-Inhalt an, der zur Implementierung des Zustands 3 benötigt
wird.

neg Runde Zustand Ausgang Folgerunde Folgezust.

Zust. 3
190 3 Arithmetische Schaltungen

T d) Geben Sie den ROM-Inhalt an, der zur Implementierung des Zustands 4 benötigt
wird.

neg Runde Zustand Ausgang Folgerunde Folgezust.

Zust. 4
4.1 Vom zu lösenden Problem abhängige Schaltung 191

4 Prozessor-Datenpfad

4.1 Vom zu lösenden Problem abhängige Schaltung


Mit den bisher kennengelernten Schaltungen können bereits viele Problemstellungen
gelöst werden. Nachfolgende Schaltung löst die Quadratische Gleichung ax 2 + bx + c =
0. Die Ausgänge 1R und 0R geben an, ob das Ergebnis zwei reelle Lösungen hat
(1R = 0R = 0, eine reelle Lösung hat (1R = 1, 0R = 0) oder keine reelle Lösung hat
(1R = 0, 0R = 1).

b
2 DIV a/b x1
2a
MUL a
a
b
4ac

x2
4ac

DIV a/b
4a
MUL a
4ac
b2

4 MUL b
b2

p
SUB a-b X b
a SUB a-b
a

0 a
b 2
-b
b SUB a-b
MUL
b ADD

n 1
1R

1
0R
c

Das Problem (quadratische Gleichung lösen) wird durch die verwendeten Komponenten
(Multiplizierer, Addierer, ...) und deren Verknüpfungen (z.B. ‘‘ein Eingang von Multiplizierer
1 ist mit der Zahl 2 verknüpft, der andere mit a’’, ...) gelöst.
Soll ein anderes Problem gelöst werden, benötigt man andere Verknüpfungen und
ggf. auch andere Komponenten. Während die Anzahl der Komponenten sowie die
192 4 Prozessor-Datenpfad

möglichen Verknüpfungen generell unbeschränkt sind, ist die Menge der benötigten
unterschiedlichen Rechenkomponenten {Addierer, Subtrahierer, ...} sehr überschaubar.
Diese geringe Menge unterschiedlicher Rechenkomponenten ermöglicht es, Rechen-
Schaltungen zu bauen, die unabhängig vom zu lösenden Problem sind, sog. Universal-
rechner.

4.2 Universalrechner: Schaltung unabhängig vom Problem

Allgemein
Bei einem Universalrechner wird die gemischt parallel/serielle Struktur der Problem-
lösung (vgl. obige Schaltung) serialisiert und der Reihe nach in einzelnen Schritten
bearbeitet. Die durch die Serialisierung anfallenden Zwischenergebnisse werden in
Speicherelementen (Register, Arbeitsspeicher) gesichert. Die Verknüpfung der ein-
zelnen Rechenkomponenten (vgl. obige Abbildung) entsteht dadurch, dass für jeden
Serialisierungs-Schritt ausgewählt wird, welche Werte/Zwischenergebnisse von welchen
Rechenkomponenten verwendet werden sollen und in welchem Speicherelement das
Ergebnis abgelegt werden soll. Durch die Serialisierung muss jede zur Problemlösung
benötigte arithmetische Komponente nur einmal vorhanden sein.

Beispiel-Schaltung
Nachfolgende Abbildung zeigt einen solchen Universalrechner.

Arithmetische Schaltungen
Auf der rechten Seite befinden die arithmetischen Schaltungen, die der Rechner verwen-
den kann. Jede benötigte arithmetische Operation wird durch genau eine entsprechende
Schaltung repräsentiert.

Register als Quell-Operanden


R0, R1, ... , R7 sind Register, in denen die (Zwischen-) Ergebnisse abgelegt werden
können. Mit M3 und M4 werden Operanden ausgewählt, die von den arithmetischen
Schaltungen verarbeitet werden sollen. Hat z.B. M3 den Wert 2 und M4 den Wert 3,
werden die Inhalte von Register R2 und R4 an die arithmetischen Schaltungen angelegt.
Die Eingänge der arithmetischen Schaltungen sind alle miteinander verbunden, d.h. die
Operanden liegen an allen Schaltungen gleichzeitig an.
4.2 Universalrechner: Schaltung unabhängig vom Problem 193

Auswahl der Rechenoperation


Die Auswahl der Rechenoperation (Addition, Subtraktion, ...) erfolgt durch Auswahl des
entsprechenden Ergebnisses mittels M2. Hat z.B. M2 den Wert 1 und M1 den Wert 3,
dann wird das von Addierer A2 berechnete Ergebnis an die Eingänge aller Register R0,
R1, ... R7 gleichzeitig angelegt.

Abspeichern des Ergebnisses, Register als Ziel-Operand


In welches Register das Additions-Ergebnis übernommen werden soll, wird durch den
Demultiplexer D festelegt. Hat z.B. D den Wert 4, so wird der invertierte Takt clk an den
Takteingang von Register R4 angelegt – und Register R4 übernimmt das Ergebnis. Alle
anderen Register werden nicht getaktet und behalten somit ihren ursprünglichen Wert.

10 10
n
MSB
R D23 K …

D14 10 R7 n-10
M3
D13 D 0
7
D12 3 A2
D11
D10 M4 1
6
D9 3
D8 ADD
R6 2
5
D7 M3
clk
A7 D6
D5 3
BZ 3
4

A0 D4
D3
M2
D2 3 0
7 3
D1 M1 R5 a
D0 2 M2
1
6 2 SUB a-b
0
1 b
2
5 1
0
1
A1 R4
3
4 0
M0 Add 1
2
M3
reset 1 0 3 MUL 2
3
0 2 0
7
R3 3
4
1 1
6
5
0 2
5 a
M1 M2
DIV a/b
D R2 3
4
b
a 0 3
b 1 2
R1 p
c 2 1 X
3 0
M1 R0 M4
M4
194 4 Prozessor-Datenpfad

Befehlswort-Konstanten
Im Befehlswort können in den Bits 14 bis 23 Konstanten abgelegt werden. Um diese
Konstanten in ein Register zu schreiben, wird M2 auf 0 und M1 auf 3 gesetzt und das
entsprechende Register über den Demultiplexer D getaktet. In der Schaltung wird das
MSB auf die oberen n-10 Bits (n ist die Registerwortbreite) erweitert. Dadurch wird bei
negativen Zahlen (2er-Komplement) das Vorzeichen beibehalten.

Eingänge
Der Rechner verfügt über drei Eingänge a, b und c, die über M1 mit den Registern R0,
R1, ... R7 verbunden werden können. Soll z.B. der an Eingang b anliegende Wert in
Register R6 übernommen werden, wird M1 auf 1 und D auf 6 gesetzt. Bei einer fallenden
Flanke des Signals clk entsteht dann an R6 eine steigende Flanke und das am Eingang
b anliegende Datenwort wird in Register R6 übernommen.

ROM: Speichern der Befehlsworte, Programme


Die Signale von M1, M2, M3, M4 und D kommen aus dem ROM R. Die in ROM R
gespeicherten Datenworte legen also fest, welche Register-Inhalte als Operanden an
die arithmetischen Schaltungen angelegt werden, in welches Register das Ergebnis
übernommen wird bzw. welcher Eingang a, b, c in welchem Register abgespeichert
werden soll. Die im ROM gespeicherten Datenworte werden deswegen auch Befehls-
worte genannt. Über den Adresseingang A0, ... A7 wird ausgewählt, welcher Befehl
ausgeführt werden soll. Die Auswahl erfolgt über das Register BZ, dem Befehlszähler.
Im Befehlszähler ist die Adresse des gerade ausgeführten Befehls abgelegt.
Bei einer positiven Flanke an der Leitung clk und reset = 0 wird der Befehlszähler durch
den Addierer A1 immer um den Wert 1 erhöht, d.h. es wird der im Speicher der auf den
aktuellen Befehl folgende Befehl ausgeführt. Im Fall reset = 1 wird bei einer steigenden
Flanke auf der Leitung clk der Befehlszähler auf 0 gesetzt, d.h. es wird der an Adresse 0
stehende Befehl ausgeführt.
Die Menge der im ROM gespeicherten auszuführenden Befehlsworte wird Programm
genannt.

Taktsignal clk
Das Taktsignal clk treibt die Schaltung an. Mit jeder steigenden Flanke wird der Be-
fehlszähler BZ so geändert, dass der nächste auszuführende Befehl adressiert wird. Das
entsprechende Befehlswort liegt dann am Ausgang des ROMs R an und schaltet über
die Multiplexer M1, M2, M3, M4 und den Demultiplexer D die gewünschten Datenpfade
frei.
Bei der darauf folgenden fallenden Flanke wird das berechete bzw. ausgewählte Ergebnis
in das durch D spezifizierte Register übernommen, da durch den Inverter an dem
4.2 Universalrechner: Schaltung unabhängig vom Problem 195

ausgewählten Register dann eine steigende Flanke anliegt.


Die Übernahme des Ergebnisses bei fallender clk-Flanke wird bei der gezeigten Schal-
tung dazu verwendet, die Setup- und Hold-Zeiten der Register einzuhalten. So kann
sichergestellt werden, dass sich die an den Registern R0, ... R7 anliegenden Werte
unmittelbar vor und unmittelbar nach der Übernahme des Ergebnisses nicht ändern.
Nachfolgende Abbildung zeigt den durch das clk-Signal festgelegten zeitlichen Ablauf.

benötigte benötigte benötigte benötigte


Setup-Zeit Hold-Zeit Setup-Zeit Hold-Zeit

Zeitpunkt, zu dem das Zeitpunkt, zu dem das


Ergebnis in R0, … R7 Ergebnis in R0, … R7
übernommen wird übernommen wird

Auswahl der Operanden durch M3 und Auswahl der Operanden durch M3 und
M4, Durchführen Berechnungen (dauert M4, Durchführen Berechnungen (dauert
in Abhängigkeit der durchzuführenden in Abhängigkeit der durchzuführenden
Operation unterschiedlich lange), Aus- Operation unterschiedlich lange), Aus-
wahl des gewünschten Ergebnisses wahl des gewünschten Ergebnisses
durch M2, weiterleiten des Ergebnisses durch M2, weiterleiten des Ergebnisses
durch M1, Anpassung des clk-Pfads durch M1, Anpassung des clk-Pfads
durch D. durch D.

Zeitpunkt, zu dem der Befehlszähler BZ Zeitpunkt, zu dem der Befehlszähler BZ


aktualisiert wird und das neues Befehlswort aktualisiert wird und das neues Befehlswort
am ROM-Ausgang anliegt. Ab diesem am ROM-Ausgang anliegt. Ab diesem
Zeitpunkt werden durch das geänderte Zeitpunkt werden durch das geänderte
Befehlswort andere Operanden ausgewählt, Befehlswort andere Operanden ausgewählt,
die dann durch die arithmetischen Schaltun- die dann durch die arithmetischen Schaltun-
gen laufen. gen laufen.
196 4 Prozessor-Datenpfad

Aufgaben

Verständnisfragen

a) Wozu dienen die Multiplexer M3 und M4?

b) Wie wird bei dem Rechner ausgewählt, welche Operation (Addieren, Subtrahieren,
Multiplizieren, ...) ausgeführt werden soll?

c) Welche Funktion hat der Multiplexer M1?

d) Wozu dient der Demultiplexer D?


4.2 Universalrechner: Schaltung unabhängig vom Problem 197

e) Wozu dient der Inverter?

f) Wozu dient das Register BZ?

g) Wozu dient der Addierer A1?

h) Wozu dient der Multiplexer M0?


198 4 Prozessor-Datenpfad

i) Wozu wird im oberen rechten Teil der Schaltung das Bit D23 auf die n 10 Bits
10 ... n 1 erweitert?

Gegeben sind die folgenden Signallaufzeiten der arithmetischen Schaltungen: Addierer


= 10 ns; Subtrahierer = 10 ns; Multiplizierer = 50 ns; Dividierer = 90 ns; Wurzel = 90 ns.

j) Wie hoch darf der Rechner maximal getaktet werden, wenn die Setup-Zeit 10 ns
und die Hold-Zeit 5 ns beträgt?
4.2 Universalrechner: Schaltung unabhängig vom Problem 199

k) In der CMOS-Technik wird viel Strom bei Pegelübergängen verbraucht, da dann


Vcc für einen kurzen Zeitraum vergleichsweise niederohmig mit Masse verbunden
ist. Wie könnte man die gezeigte Schaltung hinsichtlich dieses Stromverbrauchs
verbessern?
200 4 Prozessor-Datenpfad

Programmieraufgaben

Quadratische Gleichung
In diesem Abschnitt soll für den Universalrechner ein Programm zur Berechnung von
p
b2 4 · a · c

x1,2 =
2a
erstellt werden. Nachfolgende Abbildung zeigt noch einmal den Universalrechner.

10 10
n
MSB
R D23 K …

D14 10 R7 n-10
M3
D13 D 0
7
D12 3 A2
D11
D10 M4 1
6
D9 3
D8 ADD
R6 2
5
D7 M3
clk
A7 D6
D5 3
BZ 3
4

A0 D4
D3
M2
D2 3 0
7 3
D1 M1 R5 a
D0 2 M2
1
6 2 SUB a-b
0
1 b
2
5 1
0
1
A1 R4
3
4 0
M0 Add 1
2
M3
reset 1 0 3 MUL 2
3
0 2 0
7
R3 3
4
1 1
6
5
0 2
5 a
M1 M2
DIV a/b
D R2 3
4
b
a 0 3
b 1 2
R1 p
c 2 1 X
3 0
M1 R0 M4
M4
4.2 Universalrechner: Schaltung unabhängig vom Problem 201

a) Geben Sie binär die Befehlsworte an, mit denen Sie die Eingänge a, b und c in die
Register R1, R2 und R3 übernehmen.

K D M4 M3 M2 M1

p
b) Geben Sie binär die Befehlsworte an, mit denen Sie b2 4ac berechnen und das
Ergebnis in Register 4 ablegen.

K D M4 M3 M2 M1 Kommentar
202 4 Prozessor-Datenpfad

p
c) Geben Sie binär die Befehlsworte an, mit denen Sie ( b± b 2 4ac)/2a berechnen
und das Ergebnis in den Registern R1 und R2 ablegen.

K D M4 M3 M2 M1 Kommentar

Kugelvolumen
4
In dieser Aufgabe soll das Volumen einer Kugel V = 3 · r 3 · ⇡ berechnet werden. Der
Radius liegt am Eingang 0 des Universalrechners an.

T a) Geben Sie binär das Befehlswort an, mit dem Sie den Radius in das Register R0
einlesen.

K D M4 M3 M2 M1 Kommentar
4.2 Universalrechner: Schaltung unabhängig vom Problem 203

T b) Geben Sie binär das Befehlswort an, mit dem Sie 4 · r 3 · 314 berechnen und das
Ergebnis in Register R1 ablegen. Hinweis: 31410 = 1001110102 .

K D M4 M3 M2 M1 Kommentar

T c) Geben Sie binär das Befehlswort an, mit dem Sie das in Register R1 stehende
Datenwort durch 300 dividieren und das Ergebnis wieder in R1 ablegen.

K D M4 M3 M2 M1 Kommentar
204 4 Prozessor-Datenpfad

4.3 Assembler
Die Programmierung des Universalrechners durch Niederschreiben der einzelnen
Befehlswort-Bits aller Befehle ist sehr aufwendig. Aus diesem Grund wird dieser Schritt
in der Regel durch ein Computerprogramm, dem sog. Assembler (engl. to assemble =
zusammenbauen), übernommen.

Assembler als leicht verständliche hardwarenahe Sprache


Der Programmierer kann Programme in einer hardwarenahen, jedoch für den Menschen
leicht verständlichen Sprache schreiben. Die Sprache wird – ebenso wie das Übersetzer-
Programm – umgangssprachlich oft Assembler genannt.
Unser Universalrechner verarbeitet zwei Quelloperanden zu einem Zieloperand. Befehle
in einer hardwarenahen Sprache für den Universalrechner müssen also
• bis zu drei Operanden spezifizieren (aus welchen Quell-Registern kommen die
Operanden, wo soll das Ergebnis abgespeichert werden?), aber auch
• die auszuführende Operation (Addieren, Subtrahieren, ...).

Ein Assembler-Programm zur Berechnung der quadratischen Gleichung auf unserem


Universalrechner könnte dann beispielsweise wie folgt geschrieben werden:

INPUT R1,0 // R1 a
INPUT R2,1 // R2 b
INPUT R3,2 // R3 c

MUL R4,R2,R2 // R4 b2
SET R5,4 // R5 4
MUL R5,R5,R1 // R5 4·a
MUL R5,R5,R3 // R5 4·a·c
SUB R4,R4,R5 // R4 b2 4 · a · c
p
SQRT R4,R4 // R4 b2 4 · a · c

SET R5,0 // R5 0
SUB R5,R5,R2 // R5 b
p
ADD R6,R5,R4 // R6 b + b2 4·a·c
p
SUB R7,R5,R4 // R7 b b2 4·a·c
SET R0,2 // R0 2
MUL R0,R1,R0 // R0 2·a
p
DIV R1,R6,R0 // R1 ( b + b2 4 · a · c)/(2 · a)
p
DIV R2,R7,R0 // R2 ( b b2 4 · a · c)/(2 · a)
4.3 Assembler 205

Diese Schreibweise meint genau dasselbe wie die in den Aufgaben zuvor bitweise
spezifizierten Befehlsworte, ist für den Menschen aber viel einfach lesbar. Um solche
Assembler-Programme auf dem Universalrechner auszuführen, müssen diese jedoch
zunächst mit dem Assembler in Befehlsworte übersetzt werden.

Definition einer Assembler-Sprache für den Universalrechner

• Leere Programmzeilen, d.h. Zeilen, die nur Leerzeichen, Tabulatorzeichen und


Zeilenumbruch-Zeichen enthalten, können zur Strukturierung eingefügt werden,
werden aber vom Universalrechner nicht ausgeführt bzw. vom Assembler
ignoriert.
• Wenn eine Zeile nicht leer ist, dann
• spezifiziert das erste in der Zeile vorkommende Wort (also alle Zeichen
bis zum ersten Leerzeichen oder Tabulator) den Befehl (Multiplizieren,
Subtrahieren, ...), und
• das zweite in der Zeile vorkommende Wort die Operanden:
• die Operanden werden durch Komma getrennt;
• der erste Operand ist immer der Ziel-Operand,
• die folgenden Operanden sind Quelloperanden.

• Alle folgenden Worte sind Kommentare und werden vom Assembler


ignoriert und somit vom Universalrechner nicht ausgeführt.

• Befehle und Operanden:


• INPUT: Liest Daten von den Eingängen des Rechners (Eingänge 0,
1 und 2 des Multiplexers M1) ein uns speichert diese in einem Re-
gister ab; der erste Operand ist das Zielregister, der zweite Operand
spezifiziert den Eingang (0, 1 oder 2).
• ADD, SUB, MUL, DIV: Führen entsprechende arithmetische Operation
durch; der erste Operand ist das Zielregister, die anderen beiden
Operanden die Quellregister.
• SQRT: Zieht die Wurzel; der erste Operand ist das Zielregister, der
zweite Operand das Quellregister.
• SET: Schreibt eine 10 Bit breite vorzeichenbehaftete Konstante in ein
Register; der erste Operand ist das Zielregister, der zweite Operand
die Konstante.
206 4 Prozessor-Datenpfad

a) Schreiben Sie für den Universalrechner ein Programm in Assembler-Sprache,


welches die drei Seiten eines Würfels von den Eingängen 0, 1 und 2 einliest, das
Volumen des Würfels berechnet und das Ergebnis im Register R0 ablegt.

b) Schreiben Sie für den Universalrechner ein Programm in Assembler-Sprache,


welches den Mittelwert der an den Eingängen 0, 1 und 2 anliegenden Werte
berechnet und diesen im Register R0 ablegt.
4.3 Assembler 207

c) Schreiben Sie für den Universalrechner ein Programm in Assembler-Sprache,


welches die an den Eingängen 0, 1 und 2 anliegenden Koordinaten eines Vektors
im dreidimensionlen Raum einliest, den Betrag des Vektors berechnet und das
Ergebnis in Register R0 ablegt.
208 4 Prozessor-Datenpfad

d) Schreiben Sie für den Universalrechner ein Programm in Assembler-Sprache,


welches den Radius eines Kreises vom Eingang 0 einliest, die Fläche des Kreises
berechnet und das Ergebnis in Register R0 ablegt. Verwenden Sie für ⇡ den Wert
3,141592 in der angegebenen Genauigkeit.
4.3 Assembler 209

T e) Schreiben Sie für den Universalrechner ein Programm in Assembler-Sprache,


welches die Längen der beiden Katheten eines rechtwinkligen Dreiecks über die
Eingänge 0 und 1 einliest, die Länge der Hypothenuse berechnet und das Ergebnis
im Register R0 ablegt

T f) Schreiben Sie für den Universalrechner ein Programm in Assembler-Sprache,


welches den Radius eines Kreises vom Eingang 0 einliest, den Umfang des
Kreises berechnet und das Ergebnis in Register R0 ablegt. Verwenden Sie für ⇡
den Wert 3,141592 in der angegebenen Genauigkeit.
210 4 Prozessor-Datenpfad

Assembler als Übersetzer


Um ein Assembler-Programm für den Universalrechner zu übersetzen, iteriert der As-
sembler der Reihe nach über alle Programmzeilen und führt für jede Zeile folgendes aus:

• Wenn die Programmzeile ‘‘leer’’ ist (nur Leerzeichen, Tabulatorzeichen und


Zeilenumbruch-Zeichen enthält), wird die Zeile ignoriert.
• Wenn die Programmzeile nicht leer ist,
• wird das erste Wort (alle Zeichen bis zum ersten Leerzeichen oder
Tabulator) als Befehls-Zeichenkette interpretiert und das zweite Wort
als Operanden-Zeichenkette; die Operanden-Zeichenkette wird bei
den Kommas in zwei bzw. drei Operanden aufgetrennt;

• entspricht die Befehls-Zeichenkette der Zeichenkette ‘‘INPUT’’, wird


• vom erste Operanden das ‘‘R’’ entfernt, das übrigbleibende
Zeichen in eine Zahl gewandelt und diese im Befehlswort als
D abgespeichert (z.B. D = 001 für R1, D = 010 für R2, ...)
• der zweite Operand im Befehlswort als M1 abgespeichert
(z.B. M1 = 00, falls zweiter Operand den Wert 0 hat)

• entspricht die Befehls-Zeichenkette den Zeichenketten ‘‘ADD’’ oder


‘‘SUB’’ oder ‘‘MUL’’ oder ‘‘DIV’’, wird
• von den drei Operanden das ‘‘R’’ entfernt und die übrig
bleibenden Zahlen im Befehlswort als D (erster Operand), M3
(zweiter Operand) und M4 (dritter Operand) abgespeichert,
und
• der Wert von M2 bei ‘‘ADD’’ auf 0012 gesetzt, bei ‘‘SUB’’ auf
0102 , bei ‘‘MUL’’ auf 0112 , bei ‘‘DIV’’ auf 1002 , und
• M1 auf 112 gesetzt;

• entspricht die Befehls-Zeichenkette der Zeichenkette ‘‘SQRT’’, wird


• von beiden Operanden das ‘‘R’’ entfernt und die übrig blei-
benden Zahlen im Befehlswort als D (erster Operand) bzw.
M4 (zweiter Operand) abgespeichert
• M2 auf 1012 und
• M1 auf 112 gesetzt;
4.3 Assembler 211

• entspricht die Befehls-Zeichenkette der Zeichenkette ‘‘SET’’, wird


• vom ersten Operanden das ‘‘R’’ entfernt und die übrig blei-
bende Zahl im Befehlswort als D abgespeichert
• der zweite Operand in K abgespeichert (z.B. 00000000012 für
1 oder 11111111112 für 1
• M2 auf 0002 und
• M1 auf 112 gesetzt.

Neben dieser Grundfunktionalität würde ein richtiger Assembler auch noch diverse
Fehlerüberprüfungen durchführen, beispielsweise ob nur gültige Befehle und Operanden
verwendet wurden, ob alle Operanden angegeben sind, ob das Format der Operanden
stimmt, ob die Konstanten nicht zu groß sind etc. Das Grundprinzip jedoch ist immer
das selbe: Assembler-Programme werden durch eine eindeutige Abbildungsregel in
Befehlsworte übersetzt.

Betrachten Sie die folgende Codesequenz:

INPUT R0,0
MUL R0,R0,R0
INPUT R1,1
MUL R1,R1,R1
ADD R0,R0,R1
SQRT R0,R0

Befehlsformat: K (10 Bit) – D (3 Bit) – M4 (3 Bit) – M3 (3 Bit) – M2 (3 Bit) – M1 (2 Bit)

a) Übersetzen Sie das Programm in Befehlsworte des Universalrechners mit Hilfe


obiger Übersetzungsregeln. Geben Sie für alle irrelevanten Bits ‘‘x’’ an
212 4 Prozessor-Datenpfad

Betrachten Sie die folgende Codesequenz:

MUL R0,R0,R1
SET R1,255
DIV R1,R0,R2
ADD R1,R1,R3

b) Übersetzen Sie das Programm in Befehlsworte des Universalrechners mit Hilfe


obiger Übersetzungsregeln. Geben Sie für alle irrelevanten Bits ‘‘x’’ an

Betrachten Sie die folgende Codesequenz:

SET R0,0
INPUT R1,0
ADD R0,R0,R1
INPUT R1,1
ADD R0,R0,R1
INPUT R1,2
ADD R0,R0,R1
SET R1,3
DIV R0,R0,R3

T c) Übersetzen Sie das Programm in Befehlsworte des Universalrechners mit Hilfe


obiger Übersetzungsregeln. Geben Sie für alle irrelevanten Bits ‘‘x’’ an
4.3 Assembler 213

Betrachten Sie den Datenpfad des Universalrechners.

10 10
n
MSB
R D23 K …


D14 10 R7 n-10
M3
D13 D 0
7
D12 3 A2
D11
D10 M4 1
6
D9 3
D8 ADD
R6 2
5
D7 M3
clk
A7 D6
D5 3
BZ 3
4

A0 D4
D3
M2
D2 3 0
7 3
D1 M1 R5 a
D0 2 M2
1
6 2 SUB a-b
0
1 b
2
5 1
0
1
A1 R4
3
4 0
M0 Add 1
2
M3
reset 1 0 3 MUL 2
3
0 2 0
7
R3 3
4
1 1
6
5
0 2
5 a
M1 M2
DIV a/b
D R2 3
4
b
a 0 3
b 1 2
R1 p
c 2 1 X
3 0
M1 R0 M4
M4
214 4 Prozessor-Datenpfad

Gegeben ist folgende Codesequenz:

SET R0,5
INPUT R4,2
ADD R0,R0,R1
DIV R7,R0,R1

d) Übersetzen Sie das Programm in Befehlsworte des Universalrechners lediglich mit


Hilfe des Datenpfads (ohne Übersetzungsregeln). Geben Sie für alle irrelevanten
Bits ‘‘x’’ an

Gegeben ist folgende Codesequenz:

SET R1,2
SQRT R2,R1
INPUT R2,1
MUL R5,R0,R1

T e) Übersetzen Sie das Programm in Befehlsworte des Universalrechners lediglich mit


Hilfe des Datenpfads (ohne Übersetzungsregeln). Geben Sie für alle irrelevanten
Bits ‘‘x’’ an
215

5 Befehlssätze und deren Klassifikation

Befehlssatz
Unser Universalrechner kennt 7 verschiedene Befehle: ADD, SUB, MUL, DIV, FSQRT, INPUT
und SET. Die Menge (im mathematischen Sinne) der Befehle, die ein Prozessor versteht,
nennt man auch den Befehlssatz (Satz im Sinne von Menge; engl.: instruction set) des
Prozessors. Befehlssätze lassen sich in mehrfacher Hinsicht klassifizieren.

Klassifikation nach Komplexität

CISC = Complex Instruction Set Architecture


CISC-Befehlssätze enthalten sehr mächtige, ‘‘komplexe’’ Befehle, um mit möglichst
wenig Assembler-Code viel zu erreichen. Beispiel: Laden von zwei Operanden aus dem
Speicher, Multiplikation der Operanden, Abspeichern des Ergebnisses im Speicher als
ein Befehl. Dieses Prinzip war in den 1970er-Jahren gängig, da die verfügbaren Speicher
sehr klein waren und so weniger Platz benötigt wurde. Zudem gab es noch keine
(vernünftigen) Compiler, d.h. Programme wurde in Assembler-Sprache geschrieben.
Durch die mächtigen Befehle ging das Programmieren schneller, da sich die Befehle
fast wie eine Hochsprache verhielten. Durch die Unterschiedlichkeit der Befehle ist das
Befehlswort bzgl. der Länge variabel, d.h. die Befehlswortbreite schwankt je nach Befehl
z.B. zwischen 1 und 16 Byte.

RISC = Reduced Instruction Set Architecture


Bei RISC-Befehlssätzen ist die Mächtigkeit der Befehle stark reduziert. Komplexe Ope-
rationen werden durch mehrere einfachen Befehlen gelöst, statt durch einen sehr
mächtigen Befehl. Beispiel Multiplikation zweier im Speicher liegender Zahlen:
• 2 Lade-Befehle, um Operanden vom Speicher in Register zu laden
• 1 Multiplikation-Befehl, der zwei Register-Werte multipliziert und das Ergebnis
wieder in einem Register abspeichert
• 1 Speicher-Befehl, um das Ergebnis vom Register in den Speicher zu schreiben

Durch Compiler und Programmierung in Hochsprache ist die Mächtigkeit einzelner Be-
fehle nicht mehr ausschlaggebend für die Programmiereffizienz. Durch die Verfügbarkeit
größerer Speicher besteht keine Notwendigkeit mehr, Speicher durch mächtige Befehle
zu sparen.
Die Befehle eines RISC-Prozessors haben in der Regel alle die selbe Befehlswortlänge,
z.B. 2 Byte oder 4 Byte, was die Hardware einfacher und damit auch schneller macht.
216 5 Befehlssätze und deren Klassifikation

Klassifikation nach Verortung der Operanden

Register-Speicher-Architektur
Bei einer Register-Speicher-Architektur können die Operanden der Befehle sowohl in
Registern, als auch im Speicher stehen.

Register-Register-Architektur/Load-Store-Architektur
Bei Register-Register-Architekturen müssen Quell- und Zieloperand in Registern stehen.
Quelloperanden, die im Speicher stehen, müssen zunächst mit einem Lade-Befehl (engl.
load instruction) vom Speicher in ein Register geladen werden, bevor sie verarbeitet
werden können. Soll das Ergebnis eines Befehls im Speicher abgelegt werden, so
muss das Ergebnis zunächst in einem Register abgelegt werden, bevor es mit einem
Speicher-Befehl (engl. store instruction) vom Register in den Speicher geschrieben
werden kann.
Da Speicherzugriffe nur über Lade- und Speicher-Befehle erfolgen, nenn man Register-
Register-Architekturen auch Load-Store-Architekturen.

Klassifikation nach der Anzahl der Operanden

Drei-Adress-Maschine
Bei einer Drei-Adress-Maschine können bis zu zwei Quell- und ein Zieloperand explizit
angegeben werden. Da das bei unserem Universalrechner ebenfalls möglich war, ist
unser Universalrechner eine Drei-Adress-Maschine.
Beispiel: ADD R0,R1,R2 , addiere Register R1 zum Register R2 und speichere das
Ergebnis in Register R0 ab.

Zwei-Adress-Maschine
Bei einer Zwei-Adress-Maschine ist ein Quell-Operand gleichzeitig auch Zieloperand.
Beispiel: ADD R0,R1 , addiere Register R0 zum Register R1 und speichere das Ergebnis
in Register R0 ab.

Ein-Adress-Maschine/Akkumulator-Maschine
Bei einer Ein-Adress-Maschine wird nur ein einziger Quell-Operand angegeben. Zweiter
Quell-Operand und Ziel-Operand ist implizit immer das sog. Akkumulator-Register.
Beispiel: ADD R1 , addiere Register R1 zum Akkumulator-Register und speichere das
Ergebnis wieder im Akkumulator-Register ab.

Null-Adress-Maschine/Stack-Maschine
Bei einer Null-Address-Maschine muss bei einer Operation kein Operand angegeben
217

werden, da als Operand immer implizit die auf einem Stack oben liegenden Werte
verwendet werden. Das Ergebnis wird wieder auf dem Stack abgelegt. Beispiel:

push 3
push 4
add
Zunächst wird die Zahl 3 auf dem Stack abgelegt, danach die Zahl 4. Anschließend
werden beide Zahlen addiert. Das Ergebnis wird wieder auf dem Stack abgelegt.
218 6 MMIX-Prozessor

6 MMIX-Prozessor

In diesem Kapitel beschäftigen wir uns mit dem MMIX-Prozessor. Der MMIX-Prozessor
wurde von Donald Ervin Knuth zu Lehr- und Forschungszwecken an der Stanford Uni-
versity entwickelt. Donald Knuth ist Mathematiker und ein berühmter Computer-Pionier.
Von ihm stammen unter anderem die berühmten Bücher ‘‘The Art of Computer Pro-
gramming’’ sowie das Text-Satzsystem TEX, ein Vorfahre von LATEX, mit dem z.B. dieses
Skript erstellt wurde. Für mehr Infos, siehe http://www-cs-faculty.stanford.edu/~uno/.
‘‘MMIX’’ steht für die römische Zahl 2009, die sich als Mittelwert mehrerer RISC-Rechner-
Kennzahlen ergibt: (CrayI + IBM801 + RISCII + ClipperC300 + AMD29K + Motorola88K
+ IBM601 + In-teli960 + Alpha21164 + POWER2 + MIPSR400 + HitachiSuperH4 +
StrongARM110 + Sparc64) / 14 = 28126 / 14 = 2009.
MMIX ist ein Prozessor-Modell, d.h. kein real existierender Prozessor. Damit gibt es
keine Legacy-Effekte aufgrund gewünschter Rückwärtskompatibilitäten, was nicht nur
die Programmierung, sondern auch die Implementierung des Prozessors sehr einfach
und verständlich macht. Simulations-Tools zum MMIX-Prozessor können von der LDV-
Webseite heruntergeladen werden.
Der MMIX ist eine Register-Register-Architektur mit 256 Allzweck-Registern und 32
Spezial-Registern. Die Wortbreite beträgt 64 Bit (Register, Rechenwerk, Daten- und
Adress-Busse), der Adressbereich umfasst 264 Byte. Der Befehlssatz umfasst 256
Befehle. Für alle Befehle beträgt die Befehlswortlänge 32 Bit. Donald Knuth gibt für die
Ausführungszeit der meisten Befehle 1 Takt an, was typisch für RISC-Prozessoren ist.
Diese Ausführungszeit bezieht sich jedoch auf den von Donald Knuth erstellten Simulator
und nicht auf die von uns entwickelte Datenpfad-Realisierung.
6.1 Programmiermodell 219

6.1 Programmiermodell
32 Spezialregister 256 Allzweckregister Speicher

64 Bit 64 Bit 8 Bit

0 PUT 0 LDx 0

1 1 1
64 Bit
8, 16,
GET 32, 64 Bit

31
STx

32 Bit Befehlswort 255


64 Bit 64 Bit
OP X Y Z

8, 16, 24 Bit
ALU

STCO

264 - 1

• Die Operanden, die vom Rechenwerk (ALU = Arithmetic Logic Unit) verarbeitet
werden, entstammen entweder den Allzweckregistern (64 Bit Wortbreite) oder
direkt dem Befehlswort (Direktoperand; 8, 16, 24 Bit).
• Ein vom Rechenwerk berechnetes Ergebnis (Zieloperand) wird immer in einem
Allzweckregister abgelegt.
• Daten aus dem Speicher müssen erst mit Ladebefehlen (LDx) in ein Allzweckre-
gister geladen werden, bevor Sie vom Rechenwerk verarbeitet werden können.
• Daten können mit Speicherbefehlen (STx) von einem Allzweckregister in den
Speicher geschrieben werden.
• Die Wortbreite für Speicherzugriffe beträgt 8, 16, 32 oder 64 Byte. Für jede
Wortbreite gibt es einen eigenen Lade- bzw. Speicherbefehl, was mit dem ‘‘x’’
bei ‘‘LDx’’ bzw. ‘‘STx’’ gekennzeichnet ist.
• Der Zugriff auf die Spezialregister erfolgt mit PUT (vom Allzweckregister ins
Spezialregister schreiben) bzw. mit GET (Daten vom Spezialregister in ein
Allzweckregister einlesen).
• Mit dem STCO-Befehl können 8 Bit breite Operanden vom Befehlswort in den
Speicher geschrieben werden.
220 6 MMIX-Prozessor

6.2 Register
Die Register sind kleine, jedoch sehr schnelle Speicherelemente, die im Prozessor-Kern
untergebracht sind. Die Wortbreite der Register entspricht typischerweise der Breite
der Datenworte, die vom Prozessor verarbeitete werden können. Beim MMIX sind die
Register 64 Bit groß.

Allzweckregister
Allzweckregister (engl. general purpose register) sind Register, die keinen bestimmten
Zweck haben, sondern universell verwendet werden können. Gemeint ist, dass diese
Register als Operanden für alle Befehle verwendet werden können. Es gibt bei Allzweck-
registern also keine festgelegte Bindung zwischen einem bestimmten Register und einer
bestimmten auszuführenden Operation (z.B. Festkomma-Addition, Basis-Adresse für
Speicherzugriff, ...).
Die 256 Allzweckregister des MMIX haben keine besonderen Namen, sondern werden
von 0 bis 255 durchnummeriert und über diese Nummer angesprochen. Um Regis-
ter von Zahlen unterscheiden zu können wird der Registernummer ein Dollarzeichen
vorangestellt. $0 meint also den Inhalt von Register 0, während 0 die Zahl 0 meint.
Computerprogramme verwenden sowohl globale als auch lokale Variable: Globale
Variable können von allen Programmteilen verwendet werden, lokale nur von einem
Teilausschnitt, z.B. einer Funktion. Beim MMIX werden lokale Variable in den unteren
Allzweckregistern ($0, $1, ... = lokale Register) und globale Variable in den oberen
Allzweckregistern ($255, $254, ... = globale Register) abgelegt. Die dazwischen liegenden
unbenutzten Register werden beim MMIX marginale Register genannt.
Die Nummer des ersten freien lokalen Registers ist in Spezialregister rL abgelegt, die
Nummer des ersten globalen Registers in Spezialregister rG.

$255
Globale
Register
$(rG)

Marginale
Register

$(rL)

Lokale
Register
$0
6.2 Register 221

Spezialregister
Spezialregister (engl. special purpose registers) haben im Gegensatz zu Allzweckregis-
tern einen bestimmten Zweck, d.h. jedes Spezialregister hat seine ganz eigene Aufgabe.
Spezialregister können als eine Art Schnittstelle zwischen Hardware und Software ange-
sehen werden, die es der Software ermöglicht, bestimmte Hardware-Einstellungen vor-
zunehmen (z.B. Setzen von Taktfrequenz-Multiplikatoren, Konfiguration von Interrupts,
...) oder aufgetretene Ereignisse (z.B. Division durch 0, Zeitablauf bei Timer-Interrupt, ...)
durch die Software erfassbar/auswertbar zu machen.
Der MMIX-Prozessor hat 32 Spezialregister, die rA, rB, rC, ... rZ, rBB, rTT, rWW rXX,
rYY und rZZ genannt werden. Zugriff auf die Spezialregister ist bei MMIX nur über die
Befehle PUT (Wert von Allzweckregister in Spezialregister kopieren) und GET (Wert von
Spezialregister in Allzweckregister kopieren) möglich.

Nachfolgende Abbildung zeigt das Spezialregister rA, das Arithmetische Status Register.

Interrupt Enable (Freischalten) Interrupt Event (Auftreten)

0 0 R1 R0 D V W I O U Z X D V W I O U Z X

Gleitkommazahl ungenau
nicht verwendet
(z.B. 1.0 / 3.0)
Gleitkomma-Division durch 0
Gleitkomma-Unterlauf
Gleitkomma-Überlauf
Unerlaubte Gleitkomma-
operation, z.B. sqrt(-1.0)
Überlauf bei Wandlung Gleit-
komma- in Festkommazahl
Festkomma-Überlauf
Festkomma-Division durch 0
00: Nächster Wert (standard)
01: Abrunden (Richtung 0)
Gleitkomma-Rundungsmodus
10: Aufrunden (Richtung +∞)
11: Abrunden (Richtung -∞)

Beispiele für weitere Spezialregister:


• Im Falle einer Multiplikation 64 Bit · 64 Bit = 128 Bit werden in rH die oberen 64
Bit des Ergebnisses abgelegt.
• Im Falle einer Division 128 Bit : 64 Bit = 64 Bit werden in rD die oberen 64 Bit
des 128 Bit breiten Dividenden abgelegt.
• Bei einer Festkomma-Division wird in rR der Rest der Division abgelegt (Modulo-
Operation).
222 6 MMIX-Prozessor

Verständnisfragen/Aufgaben

Allgemein

T a) Was ist ein Register?

T b) Wo findet man Register in einem Computer-System?

T c) Daten welcher Größenordnung kann ein Register aufnehmen: Byte, kilobytes,


megabytes, gigabytes or terabytes?

Allzweckregister

a) Was sind Allzweckregister?

b) Geben Sie ein Beispiel für eine typische Verwendung eines Allzweckregisters an.

c) Über wieviele Allzweckregister verfügt der MMIX-Prozessor? Welche Namen haben


sie?
6.2 Register 223

T d) Was ist der Unterschied zwischen einem globalen und einem lokalen Register?

Spezialregister

a) Was ist ein Spezialregister?

b) Geben Sie eine typische Anwendung eines Spezialregisters an.

T c) Über wieviele Spezialregister verfügt der MMIX-Prozessor? Wie werden sie ge-
nannt (Prinzip)?

T d) Kann jeder MMIX-Befehl Spezialregister verwenden?

T e) Welches Spezialregister stellt Informationen über Arithmetische Operationen zur


Verfügung?

T f) In welchem Spezialregister kann man die oberen 64 Bit eines 128 Bit breiten
Festkomma-Dividenden ablegen?
224 6 MMIX-Prozessor

T g) In welchem Register werden die oberen 64 Bit des Ergebnisses einer Festkomma-
Multiplikation abgelegt?

T h) In welchem Spezialregister legt das Rechenwerk den Rest einer Festkomma-


Division ab?

i) Müssen ‘‘normale’’ Programme häufig auf Spezialregister zugreifen?

j) Was müssen Sie tun, wenn Sie einzelne Bits eines Spezialregisters verändern
wollen?

Die letzte Aufgabe hat gezeigt, dass zur Bearbeitung von Spezialregistern zwei zusätzli-
che Befehle ausgeführt werden müssen. Diese Ausführung kostet Zeit.

k) Können Sie sich einen Grund vorstellen, warum nicht alle MMIX-Befehle in Spezi-
alregister schreiben bzw. Spezialregister lesen können?
6.3 Speicher 225

6.3 Speicher
Der Speicher des MMIX ist Byte-adressiert, d.h. das kleinste adressierbare Datenelement
ist ein Byte (8 Bit).

Wortbreiten
Das Speichern (Allzweckregister ! Speicher; engl. store) bzw. Laden (Speicher !
Allzweckregister; engl. load) wird in folgenden Wortbreiten unterstützt:
• 1 Byte (8 Bit)
• 2 Byte (16 Bit), beim MMIX Wyde genannt,
• 4 Byte (32 Bit), beim MMIX Tetra genannt,
• 8 Byte (64 Bit), beim MMIX Octa genannt.

Ausrichtung der Daten im Speicher - Alignment


Bei Speichermodulen sind die einzelnen Byte in der Regel auf mehrere Speicherchips
verteilt, bei einer Wortbreite von 64 Bit kann ein Speichermodul (ohne Speicherung von
Paritätsbits) beispielsweise aus 16 Chips zu je 4 Bit oder 8 Chips zu je 8 Bit aufgebaut
sein.
Betrachten Sie das nachfolgende (einseitige) Speichermodul, in dem 64 Bit breite
Datenworte aus 8 Speichermodulen zu je 8 Bit aufgebaut werden (es werden keine
Paritätsbits betrachtet).

0 1 2 3 4 5 6 7

• Bei Zugriffen auf ein einzelnes Byte wird nur auf einen einzigen Speicherchip
zugegriffen. Dabei können die letzten drei Adressbits dazu verwendet werden,
den Speicherchip auszuwählen und die übrigen Adressbits wählen dann eine
Adresse innerhalb des ausgewählten Chips aus.
• Bei Zugriffen auf 16 Bit breite Datenworte wählen die Adressbits 1 und 2 (das
Adressbit 0 wird nicht ausgewertet) eine der vier Speicherchip-Gruppen (0,1),
(2,3), (4,5) oder (6,7) aus. Die übrigen Adressbits (ab 3 aufwärts) wählen dann
eine Adresse innerhalb der ausgewählten Chips aus. Das 16 Bit Datenwort setzt
sich dann aus den 2 · 8 Bit der ausgewählten Speicherchip-Gruppe zusammen.
226 6 MMIX-Prozessor

• Bei Zugriffen auf 32 Bit breite Datenworte wählt das Adressbit 2 (Adressbits
0 und 1 werden ignoriert) eine der zwei Speicherchip-Gruppen (0,1,2,3) oder
(4,5,6,7) aus. Die Adressbits 3, 4, 5, ... wählen eine Adresse innerhalb der
ausgewählten Chips aus. Das 32 Bit Datenwort setzt sich dann aus den 4 · 8 Bit
der ausgewählten Speicherchip-Gruppe zusammen.
• Bei Zugriffen auf 64 Bit breite Datenworte werden die Adressbits 0, 1 und 2
ignoriert. Die übrigen Adressbits wählen eine Adresse innerhalb der ausgewähl-
ten Chips aus. Das 64 Bit breite Datenwort setzt sich dann aus den 8 · 8 Bit der
ausgewählten Speicherchip-Gruppe zusammen.

Aus mehreren Byte zusammengesetzte Daten werden also idealerweise so im Speicher


ausgerichtet (engl. aligned), dass auf sie gemäß obigem Schema mit nur einem einzigen
Speicherzugriff zugegriffen werden kann.
Datenworte können prinzipiell natürlich auch anders abgelegt werden, bspw. kann ein 32
Bit breites Datenwort auch auf die Chips 1, 2, 3 und 4 verteilt werden. Der Nachteil hierbei
ist jedoch, dass die Daten dann durch die Verdrahtung auf dem Speichermodul nicht
automatisch richtig zusammengesetzt werden, sondern entweder durch zusätzliche
Hardware oder durch Software-Befehle richtig zusammengefügt werden müssen. Aus
diesem Grund werden aus mehreren Byte zusammengesetzte Datenworte in der Regel
immer in der beschriebenen Weise ausgerichtet, sind also immer ‘‘aligned’’.
Der MMIX unterstützt das beschriebene Alignment, indem er durch Löschen der nieder-
wertigsten Adressbits die Menge gültiger Wortadressen wie folgt einschränkt:

Byte Wyde Tetra Octa


0x0000000000000000 X X X X
0x0000000000000001 X
0x0000000000000002 X X
0x0000000000000003 X
0x0000000000000004 X X X
0x0000000000000005 X
0x0000000000000006 X X
0x0000000000000007 X
0x0000000000000008 X X X X
0x0000000000000009 X
0x000000000000000A X X


6.3 Speicher 227

Das bedeutet:
• Bytes können an jeder Adresse abgelegt werden,
• Wydes können nur an Adressen abgelegt werden, die ein Vielfaches von 2 sind,
• Tetras können nur an Adressen abgelegt werden, die ein Vielfaches von 4 sind,
• Octas können nur an Adressen abgelegt werden, die ein Vielfaches von 8 sind.

Big- und Little Endian


Die Ausrichtung der Daten im Speicher (Alignment) beschreibt die Byte-Adressen, an
denen aus mehreren Byte zusammengesetzte Datenworte abgelegt werden können. Ein
32 Bit breites Datenwort beginnt beispielsweise an einer durch 4 teilbarer Adresse und
nimmt noch die nächsten vier Byte ein.
Damit ist jedoch noch keine Aussage über die Adressen innerhalb der Menge der erlaub-
ten Byte-Adressen getroffen, an der die verschiedenen Byte eines Datenworts abgelegt
werden. Sollen die Byte eines aus mehreren Byte zusammengesetzten Datenworts der
Reihe nach im Speicher abgelegt werden, gibt es zwei Möglichkeiten:
• Durch die (gültig ausgerichtete) Wort-Adresse wird das höherwertigste Byte
adressiert. Das nennt man Big Endian.
• Durch die (gültig ausgerichtete) Wort-Adresse wird das niederwertigste Byte
adressiert. Das nennt man Little Endian.

Beispiele für Big-Endian Prozessoren sind MMIX, MIPS, SPARC, Atmel AVR32 etc.,
Beispiele für Little-Endian-Prozessoren sind Intel x86, Renesas SH, ...

Beispiel: 32 Bit Zahl 0x01234567 an Adresse 0x0000 0000 0000 0000:

Big Endian Little Endian

0x0000000000000000 0x01 0x67


0x0000000000000001 0x23 0x45
0x0000000000000002 0x45 0x23
0x0000000000000003 0x67 0x01
228 6 MMIX-Prozessor

Speicherorganisation
Die Adressbreite des MMIX beträgt 64 Bit, d.h. der MMIX kann 264 Byte adressieren,
von 0x0000 0000 0000 0000 bis 0xFFFF FFFF FFFF FFFF. Dieser Speicherbereich wird
wie folgt aufgeteilt:

0x0000 0000 0000 0000


Interrupt-Vektoren
= Text_Segment
0x0000 0000 0000 00FF
Text-Segment
0x0000 0000 0000 0100
MMIX-Befehle

0x1FFF FFFF FFFF FFFF


0x2000 0000 0000 0000 Globale Variable (Heap)
= Data_Segment
Daten-Segment
0x3FFF FFFF FFFF FFFF Lokale Variable, Stack
0x4000 0000 0000 0000
= Pool_Segment
Pool-Segment
0x5FFF FFFF FFFF FFFF
0x6000 0000 0000 0000
= Stack_Segment
Stack-Segment
0x7FFF FFFF FFFF FFFF
0x8000 0000 0000 0000

Betriebssystem-Segment

0xFFFF FFFF FFFF FFFF

Text-Segment: Programme und Interrupt-Vektoren


Im Text-Segment wird ausführbarer Befehlscode als aufeinander folgende Befehlsworte
abgelegt. Da alle Befehlsworte 4 Byte breit sind, beginnen die Befehlsworte immer an
einer durch 4 teilbaren Adresse.
MMIX-Programme können ab Adresse 0x100 im Speicher abgelegt werden. An welcher
Adresse ein Programm genau beginnt, ist in der Symboltabelle der Objektdatei festgelegt.

• Die Objektdatei enthält Befehlsworte für den jeweiligen Prozessor (hier: MMIX),
die vom Loader (Teil des Betriebssystems das auszuführende Programme in
den Speicher lädt) beim Starten des Programms in das Textsegment geladen
6.3 Speicher 229

werden. Neben den Befehlen enthält die Objektdatei auch Informationen über
Vorbelegungen des Speichers sowie die Symboltabelle.
• Die Symboltabelle spezifiziert eine Menge von (Name ! Adresse)-Paaren,
über die Einsprungspunkte in Module, Funktionen, Blöcke etc. gefunden
werden können. MMIX-Programme beginnen an der Adresse, die durch den
Symboltabellen-Eintrag ‘‘Main’’ festgelegt ist.

Von Adresse 0x00 bis 0xFF ist die Interrupt-Vektor-Tabelle abgelegt. Die Interrupt-Vektor-
Tabelle ist der Speicherbereich, in dem die Interrupt-Vektoren (s.u.) eines Prozessors
abgelegt sind. Nachfolgende Abbildung zeigt den Aufbau der Interrupt-Vektor-Tabelle
beim MMIX.

0x00
0x04
0x08 Allgemeine Trips
0x0C
0x10
0x14
0x18 Division durch Null
0x1C
0x20
0x24
0x28 Integer-Überlauf
0x2C
0x30
0x34 Überlauf Gleitkomma-
0x38 Festkomma-Wandlung
0x3C
0x40
0x44 Ungültige Gleitkoma-
0x48 Operation
0x4C
0x50
0x54
0x58 Gleitkomma-Überlauf
0x5C
0x60
0x64
0x68 Gleitkomma-Unterlauf
0x6C
0x70
0x74 Gleitkomma-Division
0x78 durch NULL
0x7C
0x80
0x84
0x88 Gleitkommazahl ungenau
0x8C
230 6 MMIX-Prozessor

• Interrupts sind (asynchrone) Programm-Unterbrechungen. Sie können auftre-


ten, wenn ein Fehler aufgetreten ist (z.B. Division durch 0, Speicherzugriffs-
fehler), Zeitgeber (sog. Timer) abgelaufen sind, angeschlossene Geräte Daten
empfangen haben etc.
• Interrupt-Service-Routinen (ISRs) sind Funktionen, die zur Behandlung der
Interrupts aufgerufen werden. Beim Auftreten eines Timer-Interrupts können
beispielsweise von einem angeschlossenen Gerät empfangene Daten verarbei-
tet werden, Meßwerte von einem externen Sensor eingelesen werden oder – im
Falle des Betriebssystem-Schedulers – ein Prozess unterbrochen und ein an-
derer Prozess gestartet werden (time slicing). Interrupt-Service-Routinen sind
wie normale Funktionen, werden jedoch nicht durch das laufende Software-
Programm explizit (synchron) aufgerufen (wie z.B. ‘‘printf()’’ zur Ausgabe von
Zeichen auf dem Bildschirm). Sie werden durch asynchron auftretende externe
oder interne Ereignisse ausgelöst und durch die darauf folgende hardwareba-
sierte Änderung des Befehlszählers aufgerufen.
• Interrupt-Vektoren beschreiben für Interrupt-fähige Ereignisse die Adressen
der zugehörigen ISRs, d.h. die Stellen im Speicher, an die der Prozessor im
Fehlerfall automatisch verzweigen soll. Um im Ereignis-Fall automatisch in die
entsprechende ISR zu verzweigen, muss in der Regel
• die Behandlung von Interrupts allgemein freigeschaltet sein (z.B. Bit
‘‘globally enable interrupts’’ in einem Spezialregister), aber auch
• das betreffende Ereignis (z.B. ‘‘Division durch Null’’ explizit zur Feh-
lerbehandlung durch Interrupts freigeschaltet sein; beim MMIX bei-
spielsweise über das betreffende ‘‘Interrupt-Enable’’-Bit in rA.

Für viele Fehler gibt es eigene Interrupt-Vektoren, wie z.B. bei ‘‘Division durch
Null’’. Andere Fehler werden oft zu einem ‘‘allgemeinen Interrupt’’ zusammen-
gefasst.

Es gibt verschiedene Möglichkeiten, die Sprungziele der ISRs durch die


Interrupt-Vektoren zu beschreiben. Die gängigsten sind:
• Interrupt-Vektoren enthalten direkt die Adresse der ISR,
• Interrupt-Vektoren enthalten die Adresse der ISR indirekt, d.h. sie
enthalten eine Adresse auf ein Datenwort im Speicher, in dem die
Adresse der ISR steht,
• Interrupt-Vektoren enthalten vom Prozessor ausführbare Befehle; die
Befehle enthalten entweder die ISR selbst, oder einen Sprungbefehl zur
6.3 Speicher 231

ISR. Dieses Verfahren wird auch beim MMIX verwendet. Dazu werden
in die Interrupt-Vektoren Befehle eingetragen, die in die jeweiligen
ISRs verzweigen.

Daten-Segment
Das Datensegment dient zur Aufnahme von Daten, die während der Befehlsausführung
anfallen bzw. verarbeitet werden. Globale und statische Daten werden auf dem Heap
abgelegt. Dieser beginnt ab Adresse 0x2000000000000000 und wächst in Richtung
höherer Adressen. Lokale Daten werden auf dem Stack abgelegt, der bei Adresse
0x3FFFFFFFFFFFFFFF bzw. 0x3FFFFFFFFFFFFFF8 (für Octas) beginnt und in Richtung
niedrigerer Adressen wächst.

Pool-Segment
Das Pool-Segment ist ein Speicherbereich, der für den Datenaustausch zwischen
Programm und Betriebssystem gedacht ist. Im Pool-Segment werden beispielsweise
Programmen ihre Aufruf-Parameter übergeben. Dazu wird bei Programmstart in Register
0 die Anzahl der Parameter (argc = argument count) übergeben und in Register 1
die Adresse auf eine Null-terminierte Liste aus Zeigern, von denen jeder auf einen
Parameter zeigt. Adresse 0x4000000000000000 enthält die Adresse des ersten freien
Pool-Segment-Datenworts. Nachfolgende Abbildung zeigt das Poolsegment beim Aufruf
eines Programms skalprodarg mit den Parametern 4, 1, 2, 3, 4, 10, 20, 30 und 40.

Adresse Wert (hex) Wert (ascii)


0x4000000000000000 0x40000000000000b8 @ \0 \0 \0 \0 \0 \0 ©
0x4000000000000008 0x4000000000000060 @ \0 \0 \0 \0 \0 \0 `
0x4000000000000010 0x4000000000000070 @ \0 \0 \0 \0 \0 \0 p
0x4000000000000018 0x4000000000000078 @ \0 \0 \0 \0 \0 \0 x
0x4000000000000020 0x4000000000000080 @ \0 \0 \0 \0 \0 \0 Ç
0x4000000000000028 0x4000000000000088 @ \0 \0 \0 \0 \0 \0 ê
0x4000000000000030 0x4000000000000090 @ \0 \0 \0 \0 \0 \0 É
0x4000000000000038 0x4000000000000098 @ \0 \0 \0 \0 \0 \0 ÿ
0x4000000000000040 0x40000000000000a0 @ \0 \0 \0 \0 \0 \0 á
0x4000000000000048 0x40000000000000a8 @ \0 \0 \0 \0 \0 \0 ¿
0x4000000000000050 0x40000000000000b0 @ \0 \0 \0 \0 \0 \0 ░
0x4000000000000058 0x0000000000000000 \0 \0 \0 \0 \0 \0 \0 \0
0x4000000000000060 0x736b616c70726f64 s k a l p r o d
0x4000000000000068 0x6172670000000000 a r g \0 \0 \0 \0 \0
0x4000000000000070 0x3400000000000000 4 \0 \0 \0 \0 \0 \0 \0
0x4000000000000078 0x3100000000000000 1 \0 \0 \0 \0 \0 \0 \0
0x4000000000000080 0x3200000000000000 2 \0 \0 \0 \0 \0 \0 \0
0x4000000000000088 0x3300000000000000 3 \0 \0 \0 \0 \0 \0 \0
0x4000000000000090 0x3400000000000000 4 \0 \0 \0 \0 \0 \0 \0
0x4000000000000098 0x3130000000000000 1 0 \0 \0 \0 \0 \0 \0
0x40000000000000a0 0x3230000000000000 2 0 \0 \0 \0 \0 \0 \0
0x40000000000000a8 0x3330000000000000 3 0 \0 \0 \0 \0 \0 \0
0x40000000000000b0 0x3430000000000000 4 0 \0 \0 \0 \0 \0 \0
0x40000000000000b8 0x0000000000000000 \0 \0 \0 \0 \0 \0 \0 \0
232 6 MMIX-Prozessor

Stack-Segment
Das Stack-Segment dient beim sog. Register-Stack des MMIX zur Auslagerung von
Registern. Dieses Segment wird von uns nicht verwendet.

Betriebssystem-Segment
Dieser Speicherbereich ist für das Betriebssystem vorgesehen. Durch die gewählte
Aufteilung kann am höherwertigsten Adress-Bit direkt abgelesen werden, ob der ausge-
führte Befehl zum Betriebssystem (kernel space) oder zu einem Benutzerprogramm (user
space) gehört. Damit lässt sich ein zwei Stufen umfassendes Privilegierungs-System auf-
bauen, bei dem beispielsweise
• bestimmte Befehle nur vom Betriebssystem verwendet werden dürfen oder
• Zugriffe auf bestimmte Resourcen (Register, angeschlossene Geräte, ...) nur
dem Betriebssystem erlaubt sind.
6.3 Speicher 233

Virtueller Speicher
Die gezeigte Einteilung des Speichers in verschiedene Segmente bezieht sich auf den
sog. virtuellen Speicher.
Virtueller Speicher meint, dass die Speicheradressen, auf die ein Programm zugreift,
nicht den realen, physikalischen Speicheradressen entsprechen. Die Umwandlung er-
folgt durch die Hardware und wird vom Betriebssystem durch Einstellungen in Spezial-
registern gesteuert. Auf diese Weise gaukelt das System einem Programm z.B. einen 64
Bit großen Adressraum vor, obwohl beispielsweise nur 8 GB Arbeitsspeicher im System
installiert sind. Durch die vom Betriebssystem überwachte Abbildung von virtuellen auf
reale Adressen kann ein Programm auf jede beliebige Speicheradresse zugreifen ohne
mit dem Speicher anderer Programme zu kollidieren.

Virtueller Speicher dreier Programme realer Speicher

Interrupt-Vektoren 0
Text-Segment
MMIX-Befehle

Interrupt-Vektoren
Globale Variable (Heap)
Text-Segment Daten-Segment
MMIX-Befehle
Lokale Variable, Stack
0 Interrupt-Vektoren
Pool-Segment
Globale Variable (Heap)
Text-Segment Daten-Segment
MMIX-Befehle
Lokale Variable, Stack
Stack-Segment

Pool-Segment
Globale Variable (Heap)
Daten-Segment
Lokale Variable, Stack
Stack-Segment
Betriebssystem-Segment
Pool-Segment

Stack-Segment
Betriebssystem-Segment

Betriebssystem-Segment
233-1

264-1
234 6 MMIX-Prozessor

Aufgaben

Verständnis Speicher

T a) Wozu verwendet ein Computer Arbeitsspeicher?

T b) Wo findet man den Arbeitsspeicher in einem Computersystem? Auf dem


Prozessor-Kern? Auf dem Mainboard? Als externes Gerät?

T c) Sind Zugriffe auf den Arbeitsspeicher in der Regel schneller oder langsamer als
Zugriffe auf Register?

T d) Begründen Sie Ihre Antwort auf die letzte Frage.


6.3 Speicher 235

Alignment

T a) Welche Wortbreiten werden bei Speicherzugriffen vom MMIX unterstützt? Wie


werden diese genannt?

T b) Wofür steht der Begriff Alignment?

T c) Warum wird Alignment angewendet?

T d) Was würde passieren, wenn ein 64 Bit breites Datenwort an einer durch 4, aber
nicht durch 8 teilbaren Adresse abgelegt werden würde?
236 6 MMIX-Prozessor

T e) Welche Eigenschaft müssen Byte-, Wyde-, Tetra- und Octa-Adressen beim MMIX
haben?

Big- und Little-Endian

a) Welche Art von Daten betrifft die Abspeicherung als Big- oder Little-Endian?

b) Verwendet der MMIX-Prozessor Big- oder Little-Endian?

c) Was bedeutet Big- und Little-Endian? Was ist der Unterschied?

d) Wie wird die 16 Bit-Zahl 0x1234 im Speicher an der Adresse 0x2000000000000000


abgelegt im Falle einer Big-Endian- und einer Little-Endian-Maschine?

Adresse Big Endian Little Endian

0x2000000000000000

0x2000000000000001
6.3 Speicher 237

T e) Wie wird im Speicher an der Adresse 0x2000000000000008 die 32 Bit-Zahl


0x12345678 abgelegt im Falle einer Big-Endian- und einer Little-Endian-Maschine?

Adresse Big Endian Little Endian

0x2000000000000008

0x2000000000000009

0x200000000000000A

0x200000000000000B

f) Wie wird im Speicher an der Adresse 0x2000000000000008 die 64 Bit-Zahl


12345678 abgelegt im Falle einer Big-Endian- und einer Little-Endian-Maschine?

Adresse Big Endian Little Endian

0x2000000000000008

0x2000000000000009

0x200000000000000A

0x200000000000000B

0x200000000000000c

0x200000000000000D

0x200000000000000E

0x200000000000000F
238 6 MMIX-Prozessor

Speicherorganisation

T a) Was wird im Textsegment gespeichert?

T b) Was ist ein Interrupt?

T c) Nennen Sie ein Ereignis, bei dem ein Interrupt auftreten kann.

T d) Was sind Interruptvektoren?

T e) Was wird im Datensegment gespeichert?


American Standard Code for Information Interchange – Wikipedia 02.11.11 09:45

6.3 Speicher 239


boten auch Acht-Bit-Codes, in denen ein Byte für ein Zeichen stand, zu wenig Platz, um alle
Zeichen der menschlichen Schriftkultur gleichzeitig unterzubringen. Dadurch wurden mehrere
verschiedene spezialisierte Erweiterungen notwendig. Daneben existieren vor allem für den
ostasiatischen Raum einige ASCII-kompatible Kodierungen, die entweder zwischen verschiedenen
T f)Codetabellen
Was wirdumschalten
im Poolsegment gespeichert?
oder mehr als ein Byte für jedes Nicht-ASCII-Zeichen benötigen.[1]
Keine dieser Acht-Bit-Erweiterungen ist aber „ASCII“, denn das bezeichnet nur den einheitlichen
Sieben-Bit-Code.

Für die Kodierung lateinischer Zeichen wird fast nur noch im Großrechnerbereich eine zu ASCII
inkompatible Kodierung verwendet (EBCDIC).

Zusammensetzung
Gegeben ist die nachfolgend abgebildete ASCII-Tabelle:
ASCII-Zeichentabelle, hexadezimale Nummerierung
Code …0 …1 …2 …3 …4 …5 …6 …7 …8 …9 …A …B …C …D …E …F
0… NUL SOH STX ETX EOT ENQ ACK BEL BS HT LF VT FF CR SO SI
1… DLE DC1 DC2 DC3 DC4 NAK SYN ETB CAN EM SUB ESC FS GS RS US
2… SP ! " # $ % & ' ( ) * + , - . /
3… 0 1 2 3 4 5 6 7 8 9 : ; < = > ?
4… @ A B C D E F G H I J K L M N O
5… P Q R S T U V W X Y Z [ \ ] ^ _
6… ` a b c d e f g h i j k l m n o
7… p q r s t u v w x y z { | } ~ DEL

Die ersten 32 ASCII-Zeichencodes (von 00 bis 1F) sind für Steuerzeichen (control character)
reserviert; siehe dort für die Erklärung der Abkürzungen in obiger Tabelle. Das sind Zeichen, die
g) Geben Sie den Inhalt des Poolsegments für das Programm ls an, das mit dem
keine Schriftzeichen darstellen, sondern die zur Steuerung von solchen Geräten dienen (oder
dienten), die den-la
Parameter aufgerufen
ASCII verwendenwird (Aufruf:
(etwa ls -la).
Drucker). Steuerzeichen sind beispielsweise der
Wagenrücklauf für den Zeilenumbruch oder Bell (die Glocke); ihre Definition ist historisch
begründet.

Code 20 (SP)0x4000000000000000
ist das Leerzeichen (engl. space oder blank), das in einem Text als Leer- und
Trennzeichen zwischen Wörtern verwendet und auf der Tastatur durch die Leertaste erzeugt wird.
0x4000000000000008
Die Codes 21 bis 7E stehen für druckbare Zeichen, die Buchstaben, Ziffern und Satzzeichen
umfassen. 0x4000000000000010

Code 7F (alle0x4000000000000018
sieben Bits auf eins gesetzt) ist ein Sonderzeichen, das auch als Löschzeichen
bezeichnet wird (DEL). Dieser Code wurde früher wie ein Steuerzeichen verwendet, um auf
Lochstreifen 0x4000000000000020
oder Lochkarten ein bereits gelochtes Zeichen nachträglich durch das Setzen aller
Bits, das heißt durch Auslochen aller sieben Markierungen, löschen zu können – einmal
vorhandene Löcher kann man schließlich nicht mehr rückgängig machen. Bereiche ohne Löcher
0x4000000000000028
http://de.wikipedia.org/wiki/Ascii Page 3 of 11
0x4000000000000030

0x4000000000000038
240 6 MMIX-Prozessor

T h) Geben Sie den Inhalt des Poolsegments für das Programm rm an, das mit dem
Parameter -rf und * aufgerufen wird (Aufruf: rm -rf *).

0x4000000000000000

0x4000000000000008

0x4000000000000010

0x4000000000000018

0x4000000000000020

0x4000000000000028

0x4000000000000030

0x4000000000000038

i) Wie werden in der Programmiersprache C einem Programm Parameter übergeben?

j) Wie kann man in der Programmiersprache C auf die Parameter zugreifen?


6.3 Speicher 241

k) Wie kann man beim MMIX auf die Paramter zugreifen?

Virtueller Speicher

a) Wenn alle Programme an Adresse 0x100 beginnen bzw. alle Programme ihre
Daten ab Adresse 0x2000000000000000 im Speicher ablegen: Überschreiben
die verschiedenen Programme dann nicht gegenseitig ihre Daten? Ja/nein und
warum?

b) Was bedeutet virtueller Speicher?

c) Wozu ist virtueller Speicher gut?


242 6 MMIX-Prozessor

6.4 MMIX-Programme
MMIX-Programme bzw. Assembler-Programme für den MMIX-Prozessor sind Quelltext-
Dateien mit Befehlen für
• den MMIX-Prozessor; die vom MMIX unterstützen Befehle nennt man auch
‘‘Befehlssatz-Befehle’’
• den Loader; der Loader ist derjenige Teil des Betriebssystems, der auszufüh-
rende Programme vom der Festplatte/SSD in den Speicher lädt
• den Assemblierer; der Assemblierer, oft auch Assembler genannt, ist das
Computerprogramm, das MMIX-Quelltext in Binärdateien mit MMIX-Befehlen
und Loader-Anweisungen übersetzt

Aufbau
Nachfolgende Abbildung zeigt, wie MMIX-Programme (Quelltext) aus vier durch Leer-
zeichen und Tabulatoren voneinander getrennte Spalten aufgebaut sind.

Marke Befehl Operanden Kommentar

LOC Data_Segment
GREG @
SP GREG Pool_Segment
A OCTA 123456 A initialisieren

a IS $1 Name für $1

LOC #100 Beginne an 0x100


Main LDO a,A A in Reg. a laden

Start SUB SP,SP,8


STO a,:SP,0
... ...

• In der ersten Spalte stehen Marken.


• Marken sind Namen, über die Speicherstellen (Befehle oder Daten)
angesprochen werden können.
• Bis auf die Marke Main (Programm-Beginn) sind Marken optional.
6.4 MMIX-Programme 243

• Enthält eine Zeile Befehle, jedoch keine Marke, dann muss die Zeile
mit einem Leerzeichen oder Tabulator beginnen. Anderenfalls würde
der Befehl als Marke interpretiert und die Operanden als Befehl, was
zu Fehlern führen würde.
• Beginnt eine Zeile mit einem Zeichen 2
/ {a ... z, A...Z, 0...9}, so wird
diese Zeile als Kommentar ignoriert.

• In der zweiten Spalte stehen Befehle, d.h. sowohl Befehle aus dem Befehlssatz
des MMIX-Prozessors, als auch Anweisungen für den Assembler oder Loader.
• In der dritten Spalte stehen die Operanden. Mehrere Operanden werden durch
Komma (ohne Leerzeichen) getrennt.
• In der vierten Spalte stehen Kommentare. Kommentare sind optional. Sie
können Leerzeichen enthalten.

Assembler- und Loader-Befehle

Der IS-Befehl
Der IS-Befehl ist eine Assemblierer-Anweisung, d.h. er wird von dem Assemblierungs-
Programm ausgeführt, das in Assembler-Sprache geschriebene Befehle in Maschi-
nensprache (Nuller und Einser) übersetzt. Der IS-Befehl dient dazu, Allzweck-Register
sinnvoll benennen zu können. Die Syntax des Befehls lautet:

Name IS Register

Name ist der neue Name, Register das entsprechende Register. Ein Beispiel für die
Anwendung des IS-Befehls lautet:

Seitenlaenge IS $3

Dieser Befehl veranlasst den Assemblierer dazu, im Quelltext nach den Zeichenketten
‘‘Seitenlaenge’’ zu suchen und diese durch die Zeichenkette ‘‘$3’’ zu ersetzen. Dieser
Schritt wird – wie der Präprozessor in C – vor der Übersetzung des Programms in
Maschinensprache ausgeführt.

Der GREG-Befehl
Der GREG-Befehl ist ein Loader-Befehl, d.h. er wird vom Loader beim Laden eines
auszuführenden Programms von der Festplatte/SSD in den Arbeitsspeicher ausgeführt.
Der GREG-Befehl reserviert das nächste freie globale Register (d.h. er verringert die in
rG stehende Zahl um den Wert 1). Wenn für den GREG-Befehl ein Parameter angegeben
244 6 MMIX-Prozessor

ist, wird das globale Register mit dem entsprechenden Wert initialisiert. Die Syntax des
GREG-Befehls lautet:

Name GREG Wert

Name ist der Wert, über den das neue globale Register ansprechbar sein soll (wie beim
IS-Befehl), Wert ist der Initialisierungs-Wert. Name und Wert sind optional.

Beispiel: Steht in Register rG der Wert 255, dann hat der Befehl

SP GREG #4000000000000000

folgende Auswirkungen:
• Der in rG abgespeicherte Wert wird von 255 auf 254 geändert.
• In Register 254 wird der Wert 0x4000000000000000 abgespeichert; beim MMIX-
Assemblierer werden hexadezimale Zahlen mit einer führenden Raute (‘‘#’’)
statt mit führendem ‘‘0x’’ gekennzeichnet.
• Register 254 kann auch über den Namen SP angesprochen werden.

Der LOC-Befehl
Der LOC-Befehl ist ein Loader-Befehl. ‘‘LOC’’ steht für ‘‘locate an address’’ und setzt
die Eingabemarke des Loaders auf die als Parameter angegebene Adresse. Der Befehl
teilt dem Loader beim Laden einer ausführbaren MMIX-Datei in den Arbeitsspeicher mit,
• ab welcher Adresse Befehlscode in den Speicher geschrieben oder
• ab welcher Speicher-Adresse Variable angelegt werden sollen.

Die Syntax des Befehls lautet:

LOC Adresse

Als Adresse kann entweder eine Zahl, oder ein Segmentname (z.B. Data_Segment)
angegeben werden. Der Befehl

LOC #100

zeigt dem Loader beispielsweise an, dass die nachfolgenden Daten im Speicher ab
Adresse 0x100 abgelegt werden sollen.

Die vom Loader aktuell betrachtete Adresse wird beim MMIX mit dem Zeichen @
bezeichnet. @ meint dabei ‘‘the place where we are at’’.
6.4 MMIX-Programme 245

Die Befehle BYTE, WYDE, TETRA und OCTA


Die Befehle BYTE, WYDE, TETRA und OCTA sind Loader-Befehle, die Datenworte der
Größe 8 Bit (BYTE), 16 Bit (WYDE), 32 Bit (TETRA) und 64 Bit (OCTA) im Speicher
allozieren (anlegen) und diesen bei Angabe von Parametern auch initialisieren.

Die Syntax lautet:

Marke Befehl Wert

• Befehl ist einer der Anweisungen BYTE, WYDE, TETRA, OCTA,


• Marke ist der Name (auch ‘‘Marke’’ genannt), über den auf die Adresse der
allozierten Daten zugegriffen werden kann, und
• Wert der Zahlenwert, mit dem das Datenwort initialisiert werden soll; werden
mehrere Werte durch Komma (ohne Leerzeichen) getrennt, werden mehrere
Datenworte desselben Typs angelegt.

Beispiel: Die Befehle

LOC Data_Segment
Vektor BYTE 1,2,3

reservieren im Speicher an Adresse 0x20000000000000000 drei Byte und initialisieren


diese mit den Werten 1, 2 und 3. Nachfolgende MMIX-Befehle können auf die Adresse
des ersten Byte (das Byte, in dem die ‘‘1’’ gespeichert ist) über die Marke Vektor
zugreifen.

Beim MMIX werden aus mehreren Byte zusammengesetzte Datenworte (Wyde, Tetra,
Octa) an Adressen ausgerichtet, die dem ganzzahligen Vielfachen ihrer Datenwort-
breite entsprechen (Alignment). Zur Einhaltung des Alignments werden ggf. Leer-Byte
eingefügt. Die Codierung der Datenworte folgt dem Big-Endian-Schema.

Mit jedem durch BYTE, WYDE, TETRA oder OCTA allozierten Datenwort wird die aktuelle
Adresse @ um die entsprechende Byteanzahl erhöht. Müssen aufgrund des Alignments
Leer-Byte eingefügt werden, so werden diese bei der Erhöhung ebenfalls berücksichtigt.
246 6 MMIX-Prozessor

Aufgaben

T a) Aus wievielen/welchen Spalten bestehen MMIX-Programme?

T b) Wie werden die Spalten im Programmcode getrennt?

T c) Wie muss man MMIX-Codezeilen schreiben, die keine Marke verwenden?

T d) Wie kann man beim MMIX-Assembler eine komplette Zeile auskommentieren?

T e) Werden alle vier Spalten eines MMIX-Programms für den Übersetzungsvorgang


herangezogen? Gehen Sie auf die einzelnen Spalten ein.
6.4 MMIX-Programme 247

f) Geben Sie Anweisungen an, mit denen Sie die Register 0, 1 und 2 durch die
Namen a, b und c ansprechbar machen.

T g) Geben Sie Anweisungen an, mit denen Sie die Register 1, 2 und 3 durch die
Namen ankathete, gegenkathete und hypothenuse ansprechbar machen.

h) Geben Sie die Anweisung an, mit denen Sie ein globales Register anlegen,
dieses über den Namen PI ansprechbar machen und mit 0x400921FB54442EEA
initialisieren.

T i) Geben Sie die Anweisung an, mit denen Sie ein globales Register anlegen und
dieses über den Namen A ansprechbar machen.
248 6 MMIX-Prozessor

T j) Mit welchen Befehlen können Sie Worte der Länge 8, 16, 32 und 64 Bit im Speicher
reservieren?

T k) Was ist der Loader?

l) Geben Sie Befehle an, mit denen Sie an Speicheradresse #2000000000000000


vier Bytes reservieren, die über die Marken A, B, C und D angesprochen werden
können. A soll mit 1 und B mit 2 initialisiert werden. Fügen Sie auch einen
geeigneten Befehl zur Reservierung und Initialisierung eines globalen Registers mit
dem Wert 0x2000000000000000 ein.
6.4 MMIX-Programme 249

T m) Geben Sie Befehle an, mit denen Sie an Speicheradresse #2000000000000000


zwei 64 Bit Werte reservieren, die über die Marken Null, NaN und Inf angesprochen
werden können. Null soll mit der Gleitkommazahl 0.0 initialisiert werden, NaN
mit der Gleitkomma-Codierung ‘‘Not a Number’’ und Inf mit der Gleitkomma-
Codierung ‘‘unendlich’’. Fügen Sie auch einen geeigneten Befehl zur Reservierung
und Initialisierung eines globalen Registers mit dem Wert 0x2000000000000000
ein.

Betrachten Sie die folgenden Befehle:

LOC #2000000000000000
X BYTE
Y WYDE
Z OCTA

n) Geben Sie die Adressen an, an denen X und Y im Speicher abgelegt werden.

o) An welchen Adressen wird Z abgelegt?


250 6 MMIX-Prozessor

Betrachten Sie die folgenden Befehle:

LOC #2000000000000000
A WYDE
B TETRA
C BYTE
D OCTA

T p) Geben Sie die Adressen an, an denen A, B, C und D im Speicher abgelegt werden.
6.4 MMIX-Programme 251

q) Geben Sie Befehle an, die


• ein neues globales Register anlegen und dieses mit Speicheradresse
0x2000000000000000 initialisieren,
• an dieser Speicheradresse ein 64 Bit breites Datenwort anlegen, das mit
4 initialisiert wird und über die Marke N angesprochen werden kann,
• an den darauffolgenden Speicheradressen zwei 4-dimensionale Vektoren
wie folgt anlegen:
• Der erste Vektor soll über ADR_A1 ansprechbar sein und mit den
64 Bit-Zahlen [1, 2, 3, 4] initialisert werden;
• der zweite Vektor soll über ADR_A2 ansprechbar sein und mit den
64 Bit-Zahlen [10, 20, 30, 40] initialisiert werden.
252 6 MMIX-Prozessor

T r) Geben Sie Befehle an, die


• ein neues globales Register anlegen und dieses mit Speicheradresse
0x2000000000000000 initialisieren,
• an dieser Speicheradresse ein 64 Bit breites Datenwort anlegen, das mit
der Marke Erg angesprochen werden kann,
• an den darauffolgenden Speicheradressen zwei 3-dimensionale Vektoren
wie folgt anlegen:
• Der erste Vektor soll über V1 ansprechbar sein und mit den 32
Bit-Zahlen [100, 200, 300] initialisert werden;
• der zweite Vektor soll über V2 ansprechbar sein und mit den 32
Bit-Zahlen [10, 20, 30] initialisiert werden.
6.4 MMIX-Programme 253

Übersetzungsprozess
Nachfolgende Abbildung zeigt den Übersetzungsprozess, mit dem MMIX-Quelldateien
in MMIX-Objektdateien umgewandelt werden um anschließend vom MMIX-Simulator
ausgeführt werden zu können.

Quelldatei *.mms
LOC Data_Segment
GREG @
A OCTA 3
a IS $1

LOC #100
Main LDO a,A
ADD a,a,8
STO a,A

mmixal *.mms Assembler


(Präprozessor)

LOC Data_Segment
GREG @
A OCTA 3
a IS $1

LOC #100
Main LDO $1,$254,0
ADD $1,$1,8
STO $1,$254,0

Assembler

Binärdatei *.mmo
xxxxxxxxxxxxxxxxxxxxxxxx Loader-Anweisungen
xxxxxxxxxxxxxxxxxxxxxxxx
8D01FE0020010108AD01FE00 MMIX-Befehle
xxxxxxxxxxxxxxxxxxxxxxxx
Symboltabelle

mmix -i *.mmo

MMIX-Simulator

MMIX-Quelldateien werden mit einem Texteditor erstellt. Die Quelldateien haben die
Endung mms (MMIX source). Mit einem Aufruf des Assemblierungsprogramms mmixal
254 6 MMIX-Prozessor

werden die Quelldateien in Objektdateien übersetzt. Der Assembler verarbeitet zunächst


die Assembler-Anweisungen (z.B. IS-Befehle) mit einem Präprozessor und löst Namen
und Marken auf. Anschließend übersetzt er die MMIX-Befehle (mit den aufgelösten
Marken) in entsprechende Binärwerte. Die durch Namen und Marken gegebenen An-
weisungen sind somit implizit in den MMIX-Befehlen enthalten (Nummer des Registers,
Speicheradresse, ...). Aus den Sprung-Marken erstellt der Assembler eine Symboltabel-
le, in der für jedes vorkommende Symbol die entsprechende Adresse eingetragen wird.
Auf diese Weise kann z.B. der Loader über die Symboltabelle die Adresse der Marke
Main ermitteln und zum Programmstart an diese Adresse verzweigen.

Befehlswort
Das Befehlswort beim MMIX ist für alle Befehle 32 Bit breit, d.h. die Länge des
Befehlsworts (in Byte) ist konstant. Dies ist ein typisches Merkmal für RISC-Prozessoren.
Durch die konstante Befehlswortbreite ist es sehr einfach, Befehle ‘‘im Voraus’’ aus dem
Befehlsspeicher zu laden: Da alle Befehle vier Byte breit sind, können durch Laden der
nächsten 4 · n Byte die nächsten n Befehle aus dem Speicher geladen werden.
Bei CISC-Prozessoren ist die Länge des Befehlsworts nicht konstant sondern abhängig
vom jeweiligen Befehl. Bei x86 sind Befehlsworte beispielsweise zwischen 1 und 15 Byte
lang.

Beim MMIX gliedert sich das 32 Bit breite Befehlswort in vier Byte, die Opcode, X, Y und
Z genannt werden.
31 24 23 16 15 8 7 0

OP X Y Z

• Der Opcode ist eine 8 Bit breite Zahl die festlegt, um welchen Befehl es sich
handelt (Addieren, Subtrahieren, ...). Die Zuordnung Opcode $ Befehl wird
durch eine Tabelle (s.u.) spezifiziert.
• X ist (bis auf Speicherbefehle) der Ziel-Operand, d.h. eine 8 Bit breite Zahl,
die festlegt, in welches Register (0 bis 255 bei Allzweckregistern bzw. 0 bis
31 bei Spezialregistern) das Ergebnis der Operation abgelegt werden soll. Die
Codierung von X entspricht der Registernummer, d.h. ‘‘Register 1’’ wird als
X = 0000 00012 = 0x01 codiert.
• Y und Z sind die Quelloperanden, d.h. zwei 8 Bit breite Zahlen, die festlegen,
in welchen Registern die Quelloperanden stehen. Die Codierung entspricht der
von X.
6.4 MMIX-Programme 255

Spezialregister werden im Befehlswort wie folgt codiert:

x S(x) x S(x) x S(x) x S(x)


0x00 rB 0x08 rC 0x10 rQ 0x18 rW
0x01 rD 0x09 rN 0x11 rU 0x19 rX
0x02 rE 0x0A rO 0x12 rV 0x1A rY
0x03 rH 0x0B rS 0x13 rG 0x1B rZ
0x04 rJ 0x0C rI 0x14 rL 0x1C rWW
0x05 rM 0x0D rT 0x15 rA 0x1D rXX
0x06 rR 0x0E rTT 0x16 rF 0x1E rYY
0x07 rBB 0x0F rK 0x17 rP 0x1F rZZ

Viele MMIX-Befehle verwenden sog. Direktoperanden (engl. immediate operands), d.h.


Operanden, die direkt im Befehlswort stehen. Beim MMIX sind folgende Direktoperanden
möglich:
• Z: Die Bits 7 ... 0 des Befehlsworts enthalten eine 8 Bit breite Zahl.
• Y: Die Bits 15 ... 8 des Befehlsworts enthalten eine 8 Bit breite Zahl.
• YZ: Die Bits 15 ... 0 des Befehlsworts enthalten eine 16 Bit breite Zahl.
• XYZ: Die Bits 23 ... 0 des Befehlsworts enthalten eine 24 Bit breite Zahl.
256 6 MMIX-Prozessor

Nachfolgende Tabelle übersetzt MMIX-Opcodes in diejenigen Zahlen, die im Befehlswort


!"#"$% &'()*+,-.%(*/%012'(*/%
in! den Bits 31...24 abgelegt werden müssen.
&'(!)*+*,-(#.*-/!01234/*5!67*8434/*9!:;</!=*8>((!7'3,+4-=*7/*<!?'@*--*!A@*<(*BCBD!
!
0x..0 0x..1 0x..2 0x..3 0x..4 0x..5 0x..6 0x..7
TRAP 5ν FCMP ν FUN ν FEQL ν FADD 4ν FIX 4ν FSUB 4ν FIXU 4ν
0x0.. 0x0..
FLOT[I] 4ν FLOTU[I] 4ν SFLOT[I] 4ν SFLOTU[I] 4ν
FMUL 4ν FCMPE 4ν FUNE ν FEQLE 4ν FDIV 40ν FSQRT 40ν FREM 4ν FINT 4ν
0x1.. 0x1..
MUL[I] 10ν MULU[I] 10ν DIV[I] 60ν DIVU[I] 60ν
ADD[I] ν ADDU[I] ν SUB[I] ν SUBU[I] ν
0x2.. 0x2..
2ADDU[I] ν 4ADDU[I] ν 8ADDU[I] ν 16ADDU[I] ν
CMP[I] ν CMPU[I] ν NEG[I] ν NEGU[I] ν
0x3.. 0x3..
SL[I] ν SLU[I] ν SR[I] ν SRU[I]ν
BN[B] ν+π BZ[B] ν+π BP[B] ν+π BOD[B] ν+π
0x4.. 0x4..
BNN[B] ν+π BNZ[B] ν+π BNP[B] ν+π BEV[B] ν+π
PBN[B] 3ν-π PBZ[B] 3ν-π PBP[B] 3ν-π PBOD[B] 3ν-π
0x5.. 0x5..
PBNN[B] 3ν-π PBNZ[B] 3ν-π PBNP[B] 3ν-π PBEV[B] 3ν-π
CSN[I] ν CSZ[I] ν CSP[I] ν CSOD[I] ν
0x6.. 0x6..
CSNN[I] ν CSNZ[I] ν CSNP[I] ν CSEV[I] ν
ZSN[I] ν ZSZ[I] ν ZSP[I] ν ZSOD[I] ν
0x7.. 0x7..
ZSNN[I] ν ZSNZ[I] ν ZSNP[I] ν ZSEV[I] ν
LDB[I] µ+ν LDBU[I] µ+ν LDW[I] µ+ν LDWU[I] µ+ν
0x8.. 0x8..
LDT[I] µ+ν LDTU[I] µ+ν LDO[I] µ+ν LDOU[I] µ+ν
LDSF[I] µ+ν LDHT[I] µ+ν CSWAP[I] 2µ+2ν LDUNC[I] µ+ν
0x9.. 0x9..
LDVTS[I] ν PRELD[I] ν PREGO[I] ν GO[I] 3ν
STB[I] µ+ν STBU[I] µ+ν STW[I] µ+ν STWU[I] µ+ν
0xA.. 0xA..
STT[I] µ+ν STTU[I] µ+ν STO[I] µ+ν STOU[I] µ+ν
STSF[I] µ+ν STHT[I] µ+ν STCO[I] µ+ν STUNC[I] µ+ν
0xB.. 0xB..
SYNCD[I] ν PREST[I] ν SYNCID[I] ν PUSHGO[I] 3ν
OR[I] ν ORN[I] ν NOR[I] ν XOR[I] ν
0xC.. 0xC..
AND[I] ν ANDN[I] ν NAND[I] ν NXOR[I] ν
BDIF[I] ν WDIF[I] ν TDIF[I] ν ODIF[I] ν
0xD.. 0xD..
MUX[I] ν SADD[I] ν MOR[I] ν MXOR[I] ν
SETH ν SETMH ν SETML ν SETL ν INCH ν INCHM ν INCML ν INCL ν
0xE.. 0xE..
ORH ν ORMH ν ORML ν ORL ν ANDNH ν ANDNMH ν ANDNML ν ANDNL ν
JMP[B] ν PUSHJ[B] ν GETA[B] ν PUT[I] ν
0xF.. 0xF..
POP 3ν RESUME 5ν [UN]SAVE 20µ+ν SYNC ν SWYM ν GET ν TRIP 5ν
0x..8 0x..9 0x..A 0x..B 0x..C 0x..D 0x..E 0x..F !
!
!
&'(!*<(B*!E;@@-*!0F!);B#G*<B9!/*(!1234/*(!*7B(2<;3,B!/*<!&422*-C*;-*!0H!@;(!IJ95!;7!/*<!(;3,!/*<!)*#
+*,-(34/*!@*+;7/*BD!
Die Übersetzung erfolgt folgendermaßen:
!
! • Befehl suchen
&'(!C:*;B*!E;@@-*!/*(!1234/*(!*<=;@B!(;3,!:;*!+4-=BK!
! • Doppelzeile ermitteln, in der der Befehl steht
−! 6L)!0);B!E<D!"9!/*(!C:*;B*7!E;@@-*(!
• An +der
! H5!:*77!(;3,!/*<!)*+*,-!;8!4@*<*7!?*;-!/*<!&422*-
Seite der Tabelle das obere Nibble (= die !"#$" !@*+;7/*B!
oberen 4 Bits) des Opcodes
+! I5!:*77!(;3,!/*<!)*+*,-!;8!M7B*<*7!?*;-!/*<!&422*-!"#$"!@*+;7/*B!!
! ablesen, z.B. ADD ) 0x2
−! );B(!$5!I!M7/!H!/*(!C:*;B*7!E;@@-*(!*7B(2<*3,*7!/*<! %&'$("!0H!@;(!%95!;7!/*8!(;3,!/*<!)*+*,-(#
• Prüfen, ob der Befehl im oberen oder im unteren Teil der Doppelzeile steht
34/*!@*+;7/*B!
!
• Steht der Befehl im oberen Teil der Doppelzeile, kann man das untere
[I]!@*/*MB*BK!N88*/;'B*#O'<;'7B*!/*(!)*+*,-(!
−! ;88*/;'B*!
Nibble ⇔(=!&;<*PB42*<'7/!
die unteren 4 Bits) des Opcodes an der ersten Tabellenzeile
−! ADD $1,$2,$3K!7;3,B!;88*/;'B*5!/'!/*<!"D!12*<'7/!*;7!Q*=;(B*<!;(B!M7/!P*;7*!R',-!
ablesen, z.B. ADD ) 0x..0 oder 0x..1
−! ADD $1,$2,3K!;88*/;'B*5!/'!'-(!"D!12*<'7/!*;7*!R',-!'7=*=*@*7!;(B!M7/!P*;7!Q*=;(B*<!
−! /*<! 1234/*!
• Steht der/*<! ;88*/;'B*#O'<;'7B*!
Befehl im unteren Teil *;7*(!der
)*+*,-(! ;(B! ;88*<! kann
Doppelzeile, M8! I! man
,S,*<!das
'-(! /;*! 7;3,B#
;88*/;'B*#O'<;'7B*!/*(!)*+*,-(!0(B*,B!;7!/*<!&422*-)&'$("!'-(4!<*3,B(9!
−! *;7*! ;88*/;'B*#O'<;'7B*! /*(! )*+*,-(!:;</! T48! U((*8@-*<!'MB48'B;(3,! '7,'7/! /*(! +*,-*7/*7!
&4--'<#R*;3,*7(! 0$9! *<P'77B5! :*(,'-@! ;8! V<4=<'88! 7;3,B! *W2-;C;B! ADDI! =*(3,<;*@*7! :*</*7!
8M((!!!

! "#$%
6.4 MMIX-Programme 257

untere Nibble (=die unteren 4 Bits) des Opcodes an der untersten


Tabellenzeile ablesen, z.B. 2ADDU ) 0x..8 oder 0x..9

• Anschließend muss nur noch unterschieden werden, ob es sich um die linke


oder die rechte Variante des Befehls handelt, beispielsweise ob man in der
oberen Zeile 0x..0 oder 0x..1 auswählen muss oder ob man in der unteren
Zeile 0x..8 oder 0x..9 auswählen muss. Dazu wird der in der Tabelle nach dem
Befehlsnamen in Klammern stehende Buchstabe verwendet;
• I bedeutet immediate, d.h. Direktoperand; Beispiel: Bei ADD $1,$2,$3
wird ADD mit 0x20 codiert, bei ADD $1,$2,3 mit 0x21
• B bedeutet backward, d.h. Rückwärtssprung; erhöht sich bei einem
Sprung die Adresse, wird der linke Zahlenwert verwendet (Vorwärts-
Sprung); verringert sich bei einem Sprung die Adresse, wird der rechte
Zahlenwert verwendet (Rückwerts-Sprung)

Aus der Tabelle lassen sich auch die von Donald Knuth für den MMIX-Simulator
spezifizierten Ausführungszeiten ermitteln:
• ⌫ entspricht der Dauer von 1 Takt
• µ ist die Anzahl der Takte für einen Speicherzugriff
• ⇡ bedeutet
• 3 · ⌫, wenn gesprungen wird, und
• 0 · ⌫, wenn nicht gesprungen wird.
258 6 MMIX-Prozessor

Aufgaben

T a) Wie breit (in Bit) ist das MMIX Befehlswort?

T b) Skizzieren Sie das MMIX Befehlswort und geben Sie den Inhalt jedes Bytes an.

T c) In welchen Byte des Befehlsworts wird im Allgemeinen Information über die


Quelloperanden bzw. über die Zieloperanden abgespeichert?

T d) Was ist ein Direktoperand?

e) Wieviele Taktzyklen benötigen die meisten Befehlen zur Ausführung?

f) Welcher Befehl benötigt die längste Zeit zur Ausführung, wenn man von Speicher-
befehlen absieht?

g) Wieviele Takte benötigt der BZ-Befehl, wenn gesprungen wird?


6.4 MMIX-Programme 259

h) Wieviele Takte benötigt der BZ-Befehl, wenn nicht gesprungen wird?

i) Wieviele Takte benötigt der PBZ-Befehl, wenn gesprungen wird?

j) Wieviele Takte benötigt der PBZ-Befehl, wenn nicht gesprungen wird?

k) Geben Sie das 32 Bit breite Befehlswort des Befehls ‘‘SL $1,$2,3’’ an.

T l) Geben Sie das 32 Bit breite Befehlswort des Befehls ‘‘SUB $5,$6,7’’ an.
260 6 MMIX-Prozessor

6.5 MMIX Befehle

Definitionen

Wort
w b ist ein Wort der Länge b Byte. wxb repräsentiert Bit Nr. x im Datenwort w b , wobei das
niederwertigste Bit in w b an Bitposition x = 0 liegt. wx...y
b meint Bits x...y des Datenworts
b
w .

Befehlswort
Sei ◆ ein 32 Bit breites MMIX Befehlswort.
• X = ◆23...16
• Y = ◆15...8
• Z = ◆7...0
• YZ = ◆15...0
• XY = ◆23...8
• XYZ = ◆23...0

Allzweckregister

• Der MMIX-Prozessor verfügt über 256 Allzweckregister, die mit 0, 1, ... 255
durchnummeriert werden.
• Zur Adressierung eines Allzweckregisters im Befehlswort wird die als vor-
zeichenlose 8 Bit breite Zahl codierte Registernummer verwendet. Beispiel:
Register 5 wird als 0x05 bzw. als Bitkombination 00000101 codiert.
• $x, 0  x  255 entspricht der Bitkombination, die in Register x gespeichert ist.
• $X ist die Bitkombination, die in dem durch Bits 23...16 des Befehlsworts
adressierten Register gespeichert ist. Beispiel: Befehlswort ist 0x12345678;
Bits 23...16 extrahieren ) 0x34 (= Bitkombination 00110100) = Dezimal 52 )
Im Falle des Befehlsworts 0x12345678 meint $X den Wert, der in Register 52
gespeichert ist.
• $Y ist die Bitkombination, die in dem durch Bits 15...8 des Befehlsworts
adressierten Register gespeichert ist.
• $Z ist die Bitkombination, die in dem durch Bits 7...0 des Befehlsworts adres-
sierten Register gespeichert ist.
6.5 MMIX Befehle 261

Arbeitsspeicher
M ist der Arbeitsspeicher des MMIX Prozessors (M = memory).
• M1 [x] ist das an Adresse x gespeicherte Byte.
• M2 [x] ist das an Adresse x & ( 2) gespeicherte Wyde.
• M4 [x] ist das an Adresse x & ( 4) gespeicherte Tetra.
• M8 [x] ist das an Adresse x & ( 8) gespeicherte Octa.

Die Symbole ◆, X, Y, Z, $X, $Y, $Z, $0, $1, ..., M1 [...], M2 [...], ... repräsentieren Bitmuster.
Ein Zahlenwert entsteht erst durch entsprechende Interpretation des Bitmusters (z.B.
vorzeichenlose Festkommazahl, ...).

Befehlszähler
Beim MMIX bedeutet das Zeichen @ ‘‘the place where we are at’’ und meint eine Adresse
im Speicher.
• Beim Loader bezieht sich @ auf die Adresse, an der ein Daten- oder Befehls-
worte im Speicher abgelegt werden soll.
• In Bezug auf die Befehlsausführung meint @ die Adresse des Befehls, der
gerade ausgeführt wird, also den Befehlszähler BZ (oder PC für engl. program
counter).
262 6 MMIX-Prozessor

Operationen

•x y : Weise x den Wert y zu


• x , y : Ausdruck x ist äquivalent zum Ausdruck y
• x ) y : Wenn x, dann y
• x||y : Logische operation x ODER y
• x = y : Vergleich ob x den gleichen Wert hat wie y ; liefert wahr (d.h. 1), wenn x
den selben Wert hat wie y , sonst falsch (d.h. 0)
• x ⌧ y : Schiebe x um y Stellen nach links; fülle frei werdende Bitstellen mit 0
auf
• x u y : Schiebe x um y Bitstellen nach rechts; fülle frei werdende Bitstellen
mit 0 auf
• x s y : Schiebe x um y Bitstellen nach rechts; fülle frei werdende Bitstellen mit
dem Wert des Vorzeichenbits (MSB) auf.
• x % y : Rest der Festkomma-Division x/y .
• ⇠ x: Invertiere alle Bits von x, d.h. berechne das 1er-Komplement
• x & y : Bitweise UND-Verknüpfung von x und y
• x | y : Bitweise ODER-Verknüpfung von x und y
• x ⌦ y : Bitweise XOR-Verknüpfung von x und y

Umwandlung Festkommazahl $ Gleitkommazahl

• f32 (w 4 ): Nimmt an, dass das vier Byte breite Datenwort w 4 im 32 Bit IEEE 754
Gleitkommaformat codiert ist und gibt den entsprechenden Zahlenwert zurück
(z.B. 1,75).
0 (x): Codiert die Zahl x als 32 Bit breite Gleitkommazahl und gibt das
• f32
entsprechende 32 Bit breite Bitmuster zurück.
• f64 (w 8 ): Nimmt an, dass das acht Byte breite Datenwort w 8 im 64 Bit IEEE 754
Gleitkommaformat codiert ist und gibt den entsprechenden Zahlenwert zurück
(z.B. 1,75).
0 (x): Codiert die Zahl x als 64 Bit breite Gleitkommazahl und gibt das
• f64
entsprechende 64 Bit breite Bitmuster zurück.
• r (x): Rundet eine reelle Zahl gemäß dem in Register rA ausgewählten Run-
dungsmodus auf eine ganze Zahl.
6.5 MMIX Befehle 263

(De-) Codierung von Festkommazahlen

• s(w b ): Nimmt an, dass das b Byte breite Wort w b im 2er-Komplement codiert
ist und gibt den entsprechenden Wert zurück (z.B. 1, 0, -3)
• u(w b ): Nimmt an, dass das b Byte breite Wort w b als vorzeichenlose Festkom-
mazahl codiert ist und gibt den entsprechenden Wert zurück (z.B. 0, 1)
• sb0 (x): Gibt das b Bit breite im 2er-Komplement codiert Bitmuster zurück das
dem Wert x entspricht.
• ub0 (x): Gibt das b Bit breite Bitmuster (vorzeichenlose Codierung) zurück das
dem Wert x, x 0, entspricht.

Zusammenfassen von in Registern gespeicherten Werten


Wenn $X das 64 Bit breite in Register X gespeicherte Bitmuster ist und $Y das 64 Bit breite
in Register Y gespeicherte Bitmuster ist, dann ist $X$Y das 128 Bit breite Bitmuster das
aus der Aneinanderreihung der beiden Bitmuster $X und $Y entsteht. ($X$Y)127...64 = $X
und ($X$Y)63...0 = $Y.

Programm beenden

• TRAP 0,Halt,0 beendet ein MMIX-Programm und gibt die Kontrolle zurück an
das Betriebssystem.

Register-Register-Befehle

Hardware
Der MMIX ist eine Drei-Address- Register-Register-Maschine, d.h. er verarbeitet bis
zu zwei individuell spezifizierbare Quell-Operanden zu einem Zieloperand, wobei alle
Operanden in Registern stehen.
Auf die durch Y und Z adressierten Operanden wird beim MMIX nur lesend zugegriffen.
Auf X wird sowohl lesend als auch schreibend zugegriffen.
264 6 MMIX-Prozessor

a) Vervollständigen Sie nachfolgende Schaltung des Registerblocks (engl. register


file so, dass
• an den Ausgängen $X, $Y und $Z die durch X, Y und Z spezifizierten
Register automatisch ausgegeben werden und
• das am Eingang $X anliegende Datenwort im Falle einer positiven Flanke
am clk-Eingang in das durch X spezifizierte Register übernommen wird.

clk
64
0
64
1
64
$X
64

$X
64
64 $0 64
64
255

64
0
64
1
X 64
8 $Y
64 $1 64 64

64
255

8
Y
8
64
0
64
1
64
$Z
64
Z
8
64 $255 64
64
255

8
6.5 MMIX Befehle 265

T b) Vervollständigen Sie nachfolgende Schaltung des Rechenwerks (= ALU = Arith-


metic Logic Unit) so, dass mit der Steuerleitung op (operation) die Ergebnisse der
verschiedenen integrierten Hardware-Schaltungen an den Ausgang durchgeschal-
tet werden können.

a
64 a >>u b
b

ADD

a
a << b FADD
b
a
SUB a-b
b
a a 64
a >>s b FSUB a-b
b b

MUL

a
a|b
b

64
266 6 MMIX-Prozessor

c) Entwickeln Sie einen MMIX-Prozessor, der Register-Register-Befehle mit 8 Bit


vorzeichenlosen Direktoperanden Z ausführen kann sowie vorzeichenlose 16 Bit
Direktoperanden YZ in Register X ablegen kann.

Allzweck-
Registerblock

$X $X
64 64
Adresse

X $Y
Befehls- 8 64
Speicher Y
8
ALU
Daten Z $Z
8 64

Arithmetische Befehle auf Festkommazahlen

Befehl Operanden Name/Aktion Definition


$X 0 (s($Y) + s($Z))
s64
(s($Y) + s($Z) < 263 ) ||
$X,$Y,$Z Add; signed, with overflow
(s($Y) + s($Z) 263 ) )
rA 0 (26 )
rA|u64
ADD 0 (s($Y) + u(Z))
$X s64
(s($Y) + u(Z) < 263 ) ||
$X,$Y,Z Add immediate; signed, with overflow
(s($Y) + u(Z) 263 ) )
rA 0 (26 )
rA|u64
$X,$Y,$Z Add unsigned; no overflow $X 0 (u($Y) + u($Z))
u64
ADDU 0 (u($Y) + u(Z))
$X,$Y,Z Add unsigned; no overflow $X u64
6.5 MMIX Befehle 267

$X 0 (s($Y)
s64 s($Z))
(s($Y) s($Z) < 263 ) ||
$X,$Y,$Z Subtract; signed, with overflow
(s($Y) s($Z) 263 ) )
rA 0 (26 )
rA|u64
SUB 0 (s($Y)
$X s64 u(Z))
(s($Y) u(Z) < 2 ) ||63
$X,$Y,Z Subtract immed.; signed, with ovf.
(s($Y) u(Z) 263 ) )
rA 0 (26 )
rA|u64
$X,$Y,$Z Subtract uns.; no ovf. $X 0 (u($Y)
u64 u($Z))
SUBU 0
$X,$Y,Z Subtract uns. immed.; no ovf. $X u64 (u($Y) u(Z))
$X 0 (u(Y)
s64 s($Z))
$X,Y,$Z Negate; signed, with overflow u(Y) s($Z) 263 )
rA 0 (26 )
rA|u64
NEG
$X,Y,Z Negate immediate; signed $X 0 (u(Y)
s64 u(Z))

$X,Y,$Z Negate unsigned; no overflow $X 0 (u(Y)


s64 s($Z))
NEGU 0
$X,Y,Z Negate unsigned immedidate $X s64 (u(Y) u(Z))
$X 0 (s($Y) · s($Z))
s64
(s($Y) · s($Z) < 263 ) ||
$X,$Y,$Z Multiply; signed, with overflow
(s($Y) · s($Z) 263 ) )
rA 0 (26 )
rA|u64
MUL 0 (s($Y) · u(Z))
$X s64
(s($Y) · s($Z) < 263 ) ||
$X,$Y,Z Multiply immed.; signed, with ovf.
(s($Y) · s($Z) 263 ) )
rA 0 (26 )
rA|u64
$X,$Y,$Z Mult. uns.; 128 bit result rH$X 0 (u($Y) · u($Z))
u128
MULU 0 (u($Y) · u(Z))
$X,$Y,Z Mult. uns. imm.; 128 bit result rH$X u128
Divide; signed $X 0 (bs($Y)/s($Z)c)
s64
(case $Z 6= 0) rR 0 ( s($Y) % s($Z) )
s64
$X,$Y,$Z 0 (0)
Divide signed $X u64
(case $Z = 0) rR $Y
DIV 0
Divide immediate; signed $X s64 (bs($Y)/s(Z)c)
(case Z 6= 0) rR 0 ( s($Y) % u(Z) )
s64
$X,$Y,Z 0 (0)
Divide immediate; signed $X u64
(case Z = 0) rR $Y
268 6 MMIX-Prozessor

Divide uns.; 128 bit $X 0 ( bu(rD$Y)/u($Z)c )


u64
case u($Z) > u(rD) rR 0 ( u(rD$Y) % u($Z) )
u64
$X,$Y,$Z
Divide uns.; 128 bit dividend $X rD
no ovf.; case u($Z)  u(rD) rR $Y
DIVU 0 ( bu(rD$Y)/u(Z)c )
Divide uns. immed.; 128 bit $X u64
no overflow; case u(Z) > u(rD) rR 0 ( u(rD$Y) % u(Z) )
u64
$X,$Y,Z
Divide uns. immed.; 128 bit $X rD
no ovf.; case u(Z)  u(rD) rR $Y

Direktoperand in Register schreiben

Befehl Operanden Name/Aktion Definition


SETL $X,YZ Set to low wyde $X 0 (u(YZ))
u64

Der Assembler akzeptiert statt SETL auch SET, um Direktoperanden in ein Register zu
laden. Wird SET mit einem Register als zweiter Operand aufgerufen, wird der Befehl SET
$X,$Y in den Befehl OR $X,$Y,0 übersetzt.

T a) In welchem Wertebereich können die Direktoperanden bei den Arithmetischen


Befehlen liegen?

T b) Kann mit dem ADD Befehl 3 + 5 in einer einzigen Codezeile berechnet werden?

T c) Wie kann man 5 3 in einer einzigen Codezeile berechnen?


6.5 MMIX Befehle 269

T d) Was ist der Unterschied zwischen den Befehlen MUL und MULU?

T e) Geben Sie die MMIX-Befehle an, mit denen Sie x = a2 + 2 · a · b + b 2 mit Fest-
kommazahlen berechnen. Nehmen Sie an, dass die Register a, b, und c bereits
initialiert wurden und das Ergebnis in Register x gespeichert werden soll. Benutzen
Sie Register buf1, buf2, ... für Zwischenergebnisse, falls notwendig.
270 6 MMIX-Prozessor

Gegeben ist der folgende Programmcode:

a IS $0
b IS $1
c IS $2
d IS $3
buf1 IS $4
buf2 IS $5

LOC #100
Main SETL b,1
SETL c,2
SETL d,3

c·d b
f) Geben Sie MMIX-Befehle an, mit denen Sie a = b+c+d mit Festkommazahlen
berechnen.
6.5 MMIX Befehle 271

Umwandlung Gleitkommazahl $ Festkommazahl

Befehl Operanden Name/Aktion Definition


$X,$Z Convert fixed to floating $X 0 ( s($Z) )
f64
FLOT 0 ( u(Z) )
$X,Z Conv. fixed to float. imm. $X f64
$X,$Z Conv. uns. fixed to floating $X 0 ( u($Z) )
f64
FLOTU 0 ( u(Z) )
$X,Z Conv. uns. fixed to float. $X f64
imm.
$X 0 ( r ( f ($Z) ) )
s64 64
Convert floating to fixed 63 0 (25 )
FIX $X,$Z f64 ($Z) < 2 ) rA rA|u64
with overflow 0 (25 )
f64 ($Z) > 263 1 ) rA rA|u64
Convert floating to fixed 0 ( r ( f ($Z) ) )
FIXU $X,$Z $X s64 64
without overflow

a) Welche Aktion führt der Operator r () aus?

b) Geben Sie den Befehl an, mit dem Sie Register 0 die Gleitkommazahl 15,0
zuweisen.

c) Geben Sie den Befehl an, mit dem Sie eine Gleitkommazahl in Register 1 in eine
Festkommazahl umwandeln.
272 6 MMIX-Prozessor

Arithmetische Befehle auf Gleitkommazahlen

Befehl Operanden Name/Aktion Definition


FADD $X,$Y,$Z Floating point add $X 0 ( f ($Y) + f ($Z) )
f64 64 64

FSUB $X,$Y,$Z Floating point subtract $X 0 ( f ($Y)


f64 f64 ($Z) )
64

FMUL $X,$Y,$Z Floating point multiplication $X 0 ( f ($Y) · f ($Z) )


f64 64 64

FDIV $X,$Y,$Z Floating point divide $X 0 ( f ($Y)/f ($Z) )


f64 64 64

0 (
p
FSQRT $X,$Z Square root $X f64 f64 ($Z) )

a) Geben Sie MMIX-Befehle an, die ⇡ = 3.1415 in Register a ablegen.

b) Geben Sie MMIX-Befehle an, mit denen Sie x = a2 + 2 · a · b + b 2 mit Gleitkomma-


Operationen berechnen. Nehmen Sie an, dass Register a und b mit Festkomma-
zahlen initialisiert wurden und zunächst in Gleitkommazahlen umgewandelt werden
müssen. Speichern Sie das Ergebnis als Gleitkommazahl in Register x. Benutzen
Sie buf1, buf2, ... als Pufferregister.
6.5 MMIX Befehle 273

T c) Geben Sie MMIX-Befehle an, die e = 2,718281828 in Register b ablegen.


274 6 MMIX-Prozessor

Schiebe-Befehle

Befehl Operanden Name/Aktion Definition


$X 0 ( u($Y ⌧ u($Z)) )
u64
$X,$Y,$Z Shift left; with overflow u($Y) · 2u($Z) 264 )
rA 0 (25 )
rA|u64
SL 0 ( u($Y ⌧ u(Z)) )
$X u64
$X,$Y,Z Shift left immediate; with ovf. u($Y) · 2u(Z) 264 )
rA 0 (25 )
rA|u64
$X,$Y,$Z Shift left uns., no overflow $X 0 ( u($Y ⌧ u($Z)) )
u64
SLU 0 ( u($Y ⌧ u(Z)) )
$X,$Y,Z Shift left uns. immed.; no ovf. $X u64
$X,$Y,$Z Shift right; fill with sign $X $Y s u($Z)
SR s
$X,$Y,Z Shift right imm.; fill with sign $X $Y u(Z)
$X,$Y,$Z Shift right unsigned; fill with 0 $X $Y u u($Z)
SRU u
$X,$Y,Z Shift right uns. imm.; fill w. 0 $X $Y u(Z)
6.5 MMIX Befehle 275

a) Wie unterscheiden sich der SR und der SRU Befehl?

b) In Register fpn ist eine 64 Bit Gleitkommazahl abgelegt.


63 62 52 51 0

Inhalt Register fpn: s e f

Geben Sie die MMIX-Befehle an, mit denen Sie s, e und f aus Register fpn
extrahieren und in Register s, e und f ablegen.
276 6 MMIX-Prozessor

Logische Operationen auf Bit-Ebene

Befehl Operanden Name/Aktion Definition


$X,$Y,$Z Bitwise AND $X $Y & $Z
AND 0 ( u(Z) )
$X,$Y,Z Bitwise AND immediate $X $Y & u64
$X,$Y,$Z Bitwise AND NOT $X $Y & ⇠ $Z
ANDN 0 ( u(Z) )
$X,$Y,Z Bitww AND NOT immed. $X $Y & ⇠ u64
ANDNL $X,YZ Bitw. AND NOT low wyde $X 0 ( u(YZ) )
$X & ⇠ u64
ANDNML $X,YZ Bw. AND NOT med. l. wd. $X 0 ( u(YZ) ) ⌧ 16)
$X & ⇠ ( u64
ANDNMH $X,YZ Bw. AND NOT med. h. wd. $X 0 ( u(YZ) ) ⌧ 32)
$X & ⇠ ( u64
ANDNH $X,YZ Bw. AND NOT high wyde $X 0 ( u(YZ) ) ⌧ 48)
$X & ⇠ ( u64
$X,$Y,$Z Bitwise NOT AND $X ⇠ ($Y & $Z)
NAND 0 ( u(Z) ) )
$X,$Y,Z Bitwise NOT AND immed. $X ⇠ ( $Y & u64
$X,$Y,$Z Bitwise OR $X $Y | $Z
OR 0
$X,$Y,Z Bitwise OR immediate $X $Y | u64 ( u(Z) )
ORL $X,YZ Bitwise OR low wyde $X 0 ( u(YZ) )
$X | u64
ORML $X,YZ Bitw. OR med. low wyde $X 0 ( u(YZ) ) ⌧ 16)
$X | ( u64
ORMH $X,YZ Bitw. OR med. high wyde $X 0 ( u(YZ) ) ⌧ 32)
$X | ( u64
ORH $X,YZ Bitwise OR high wyde $X 0 ( u(YZ) ) ⌧ 48)
$X | ( u64
$X,$Y,$Z Bitwise OR NOT $X $Y | ⇠ $Z
ORN 0 ( u(Z) )
$X,$Y,Z Bitwise OR NOT immediate $X $Y | ⇠ u64
$X,$Y,$Z Bitwise NOT OR $X ⇠ ($Y | $Z)
NOR 0 ( u(Z) ) )
$X,$Y,Z Bitwise NOT OR immediate $X ⇠ ($Y | u64
$X,$Y,$Z Bitwise XOR $X $Y ⌦ $Z
XOR 0
$X,$Y,Z Bitwise XOR immediate $X $Y ⌦ u64 ( u(Z) )
$X,$Y,$Z Bitwise NOT XOR $X ⇠ ($Y ⌦ $Z)
NXOR 0 ( u(Z) ) )
$X,$Y,Z Bitw. NOT XOR immediate $X ⇠ ($Y ⌦ u64
6.5 MMIX Befehle 277

Bits löschen

a) Welche Befehle verwendet man typischerweise um einzelne Bits zu löschen?

b) Geben Sie an, wie Sie mit dem Befehl ANDNML Bit 21 in Register a löschen.

T c) Geben Sie an, wie Sie mit dem Befehl ANDN Bit 21 in Register a löschen.

d) Geben Sie an, wie Sie mit einem NAND und einem AND-Befehl Bit Nr. 21 löschen.

Bits setzen

a) Welche Befehle verwendet man typischerweise um Bits zu setzen?


278 6 MMIX-Prozessor

b) Geben Sie die Befehle, mit denen Sie in Register a Bit 20 mit einem OR-Befehl auf
1 setzen.

T c) Geben Sie an, wie Sie in Register a Bit 20 mit einem ORML-Befehl auf 1 setzen.

XOR

a) Erklären Sie den Effekt einer XOR-Operation.

b) Was wird dem Ziel-Operanden einer XOR-Operation zugewiesen, wenn alle Bits
des einen Quell-Operanden gelöscht (0) sind?

c) Was wird dem Ziel-Operanden einer XOR-Operation zugewiesen, wenn alle Bits
des einen Quell-Operanden gesetzt (1) sind?

d) Geben Sie die Befehle an, mit denen Sie alle Bits in Register a invertieren.
6.5 MMIX Befehle 279

Register-Speicher-Befehle
Der MMIX ist eine Load-Store-Architektur. Speicherzugriffe erfolgen damit nicht implizit,
sondern müssen explizit durch eigene Lade- und Speicherbefehle durchgeführt werden.
Da das Befehlswort des MMIX nur 32 Bit breit ist, kann es keine Speicheradressen
aufnehmen. Beim MMIX wird dieses Problem dadurch gelöst, dass bei Lade- und
Speicherbefehlen das durch das Befehlswort spezifizierte Y-Register eine Basisadresse
enthält und Z bzw. $Z einen Offset festlegt, der auf zur Basisadresse addiert wird. Das
Additionsergebnis ist 64 Bit breit und wird als Adresse verwendet.

a) Erweitern Sie nachfolgende Prozessor-Schaltung um die Fähigkeit, Lade- und


Speicherzugriffe durchzuführen.

Steuerung
4
Add

8
31…24

Allzweck-
64 BZ 64 Registerblock

0
15…0 16 $X $X
1 64 64
Adresse 0
48
X $Y
Befehls- 23…16 8 64
Speicher Y
15…8 8
32 ALU
Daten Z $Z 0
7…0 8 64

1
0 64
56
280 6 MMIX-Prozessor

Daten vom Speicher in ein Register laden

Befehl Operanden Name/Aktion Definition


$X,$Y,$Z Load byte $X 0 (s(M [u($Y) + u($Z)]))
s64 1
LDB 0
$X,$Y,Z Load byte immediate $X s64 (s(M1 [u($Y) + u(Z)]))
$X,$Y,$Z Load byte unsigned $X 0 (u(M [u($Y) + u($Z)]))
u64 1
LDBU 0
$X,$Y,Z Load byte uns. immed. $X u64 (u(M1 [u($Y) + u(Z)]))
$X,$Y,$Z Load wyde $X 0 (s(M [u($Y) + u($Z)]))
s64 2
LDW 0
$X,$Y,Z Load wyde immediate $X s64 (s(M2 [u($Y) + u(Z)]))
$X,$Y,$Z Load wyde unsigned $X 0 (u(M [u($Y) + u($Z)]))
u64 2
LDWU 0
$X,$Y,Z Load wyde uns. immed. $X u64 (u(M2 [u($Y) + u(Z)]))
$X,$Y,$Z Load tetra $X 0 (s(M [u($Y) + u($Z)]))
s64 4
LDT 0
$X,$Y,Z Load tetra immediate $X s64 (s(M4 [u($Y) + u(Z)]))
$X,$Y,$Z Load tetra unsigned $X 0 (u(M [u($Y) + u($Z)]))
u64 4
LDTU 0
$X,$Y,Z Load tetra uns. immed. $X u64 (u(M4 [u($Y) + u(Z)]))
$X,$Y,$Z Load octa $X M8 [u($Y) + u($Z)]
LDO
$X,$Y,Z Load octa immediate $X M8 [u($Y) + u(Z)]
$X,$Y,$Z Load octa unsigned $X M8 [u($Y) + u($Z)]
LDOU
$X,$Y,Z Load octa uns. immed. $X M8 [u($Y) + u(Z)]
6.5 MMIX Befehle 281

T a) Welche Wortgrößen kann der MMIX vom Speicher in Register laden?

T b) Was ist der Unterschied zwischen vorzeichenbehaftetem (signed) und vorzeichen-


losen (unsigned) Laden?

T c) Warum muss man zwischen vorzeichenlosem und vorzeichenbehaftetem Laden


unterscheiden?

T d) Wie unterscheiden sich die Namen der vorzeichenlosen und vorzeichenbehafteten


Ladebefehle?
282 6 MMIX-Prozessor

T e) Wie unterscheiden sich die Opcodes von vorzeichenlosen und vorzeichenbehaf-


teten Ladebefehlen?

f) Nehmen Sie an, dass die vorzeichenbehaftete 8 Bit breite Zahl -64 mit dem
LDB-Befehl in ein Allzweckregister geladen wurde und geben Sie alle Bits des
Allzweckregisters in hexadezimaler Notation aus.

g) Welcher Wert würde im Allzweckregister stehen, wenn die Zahl -64 versehentlich
mit einem LDBU-Befehl statt mit einem LDB-Befehl in das Allzweckregister geladen
worden wäre? Geben Sie den Wert in der Basis 10 an.

T h) Wie können die Ladebefehle 64 Bit breite Speicheradressen adressieren, obwohl


im Befehlswort nur 16 Bit zur Darstellung der Adresse verfügbar sind?
6.5 MMIX Befehle 283

i) Vervollständigen Sie den nachfolgenden MMIX-Code um die Bereitstellung und


Initialisierung eines Basisregisters zur Adressierung von A, B und C.

LOC #2000000000000000

A BYTE 0
B OCTA #FFFF
C OCTA

LOC #100

Main
!"#"$% &'()*+,-.%(*/%012'(*/%
LDO $0,B
! ...
&'(!)*+*,-(#.*-/!01234/*5!67*8434/*9!:;</!=*8>((!7'3,+4-=*7/*<!?'@*--*!A@*<(*BCBD!
!
0x..0 0x..1 0x..2 0x..3 0x..4 0x..5 0x..6 0x..7
TRAP 5ν FCMP ν FUN ν FEQL ν FADD 4ν FIX 4ν FSUB 4ν FIXU 4ν
0x0.. 0x0..
FLOT[I] 4ν FLOTU[I] 4ν SFLOT[I] 4ν SFLOTU[I] 4ν
FMUL 4ν FCMPE 4ν FUNE ν FEQLE 4ν FDIV 40ν FSQRT 40ν FREM 4ν FINT 4ν
0x1.. 0x1..
MUL[I] 10ν MULU[I] 10ν DIV[I] 60ν DIVU[I] 60ν
ADD[I] ν ADDU[I] ν SUB[I] ν SUBU[I] ν
0x2.. 0x2..
2ADDU[I] ν 4ADDU[I] ν 8ADDU[I] ν 16ADDU[I] ν
CMP[I] ν CMPU[I] ν NEG[I] ν NEGU[I] ν
0x3.. 0x3..
SL[I] ν SLU[I] ν SR[I] ν SRU[I]ν
BN[B] ν+π BZ[B] ν+π BP[B] ν+π BOD[B] ν+π
0x4.. 0x4..
BNN[B] ν+π BNZ[B] ν+π BNP[B] ν+π BEV[B] ν+π
PBN[B] 3ν-π PBZ[B] 3ν-π PBP[B] 3ν-π PBOD[B] 3ν-π
0x5.. 0x5..
PBNN[B] 3ν-π PBNZ[B] 3ν-π PBNP[B] 3ν-π PBEV[B] 3ν-π
CSN[I] ν CSZ[I] ν CSP[I] ν CSOD[I] ν
0x6.. 0x6..
CSNN[I] ν CSNZ[I] ν CSNP[I] ν CSEV[I] ν
ZSN[I] ν ZSZ[I] ν ZSP[I] ν ZSOD[I] ν
0x7.. 0x7..
ZSNN[I] ν ZSNZ[I] ν ZSNP[I] ν ZSEV[I] ν
LDB[I] µ+ν LDBU[I] µ+ν LDW[I] µ+ν LDWU[I] µ+ν
0x8.. 0x8..
LDT[I] µ+ν LDTU[I] µ+ν LDO[I] µ+ν LDOU[I] µ+ν
LDSF[I] µ+ν LDHT[I] µ+ν CSWAP[I] 2µ+2ν LDUNC[I] µ+ν
0x9.. 0x9..
LDVTS[I] ν PRELD[I] ν PREGO[I] ν GO[I] 3ν
STB[I] µ+ν STBU[I] µ+ν STW[I] µ+ν STWU[I] µ+ν
0xA.. 0xA..
STT[I] µ+ν STTU[I] µ+ν STO[I] µ+ν STOU[I] µ+ν
STSF[I] µ+ν STHT[I] µ+ν STCO[I] µ+ν STUNC[I] µ+ν
0xB.. 0xB..
SYNCD[I] ν PREST[I] ν SYNCID[I] ν PUSHGO[I] 3ν
OR[I] ν ORN[I] ν NOR[I] ν XOR[I] ν
0xC.. 0xC..
AND[I] ν ANDN[I] ν NAND[I] ν NXOR[I] ν
BDIF[I] ν WDIF[I] ν TDIF[I] ν ODIF[I] ν
0xD.. 0xD..
MUX[I] ν SADD[I] ν MOR[I] ν MXOR[I] ν
SETH ν SETMH ν SETML ν SETL ν INCH ν INCHM ν INCML ν INCL ν
0xE.. 0xE..
ORH ν ORMH ν ORML ν ORL ν ANDNH ν ANDNMH ν ANDNML ν ANDNL ν
JMP[B] ν PUSHJ[B] ν GETA[B] ν PUT[I] ν
0xF.. 0xF..
POP 3ν RESUME 5ν [UN]SAVE 20µ+ν SYNC ν SWYM ν GET ν TRIP 5ν
0x..8 0x..9 0x..A 0x..B 0x..C 0x..D 0x..E 0x..F !
!
!
&'(!*<(B*!E;@@-*!0F!);B#G*<B9!/*(!1234/*(!*7B(2<;3,B!/*<!&422*-C*;-*!0H!@;(!IJ95!;7!/*<!(;3,!/*<!)*#
+*,-(34/*!@*+;7/*BD!
!
!
&'(!C:*;B*!E;@@-*!/*(!1234/*(!*<=;@B!(;3,!:;*!+4-=BK!
!
−! 6L)!0);B!E<D!"9!/*(!C:*;B*7!E;@@-*(!
+! H5!:*77!(;3,!/*<!)*+*,-!;8!4@*<*7!?*;-!/*<!&422*-!"#$"!@*+;7/*B!
+! I5!:*77!(;3,!/*<!)*+*,-!;8!M7B*<*7!?*;-!/*<!&422*-!"#$"!@*+;7/*B!!
284 6 MMIX-Prozessor

Gegeben ist der nachfolgende MMIX-Programmcode:

LOC #2000000000000000
GREG @ @ $254

a IS $1

X BYTE 0
Y TETRA #FFFF
Z OCTA

LOC #100

Main ... ...


... ...

j) In welches Befehlswort würde der MMIX-Assembler LDB a,X übersetzen?

k) In welches Befehlswort würde der MMIX-Assembler LDT a,Y übersetzen?

l) In welches Befehlswort würde der MMIX-Assembler LDO a,Z übersetzen?

T m) Geben Sie alle 64 Bit des Registers $1 nach Ausführung des Befehls LDBU a,Y an.

T n) Geben Sie alle 64 Bit des Registers $1 nach Ausführung des Befehls LDB a,Y an.
6.5 MMIX Befehle 285

o) Tragen Sie in nachfolgende Tabelle den Speicherinhalt ein, der sich nach Aus-
führung der angegebenen MMIX-Befehle im Falle von Big- und Little-Endian-
Adressierung ergeben würde.

LOC Data_Segment
GREG @
BYTE 1
TETRA #23456789
TETRA #ABCDEF01
BYTE #77
WYDE #0123

Niederwert. vier
Adresse Big Endian Little Endian
Adress-Bits

0x2000000000000000 0000

0x2000000000000001 0001

0x2000000000000002 0010

0x2000000000000003 0011

0x2000000000000004 0100

0x2000000000000005 0101

0x2000000000000006 0110

0x2000000000000007 0111

0x2000000000000008 1000

0x2000000000000009 1001

0x200000000000000A 1010

0x200000000000000B 1011

0x200000000000000C 1100

0x200000000000000D 1101

0x200000000000000E 1110

0x200000000000000F 1111
286 6 MMIX-Prozessor

p) Nehmen Sie die gezeigte Speicherbelegung an und geben Sie hexadezimal alle 64
Bit des Registers 0 nach Ausführung der folgenden Befehle an:

LDB $0,$254,0:

LDB $0,$254,4:

LDB $0,$254,9:

LDBU $0,$254,9:

LDT $0,$254,4:

LDT $0,$254,5:

LDT $0,$254,9:

LDTU $0,$254,9:

LDO $0,$254,0:

LDO $0,$254,1:

LDO $0,$254,12:
6.5 MMIX Befehle 287

T q) Tragen Sie in nachfolgende Tabelle den Speicherinhalt ein, der sich nach Aus-
führung der angegebenen MMIX-Befehle im Falle von Big- und Little-Endian-
Adressierung ergeben würde.

LOC Data_Segment
GREG @ @ $254
BYTE 1
WYDE #1234
OCTA #56789ABC

Niederwert. vier
Adresse Big Endian Little Endian
Adress-Bits

0x2000000000000000 0000

0x2000000000000001 0001

0x2000000000000002 0010

0x2000000000000003 0011

0x2000000000000004 0100

0x2000000000000005 0101

0x2000000000000006 0110

0x2000000000000007 0111

0x2000000000000008 1000

0x2000000000000009 1001

0x200000000000000A 1010

0x200000000000000B 1011

0x200000000000000C 1100

0x200000000000000D 1101

0x200000000000000E 1110

0x200000000000000F 1111
288 6 MMIX-Prozessor

T r) Nehmen Sie die gezeigte Speicherbelegung an und geben Sie hexadezimal alle 64
Bit des Registers 0 nach Ausführung der folgenden Befehle an:

LDB $0,$254,3:

LDB $0,$254,14:

LDBU $0,$254,15:

LDT $0,$254,14:

LDTU $0,$254,15:
6.5 MMIX Befehle 289

Daten vom Register in den Speicher schreiben (speichern)

Befehl Operanden Name/Aktion Definition


M1 [u($Y) + u($Z)] ($X)7...0
$X,$Y,$Z Store byte; with overflow 7
s($X) 2 ) rA 0 (26 )
rA | u64
s($X) < 27 ) rA 0 (26 )
rA | u64
STB
M1 [u($Y) + u(Z)] ($X)7...0
$X,$Y,Z Store byte immed.; ovf. 7
s($X) 2 ) rA 0 (26 )
rA | u64
s($X) < 27 ) rA 0 (26 )
rA | u64
$X,$Y,$Z Store byte unsigned M1 [u($Y) + u($Z)] ($X)7...0
STBU
$X,$Y,Z Store byte uns. imm. M1 [u($Y) + u(Z)] ($X)7...0
M2 [u($Y) + u($Z)] ($X)15...0
$X,$Y,$Z Store wyde; with overflow s($X) 215 ) rA 0 (26 )
rA | u64
s($X) < 215 ) rA 0 (26 )
rA | u64
STW
M2 [u($Y) + u(Z)] ($X)15...0
$X,$Y,Z Store wyde immed.; ovf. s($X) 215 ) rA 0 (26 )
rA | u64
s($X) < 215 ) rA 0 (26 )
rA | u64
$X,$Y,$Z Store wyde unsigned M2 [u($Y) + u($Z)] ($X)15...0
STWU
$X,$Y,Z Store wyde uns. imm. M2 [u($Y) + u(Z)] ($X)15...0
M4 [u($Y) + u($Z)] ($X)31...0
$X,$Y,$Z Store tetra; with overflow s($X) 231 ) rA 0 (26 )
rA | u64
s($X) < 231 ) rA 0 (26 )
rA | u64
STT
M4 [u($Y) + u(Z)] ($X)31...0
$X,$Y,Z Store tetra immed.; ovf. s($X) 231 ) rA 0 (26 )
rA | u64
s($X) < 231 ) rA 0 (26 )
rA | u64
$X,$Y,$Z Store byte unsigned M4 [u($Y) + u($Z)] ($X)31...0
STTU
$X,$Y,Z Store byte uns. imm. M4 [u($Y) + u(Z)] ($X)31...0
$X,$Y,$Z Store octa M8 [u($Y) + u($Z)] $X
STO
$X,$Y,Z Store octa immediate M8 [u($Y) + u(Z)] $X
$X,$Y,$Z Store octa unsigned M8 [u($Y) + u($Z)] $X
STOU
$X,$Y,Z Store octa uns. imm. M8 [u($Y) + u(Z)] $X
X,$Y,$Z Store constant octabyte M8 [u($Y) + u($Z)] 0 ( u(X) )
u64
STCO 0 ( u(X) )
X,$Y,Z Store const. octa imm. M8 [u($Y) + u(Z)] u64
$X,$Y,$Z Store high tetra M4 [u($Y) + u($Z)] ($X u 32)
STHT u
$X,$Y,Z Store high tetra imm. M4 [u($Y) + u(Z)] ($X 32)
290 6 MMIX-Prozessor

Befehl Operanden Name/Aktion Definition

$X,$Y,$Z Store short float M4 [u($Y) + u($Z)] f32 1 (f64 ($X))


STSF
$X,$Y,Z Store short float imm. M4 [u($Y) + u(Z)] f32 1 (f64 ($X))
$X,$Y,$Z Store uncached M8 [u($Y) + u($Z)] $X
STUNC
$X,$Y,Z Store uncached imm. M8 [u($Y) + u(Z)] $X

T a) Wie unterscheidet sich die Verwendung von X, Y und Z bei Speicher-Befehle von
derjenigen aller anderen MMIX-Befehle?

T b) Was ist beim MMIX der Unterschied zwischen vorzeichenbehaftetem und vorzei-
chenlosem Speichern?
6.5 MMIX Befehle 291

In folgendem Programmcode wird XXX XXXXXXXX als Platzhalter für einen einzelnen
Befehl verwendet:

LOC Data_Segment
GREG @
A OCTA #FFFF FFFF FFFF FFFF
B TETRA #8765 4321

LOC #100
Main LDTU $0,B
XXX XXXXXXXX
TRAP 0,Halt,0

c) Geben Sie für das oben gezeigte Programm den Inhalt des 64 Bit breiten Wortes
an, welches durch die Marke A adressiert wird, wenn XXX XXXXXXXX durch folgende
Befehle ersetzt wird:

STB $0,A:

STTU $0,A:

STT $0,$254,6:

T d) Geben Sie für das oben gezeigte Programm den Inhalt des 64 Bit breiten Wortes
an, welches durch die Marke A adressiert wird, wenn XXX XXXXXXXX durch folgende
Befehle ersetzt wird:

STW $0,A:

STWU $0,A:

STT $0,A:

STO $0,A:

STB $0,$254,5:

STW $0,$254,1:
ST0 $0,$254,5:
292 6 MMIX-Prozessor

e) Geben Sie hexadezimal das 32 Bit breite Befehlswort des Befehls STBU $0,A an,
wenn dieser in obigem Programmcode den Platzhalter XXX XXXXXXXX ersetzt.

T f) Geben Sie die Befehle an, mit denen Sie


• an Adresse 0x2000 0000 0000 0000 ein 64 Bit breites Datum anlegen,
• dieses Datum über die Marke Data ansprechbar machen und
• das Datenwort mit 0x1234 5678 initialisieren;
• an Adresse 0x100 ein Programm beginnen und
• das an Adresse Data gespeicherte Datenwort in Register 1 einlesen,
• Bits 7 ... 0 des Registers 1 an Adresse Data schreiben,
• Bits 7 ... 0 des Registers 1 an Adresse 0x2000 0000 0000 0002 schreiben,
• Bits 31 ... 0 des Registers 1 an Adresse 0x2000 0000 0000 000A schreiben.
6.5 MMIX Befehle 293

Gegeben ist der folgende Programmcode:

LOC Data_Segement
GREG @
Label OCTA #1234 5678

LOC #100
Main LDO $0,Label
STB $0,Label
LDA $2,Label
STB $0,$2,2
STT $0,$2,10

T g) Zeichnen Sie byteweise den Inhalt des Speichers von Adresse 0x20 ... 00 bis
0x20 ... 00F, der sich nach Ausführung des o.g. Programms ergibt.
294 6 MMIX-Prozessor

Adressen in ein Register laden

Befehl Operanden Name/Aktion Definition


$X,$Y,$Z Get address (absolute) $X 0 (u($Y) + u($Z))
u64
LDA 0 (u($Y) + u(Z))
$X,$Y,Z Get address immed. (absolute) $X u64
GETA $X,YZ Get address (relativ) $X 0 (u(@) + 4 · s(YZ))
u64

!"#"$% &'()*+,-.%(*/%012'(*/%
!
&'(!)*+*,-(#.*-/!01234/*5!67*8434/*9!:;</!=*8>((!7'3,+4-=*7/*<!?'@*--*!A@*<(*BCBD!
!
0x..0 0x..1 0x..2 0x..3 0x..4 0x..5 0x..6 0x..7
TRAP 5ν FCMP ν FUN ν FEQL ν FADD 4ν FIX 4ν FSUB 4ν FIXU 4ν
0x0.. 0x0..
FLOT[I] 4ν FLOTU[I] 4ν SFLOT[I] 4ν SFLOTU[I] 4ν
FMUL 4ν FCMPE 4ν FUNE ν FEQLE 4ν FDIV 40ν FSQRT 40ν FREM 4ν FINT 4ν
0x1.. 0x1..
MUL[I] 10ν MULU[I] 10ν DIV[I] 60ν DIVU[I] 60ν
ADD[I] ν ADDU[I] ν SUB[I] ν SUBU[I] ν
0x2.. 0x2..
2ADDU[I] ν 4ADDU[I] ν 8ADDU[I] ν 16ADDU[I] ν
CMP[I] ν CMPU[I] ν NEG[I] ν NEGU[I] ν
0x3.. 0x3..
SL[I] ν SLU[I] ν SR[I] ν SRU[I]ν
BN[B] ν+π BZ[B] ν+π BP[B] ν+π BOD[B] ν+π
0x4.. 0x4..
BNN[B] ν+π BNZ[B] ν+π BNP[B] ν+π BEV[B] ν+π
PBN[B] 3ν-π PBZ[B] 3ν-π PBP[B] 3ν-π PBOD[B] 3ν-π
0x5.. 0x5..
PBNN[B] 3ν-π PBNZ[B] 3ν-π PBNP[B] 3ν-π PBEV[B] 3ν-π
CSN[I] ν CSZ[I] ν CSP[I] ν CSOD[I] ν
0x6.. 0x6..
CSNN[I] ν CSNZ[I] ν CSNP[I] ν CSEV[I] ν
ZSN[I] ν ZSZ[I] ν ZSP[I] ν ZSOD[I] ν
0x7.. 0x7..
ZSNN[I] ν ZSNZ[I] ν ZSNP[I] ν ZSEV[I] ν
LDB[I] µ+ν LDBU[I] µ+ν LDW[I] µ+ν LDWU[I] µ+ν
0x8.. 0x8..
LDT[I] µ+ν LDTU[I] µ+ν LDO[I] µ+ν LDOU[I] µ+ν
LDSF[I] µ+ν LDHT[I] µ+ν CSWAP[I] 2µ+2ν LDUNC[I] µ+ν
0x9.. 0x9..
LDVTS[I] ν PRELD[I] ν PREGO[I] ν GO[I] 3ν
STB[I] µ+ν STBU[I] µ+ν STW[I] µ+ν STWU[I] µ+ν
0xA.. 0xA..
STT[I] µ+ν STTU[I] µ+ν STO[I] µ+ν STOU[I] µ+ν
STSF[I] µ+ν STHT[I] µ+ν STCO[I] µ+ν STUNC[I] µ+ν
0xB.. 0xB..
SYNCD[I] ν PREST[I] ν SYNCID[I] ν PUSHGO[I] 3ν
OR[I] ν ORN[I] ν NOR[I] ν XOR[I] ν
0xC.. 0xC..
AND[I] ν ANDN[I] ν NAND[I] ν NXOR[I] ν
BDIF[I] ν WDIF[I] ν TDIF[I] ν ODIF[I] ν
0xD.. 0xD..
MUX[I] ν SADD[I] ν MOR[I] ν MXOR[I] ν
SETH ν SETMH ν SETML ν SETL ν INCH ν INCHM ν INCML ν INCL ν
0xE.. 0xE..
ORH ν ORMH ν ORML ν ORL ν ANDNH ν ANDNMH ν ANDNML ν ANDNL ν
JMP[B] ν PUSHJ[B] ν GETA[B] ν PUT[I] ν
0xF.. 0xF..
POP 3ν RESUME 5ν [UN]SAVE 20µ+ν SYNC ν SWYM ν GET ν TRIP 5ν
0x..8 0x..9 0x..A 0x..B 0x..C 0x..D 0x..E 0x..F !
!
!
&'(!*<(B*!E;@@-*!0F!);B#G*<B9!/*(!1234/*(!*7B(2<;3,B!/*<!&422*-C*;-*!0H!@;(!IJ95!;7!/*<!(;3,!/*<!)*#
+*,-(34/*!@*+;7/*BD!
!
a)! Was ist der Unterschied zwischen dem Befehl LDA und den Ladebefehlen LDB, ... ?
&'(!C:*;B*!E;@@-*!/*(!1234/*(!*<=;@B!(;3,!:;*!+4-=BK!
!
−! 6L)!0);B!E<D!"9!/*(!C:*;B*7!E;@@-*(!
+! H5!:*77!(;3,!/*<!)*+*,-!;8!4@*<*7!?*;-!/*<!&422*-!"#$"!@*+;7/*B!
+! I5!:*77!(;3,!/*<!)*+*,-!;8!M7B*<*7!?*;-!/*<!&422*-!"#$"!@*+;7/*B!!
!
−! );B(!$5!I!M7/!H!/*(!C:*;B*7!E;@@-*(!*7B(2<*3,*7!/*<! %&'$("!0H!@;(!%95!;7!/*8!(;3,!/*<!)*+*,-(#
34/*!@*+;7/*B!
!
[I]!@*/*MB*BK!N88*/;'B*#O'<;'7B*!/*(!)*+*,-(!
−! ;88*/;'B*!⇔!&;<*PB42*<'7/!
−! ADD $1,$2,$3K!7;3,B!;88*/;'B*5!/'!/*<!"D!12*<'7/!*;7!Q*=;(B*<!;(B!M7/!P*;7*!R',-!
6.5 MMIX Befehle 295

Nehmen Sie die folgenden Befehle an:

LOC Data_Segment
GREG @ $254 @
A BYTE #12

LOC #100
Main LDA $0,A
TRAP 0,Halt,0

b) Der Assembler übersetzt den Befehl LDA $0,A in 0x2300FE00. Warum?

Gegeben sind die folgenden Befehle:

LOC Data_Segment
GREG @
A BYTE #12

LOC #100
Main LDA $0,A
GETA $0,Main
TRAP 0,Halt,0

c) In welches 32 Bit breite Befehlswort wird der Befehl GETA $0,Main übersetzt?
296 6 MMIX-Prozessor

Zugriff auf Spezialregister

Befehl Operanden Name/Aktion Definition


GET $X,Z Get value of special purpose register $X S(Z)
X,$Z Put value to special purpose register S(X) $Z
PUT 0
X,Z Put immed. value to spec. purp. reg. S(X) u64 (u(Z))

T a) Tragen Sie in nachfolgender Befehlssequenz Befehle zur Berechnung der Fest-


kommadivisioni dividend/divisor ein und speichern Sie das Ergebnis an der
Marke Quotient und den Divisionsrest an der Marke Remainder ab.

LOC Data_Segment
GREG @
Dividend OCTA 7
Divisor OCTA 3
Quotient OCTA
Remainder OCTA

dividend IS $0
divisor IS $1
quotient IS $2
remainder IS $3

LOC #100
Main LDO dividend,Dividend
LDO divisor,Divisor

TRAP 0,Halt,0
6.5 MMIX Befehle 297

Gegeben ist das Format des Spezialregisters rA.

Interrupt Enable (Freischalten) Interrupt Event (Auftreten)

0 0 R1 R0 D V W I O U Z X D V W I O U Z X

Gleitkommazahl ungenau
nicht verwendet
(z.B. 1.0 / 3.0)
Gleitkomma-Division durch 0
Gleitkomma-Unterlauf
Gleitkomma-Überlauf
Unerlaubte Gleitkomma-
operation, z.B. sqrt(-1.0)
Überlauf bei Wandlung Gleit-
komma- in Festkommazahl
Festkomma-Überlauf
Festkomma-Division durch 0
00: Nächster Wert (standard)
01: Abrunden (Richtung 0)
Gleitkomma-Rundungsmodus
10: Aufrunden (Richtung +∞)
11: Abrunden (Richtung -∞)

b) Geben Sie den MMIX-Code an, mit dem Sie den Gleitkomma-Rundungsmodus
auf ‘‘aufrunden’’ setzen.

c) Ändern Sie das Interrupt-Enable Bit ‘‘integer overflow’’ (0 ) 1, 1 ) 0) .


298 6 MMIX-Prozessor

Verzweigungsbefehle

Unbedingte Verzweigung

Befehl Operanden Name/Aktion Definition


JMP XYZ Jump @ 0 ( u(@) + 4 · s(XYZ) )
u64

Bedingte Verzweigungen

Befehl Operanden Name/Aktion Definition


BZ $X,YZ Branch if zero s($X) = 0 ) @ 0 ( u(@) + 4 · s(YZ) )
u64
PBZ $X,YZ Probable br. if zero s($X) = 0 ) @ 0 ( u(@) + 4 · s(YZ) )
u64
BNZ $X,YZ Branch if nonzero s($X) 6= 0 ) @ 0 ( u(@) + 4 · s(YZ) )
u64
PBNZ $X,YZ Prob. br. if nonzero s($X) 6= 0 ) @ 0 ( u(@) + 4 · s(YZ) )
u64
BN $X,YZ Branch if negative s($X) < 0 ) @ 0 ( u(@) + 4 · s(YZ) )
u64
PBN $X,YZ Prob. br. if negative s($X) < 0 ) @ 0 ( u(@) + 4 · s(YZ) )
u64
BNN $X,YZ Branch if nonneg. s($X) 0)@ 0 ( u(@) + 4 · s(YZ) )
u64
PBNN $X,YZ Prob. br. if nonneg. s($X) 0)@ 0 ( u(@) + 4 · s(YZ) )
u64
BP $X,YZ Branch if positive s($X) > 0 ) @ 0 ( u(@) + 4 · s(YZ) )
u64
PBP $X,YZ Prob. br. if positive s($X) > 0 ) @ 0 ( u(@) + 4 · s(YZ) )
u64
BNP $X,YZ Branch if nonpositive s($X)  0 ) @ 0 ( u(@) + 4 · s(YZ) )
u64
PBNP $X,YZ Prob. br. if nonpos. s($X)  0 ) @ 0 ( u(@) + 4 · s(YZ) )
u64
BEV $X,YZ Branch if even s($X) % 2 = 0 ) @ 0 ( u(@)+4·s(YZ) )
u64
PBEV $X,YZ Prob. branch if even s($X) % 2 = 0 ) @ 0 ( u(@)+4·s(YZ) )
u64
BOD $X,YZ Branch if odd s($X) % 2 = 1 ) @ 0 ( u(@)+4·s(YZ) )
u64
PBOD $X,YZ Prob. branch if odd s($X) % 2 = 1 ) @ 0 ( u(@)+4·s(YZ) )
u64
6.5 MMIX Befehle 299

Betrachten Sie die folgenden Befehle:

LOC Data_Segment
GREG @
A OCTA 1000

a IS $1
b IS $2

LOC #100
Main LDB a,A
Start SUB a,a,1
OR a,a,0
BZ a,End
JMP Start
End TRAP 0,0,0

a) Bestimmen Sie das 32 Bit breite Befehlswort des Befehls ‘‘JMP Start’’.

b) Bestimmen Sie das 32 Bit breite Befehlswort des Befehls ‘‘BZ a,End’’.
300 6 MMIX-Prozessor

c) Benutzen Sie MMIX Verzweigungs-Befehle um folgenden C-Code zu implemen-


tieren:

C-Code: if(a == 0)
{
a = 1;
}

MMIX-Code:

d) Benutzen Sie MMIX Verzweigungs-Befehle um folgenden C-Code zu implemen-


tieren:

C-code: int a;

...

if(a <= 0)
{
a = 1;
}
else
{
a = 2;
}

MMIX-Code:
6.5 MMIX Befehle 301

T e) Geben Sie den MMIX-Code an, der nachfolgenden C-Code implementiert:

C-Code: int a, b;

...

if(a > 0 && b < 0)


{
a = 1;
}
else if(a > 0 || b == 0)
{
a = 2;
}
else
{
a = 3;
}

MMIX-Code:
302 6 MMIX-Prozessor

Befehle für Funktionsaufrufe

Befehl Operanden Name/Aktion Definition


$X 0 ( u(@) + 4) );
u64
$X,$Y,$Z Go to location 0 ( u($Y) + u($Z) )
@ u64
GO 0 ( u(@) + 4) );
$X u64
$X,$Y,Z Go to location immediate 0 ( u($Y) + u(Z) )
@ u64

T a) Was ist der Haupt-Unterschied zwischen dem JMP-Befehl und dem GO-Befehl?

T b) Wo speichern GO-Befehle die Rücksprungadresse ab?

T c) Was ist die ‘‘Rücksprungadresse’’?

T d) Wenn GO Absolute Adressierung verwendet: Wie wird die Abolute Adresse (64 Bit)
im 32 Bit breiten Befehlswort abgelegt?

e) Geben Sie den Befehl an, mit dem Sie die Funktion fkt aufrufen und die Rück-
sprungadresse in Register 0 ablegen.
6.5 MMIX Befehle 303

Namensräume - der PREFIX-Befehl


Der PREFIX-Befehl ist ein Assembler-Befehl. Er wird verwendet, um in einem Pro-
gramm vorkommenden Namen vom Assembler-Präprozessor durch Voranstellen einer
Zeichenkette automatisiert ändern zu lassen. Dazu wird der PREFIX-Befehl mit der
voranzustellenden Zeichenkette als Operand aufgerufen.

PREFIX Zeichenkette

Ab dieser Anweisung setzt der Assembler-Präprozessor vor jeden Namen die angege-
bene Zeichenkette. Hat beispielsweise die Zeichenkette den Wert ‘‘abc:’’, dann wird ein
Name ‘‘def’’ in ‘‘abc:def’’ geändert.
Fügt man vor jede Funktion einen PREFIX-Befehl mit dem Funktionsnamen als Zeichen-
kette ein, erzeugt man automatisch für jede Funktion einen eigenen Namensraum. Eine
Variable i in der Funktion fkt bekommt dann den (globalen) Namen fkti und eine Variable
i in der Funktion fkt2 den Namen fkt2i. Auf diese Weise kann der Assembler beide
Variable als unterschiedliche Variable erkennen und es kommt zu keinem Konflikt, wenn
der Assembler beispielsweise i sowohl durch $1 ersetzen soll (für die Funktion fkt1) als
auch durch $2 (für die Funktion fkt2).
Um den Funktionsnamen besser vom Variablennamen abgrenzen zu können, bietet es
sich an, an die Prefix-Zeichenkette noch ein markantes Zeichen anzuhängen, beispiels-
weise einen Bindestrich oder einen Doppelpunkt.
Um einen Namensraum zu beenden, d.h. um den Assembler-Präprozessor anzuweisen,
vorkommenden Namen die Zeichenkette nicht mehr voranzustellen, wird der PREFIX-
Befehl mit einem Doppelpunkt als Operand aufgerufen.

PREFIX :

Will man innerhalb eines Namensraums verhindern, dass der Assembler-Präprozessor


einen Namen ändert, schreibt man vor den betreffenden Namen einen Doppelpunkt,
z.B. ‘‘:def’’ statt ‘‘def’’. Auf diese Weise kann man auf globale Namen wie z.B. den
Stackpointer SP zugreifen.

a) Geben Sie die Anweisung an, mit denen Sie den Namensraum ‘‘Main:’’ eröffnen
und in diesem Namensraum die globale Marke ‘‘Main’’ definieren.
304 6 MMIX-Prozessor

b) Wie kann man einen Namensraum beenden, d.h. wie kann man den Assembler
anweisen, Marken/Namen nicht mehr umzuwandeln?

c) Wie kann man – innerhalb eines Namensraums – verhindern, dass der Assembler
einer bestimmten Marke bzw. einem bestimmten Namen die im PREFIX-Befehl
angegebene Zeichenkette voranstellt?

T d) Wozu dient der PREFIX-Befehl?

T e) Welche Auswirkung hat der Befehl PREFIX mein_prefix auf darauf folgende MMIX-
Anweisungen?
6.5 MMIX Befehle 305

T f) Geben Sie die Anweisungen an, mit denen Sie den Namensraum ‘‘Fkt:’’ eröffnen
und die globale Marke ‘‘Fkt’’ anlegen.

Funktionsaufrufe
Mit Funktionen werden logisch zusammengehörige Befehle zur Bereitstellung einer
Gesamt-Funktionalität zusammengefasst und durch Funktionsaufrufe von beliebigen
Stellen im Programm abrufbar. Durch diese Struktur gebende Maßnahme werden
Programme übersichtlicher und kürzer:
• Übersichtlicher, da der Programm-Code die Zerlegung eines großen Problems
in kleinere Probleme durch Funktionsaufrufe widerspiegelt, und
• kürzer, da eine Funktionalität (viele Befehle) nur einmal aus Befehlen zusam-
mengesetzt werden muss und durch Sprünge in die Funktion (wenige Befehle)
beliebig oft verwendet werden kann.

Beispiel: Email-Adresse von Personen aus einer csv-Datei (csv = comma separated
values = Werte durch Komma getrennt) extrahieren und jeder Person ein Email schreiben:
• Aufruf einer Funktion, welche den Namen der csv-Datei als Parameter überge-
ben bekommt und den Inhalt der Datei in den String s einliest.
• Aufruf einer Funktion, welche den String s sowie das Zeichen \n als Parameter
übergeben bekommt, den String an den Zeichen \n in Teil-Stings s1 , s2 , ... auf-
trennt und als Ergebnis ein Array von Zeigern auf die Teil-Strings zurückliefert.
• Für jeden Teilstring si : Aufruf einer Funktion, welche den String si und das
Komma-Zeichen als Parameter übergeben bekommt, den String an den Kom-
mas in Teilstrings sij auftrennt und als Ergebnis ein Array von Zeigern auf die
Teil-Strings zurückliefert.
• Auswahl des Teil-Strings sij , in dem die EMail-Adresse gespeichert ist.
• Für jede Email-Adresse sij : Aufruf einer Funktion, die als Parameter die Email-
Adresse und den Email-Text bekommt und den Email-Text an die angegebene
Email-Adresse verschickt.
306 6 MMIX-Prozessor

Wert-Übergabe und Referenz-Übergabe


Es gibt viele Möglichkeiten, Funktionen Parameter zu übergeben. Prinzipiell unterschei-
det man zwischen der Übergabe von Werten und der Übergabe von Referenzen.
• Bei der Wert-Übergabe (engl. call by value) wird der Funktion direkt der zu
verarbeitende Wert übergeben, z.B. eine Festkommazahl.
• Bei der Referenz-Übergabe (engl. call by reference) wird der Funktion die
Adresse des zu verarbeitenden Werts übergeben, z.B. die Adresse, an der eine
Festkommazahl im Speicher steht.

In beiden Fällen wird bei der Parameterübergabe eine lokale Kopie erstellt.
• Bei der Wert-Übergabe wird eine Kopie des Werts erstellt. Ändert die Funktion
die ihr übergebene Variable, so hat das keinen Einfluss auf den Wert der
Original-Variable.
• Bei der Referenz-Übergabe wird eine Adresse übergeben und somit eine Kopie
der Adresse erstellt. Auch wenn es sich nur um eine Kopie der Adresse handelt –
die kopierte Adresse zeigt auf dieselbe Speicherstelle wie die originale Adresse.
Damit kann die Funktion Änderungen an den Werten durchführen, die an der
übergebenen Speicheradresse stehen – und der Funktionsaufrufer kann auf
diese Änderungen zugreifen.

Wert-Übergabe Referenz-Übergabe Speicher

Funktionsaufrufer: Wert Adresse


wird kopiert

wird kopiert
wird kopiert

zeigt auf
wird kopiert
ruft auf

f
zeigt au

Funktion: Wert Adresse

Diese Variable steht hier im Speicher


6.5 MMIX Befehle 307

Aufrufkonventionen
Eine Aufrufkonvention (engl. calling convention) legt fest, wie einer Funktion Parameter
übergeben werden und wie der Rückgabewert zurückgegeben wird. Damit spezifiziert
eine Aufrufkonvention u.a. Antworten auf Fragen wie:
• Werden alle Parameter auf dem Stack übergeben oder werden die ersten n
Parameter in Registern übergeben und die restlichen auf dem Stack?
• Welche Register werden zur Parameterübergabe verwendet?
• In welcher Reihenfolge werden die Parameter auf dem Stack bzw. in den
Registern abgelegt?
• Werden Gleitkommazahlen in anderen Registern übergeben als Festkomma-
zahlen? In welchen?
• Wer bereinigt den Stack: Der Funktionsaufrufer oder die Funktion?
• Wie wird der Rückgabewert zurückgegeben: Auf dem Stack oder in einem
Register? In welchem?

Da unterschiedliche Prozessorarchitekturen unterschiedliche Register haben (Anzahl,


Funktion, ...) und sich auch bezüglich der Verwendung des Stacks unterscheiden
können, sind Aufrufkonventionen architekturabhängig. Funktionen können auf einer Pro-
zessorarchitektur in vielfältiger Art und Weise aufgerufen werden. Somit gibt es für jede
Prozessorarchitektur in der Regel auch mehrere mögliche Aufrufkonventionen. Bei der
Programmierung in Hochsprache ist das Einhalten der gewünschten Aufrufkonvention
Aufgabe des Compilers.

Parameterübergabe auf dem Stack beim MMIX


Der Stack ist ein Bereich im Speicher des Prozessors, in dem Funktionsparameter,
Rücksprungadressen und lokale Variable nacheinander aufgerufender Funktionen auf-
einandergestapelt (engl. stack = Stapel) werden. Beim MMIX kann der Stack am Ende
des Datensegments aufgebaut werden, beginnend an Adresse 0x3FF...F8 in Richtung
niedrigerer Adressen wachsend. Der Stack wird immer über den sog. Stackpointer
angesprochen. Der Stackpointer wird realisiert durch ein Register, in dem die Adresse
der auf dem Stack ganz oben liegenden Daten abgelegt ist. Viele Prozessoren ver-
wenden ein spezielles Stackpointer-Register. Beim MMIX verwenden wir ein globales
Allzweckregister als Stackpointer.
308 6 MMIX-Prozessor

Beim MMIX kann die Verwendung eines Stacks wie folgt umgesetzt werden:

• Beim Start eines Programmes wird mit der Anweisung

SP GREG #4000000000000000

ein globales Register angelegt, mit 0x4000000000000000 initialisiert und über


die Marke SP angsprechbar gemacht. Über diese Marke wird der Stackpointer
dann zukünftig angesprochen.

8 Byte

0x3FFFFFFFFFFFFFF8
SP 0x4000000000000000

Der Stackpointer zeigt jetzt auf den Beginn des Pool-Segments.

• Beim Aufruf einer Funktion mit n Parametern wird vom aktuellen Wert des
Stackpointers n · 8 subtrahiert. Der Stackpointer zeigt dann auf eine niedrigere
Adresse, d.h. er wandert ‘‘nach oben’’. Im Falle n = 3 wird 3 · 8 subtrahiert.

SUB :SP,:SP,3*8

Der Stackpointer zeigt dann auf Adresse 0x3FFFFFFFFFFFFFE8.

SP 0x3FFFFFFFFFFFFFE8
0x3FFFFFFFFFFFFFF0
0x3FFFFFFFFFFFFFF8
0x4000000000000000
6.5 MMIX Befehle 309

• Anschließend werden die Parameter mittels Stackpointer auf den Stack kopiert.

STO a,:SP,0
STO b,:SP,1*8
STO c,:SP,2*8

SP 0x3FFFFFFFFFFFFFE8 1. Parameter für Fkt


0x3FFFFFFFFFFFFFF0 2. Parameter für Fkt
0x3FFFFFFFFFFFFFF8 3. Parameter für Fkt
0x4000000000000000

• Nachdem die Parameter auf den Stack kopiert sind, wird mit dem GO-Befehl
in die Funktion gesprungen. Dazu wird die Einsprungs-Marke der Funktion
angegeben, z.B. ‘‘Fkt’’. Als Register zur Speicherung der Rücksprungadresse
sollte ein Register angegeben werden, das keine Daten enthält, die noch
benötigt werden. Es bietet sich an, die Rücksprungadresse immer in demselben
Register abzulegen, beispielsweise in Register 0.

GO $0,:Fkt
310 6 MMIX-Prozessor

• Als Aufrufkonvention legen wir fest, dass die aufgerufene Funktion sicherstellen
muss, dass sie keine vom Funktionsaufrufer in Registern gespeicherten Daten
überschreibt. Da die Funktion die vom Funktionsaufrufer verwendeten Register
nicht zwingend kennt (z.B. Bibliotheksfunktion), sichert sie alle von ihr selbst
verwendeten Register auf den Stack. Die Funktion kann die Register dann
verwenden, muss aber unmittelbar vor dem Rücksprung zum Funktionsaufrufer
die alten Werte wieder vom Stack in die entsprechenden Register zurück
kopieren. Verwendet die Funktion beispielsweise die Register 1 und 2, so
sichert sie diese auf den Stack.

SUB :SP,:SP,2*8
STO $1,:SP,0
STO $2,:SP,1*8

SP 0x3FFFFFFFFFFFFFD8 Sicherung $1 Fkt


0x3FFFFFFFFFFFFFE0 Sicherung $2 Fkt
0x3FFFFFFFFFFFFFE8 1. Parameter für Fkt
0x3FFFFFFFFFFFFFF0 2. Parameter für Fkt
0x3FFFFFFFFFFFFFF8 3. Parameter für Fkt
0x4000000000000000

• Sind die Register auf den Stack gesichert, lädt die Funktion die für sie bestimm-
ten Parameter vom Stack und verarbeitet sie.

LDO $1,:SP,2*8 Parameter 1


LDO $2,:SP,3*8 Parameter 2
... ...
LDO $2,:SP,4*8 Parameter 3
... ...
6.5 MMIX Befehle 311

• Ruft die Funktion Fkt selbst eine andere Funktion Fkt2 auf, so sichert sie
zunächst die Rücksprungadresse auf den Stack, kopiert die der Funktion Fkt2
zu übergebenden Parameter auf den Stack und ruft dann Funktion Fkt2 auf.

SUB :SP,:SP,2*8
STO $0,:SP,1*8 Rücksprungadresse
STO $1,:SP,0 Parameter für Fkt2
GO $0,:Fkt2

SP 0x3FFFFFFFFFFFFFC8 Parameter für Fkt2


0x3FFFFFFFFFFFFFD0 Sicherung $0 Fkt
0x3FFFFFFFFFFFFFD8 Sicherung $1 Fkt
0x3FFFFFFFFFFFFFE0 Sicherung $2 Fkt
0x3FFFFFFFFFFFFFE8 1. Parameter für Fkt
0x3FFFFFFFFFFFFFF0 2. Parameter für Fkt
0x3FFFFFFFFFFFFFF8 3. Parameter für Fkt
0x4000000000000000
312 6 MMIX-Prozessor

• Die Funktion Fkt2 sichert nun ihrerseits die von ihr verwendeten Register auf
den Stack, lädt den ihr übergebenen Parameter vom Stack und führt damit
Berechnungen durch.

SUB :SP,:SP,2*8
STO $1,:SP,0 Sicherung $1
STO $2,:SP,1*8 Sicherung $2
LDO $2,SP,2*8 Parameter laden
... ...

SP 0x3FFFFFFFFFFFFFB8 Sicherung $1 Fkt 2


0x3FFFFFFFFFFFFFC0 Sicherung $2 Fkt 2
0x3FFFFFFFFFFFFFC8 Parameter für Fkt2
0x3FFFFFFFFFFFFFD0 Sicherung $0 Fkt
0x3FFFFFFFFFFFFFD8 Sicherung $1 Fkt
0x3FFFFFFFFFFFFFE0 Sicherung $2 Fkt
0x3FFFFFFFFFFFFFE8 1. Parameter für Fkt
0x3FFFFFFFFFFFFFF0 2. Parameter für Fkt
0x3FFFFFFFFFFFFFF8 3. Parameter für Fkt
0x4000000000000000
6.5 MMIX Befehle 313

• Hat Fkt2 ihre Berechnungen abgeschlossen, legt Sie den Rückgabewert an


der Stelle auf dem Stack ab, an der ihr der Parameter übergeben wurde. Sind
mehrere Parameter übergeben worden, wird der Rückgabewert an die Stelle
desjenigen Parameters mit der höchsten Adresse geschrieben. Wurde kein
Parameter übergeben, so muss vor der Sicherung der Register auf dem Stack
Platz freigehalten werden.

STO $2,:SP,2*8 Rückgabewert

SP 0x3FFFFFFFFFFFFFB8 Sicherung $1 Fkt 2


0x3FFFFFFFFFFFFFC0 Sicherung $2 Fkt 2
0x3FFFFFFFFFFFFFC8 Rückgabewert von Fkt2
0x3FFFFFFFFFFFFFD0 Sicherung $0 Fkt
0x3FFFFFFFFFFFFFD8 Sicherung $1 Fkt
0x3FFFFFFFFFFFFFE0 Sicherung $2 Fkt
0x3FFFFFFFFFFFFFE8 1. Parameter für Fkt
0x3FFFFFFFFFFFFFF0 2. Parameter für Fkt
0x3FFFFFFFFFFFFFF8 3. Parameter für Fkt
0x4000000000000000
314 6 MMIX-Prozessor

• Nach dem Ablegen des Rückgabewerts auf dem Stack muss die Funktion Fkt2
die auf den Stack gesicherten Register wieder herstellen. Anschließend muss
der Stackpointer so angepasst werden, dass er auf den Rückgabewert zeigt, so
dass er vom Funktionsaufrufer ausgelesen werden kann, ohne die Anzahl der
von Fkt2 auf den Stack gesicherten Register zu kennen. Anschließend springt
die Funktion Fkt2 zurück zum Funktionsaufrufer. Als Rücksprungadresse dient
Register 0 mit dem Offset 0. Für den GO-Befehl muss wieder ein Register
zur Speicherung der Rücksprungadresse angegeben werden, auch wenn nicht
an das Ende der Funktion Fkt2 zurückgesprungen wird. Da der in Register 0
enthaltene Wert nach dem Rücksprung nicht mehr benötigt wird, kann Register
0 auch wieder zur Abspeicherung dieser Rücksprungadresse verwendet werden
(1. Parameter des GO-Befehls).

LDO $1,:SP,0
LDO $2,:SP,1*8
ADD :SP,:SP,2*8
GO $0,$0,0

0x3FFFFFFFFFFFFFB8 Sicherung $1 Fkt 2


0x3FFFFFFFFFFFFFC0 Sicherung $2 Fkt 2
SP 0x3FFFFFFFFFFFFFC8 Rückgabewert von Fkt2
0x3FFFFFFFFFFFFFD0 Sicherung $0 Fkt
0x3FFFFFFFFFFFFFD8 Sicherung $1 Fkt
0x3FFFFFFFFFFFFFE0 Sicherung $2 Fkt
0x3FFFFFFFFFFFFFE8 1. Parameter für Fkt
0x3FFFFFFFFFFFFFF0 2. Parameter für Fkt
0x3FFFFFFFFFFFFFF8 3. Parameter für Fkt
0x4000000000000000

Auf die Werte oberhalb des Stackpointers wird nicht mehr zugegriffen. Sie
werden aber nicht explizit gelöscht/überschrieben.
6.5 MMIX Befehle 315

• Die Funktion Fkt kann nun das ihr von Fkt2 übergebene Ergebnis vom Stack
auslesen und mit ihren Berechnungen fortfahren. Nach dem Auslesen des
Rückgabewerts von Fkt2 addiert die Funktion Fkt noch den Wert 8 zum
Stackpointer. Damit zeigt der Stackpointer auf dieselbe Stelle wie vor dem
Aufruf von Fkt2. Der Aufruf von Fkt2 ist damit offiziell abgeschlossen.

LDO $1,:SP,0
ADD :SP,:SP,8

0x3FFFFFFFFFFFFFB8 Sicherung $1 Fkt 2


0x3FFFFFFFFFFFFFC0 Sicherung $2 Fkt 2
0x3FFFFFFFFFFFFFC8 Rückgabewert von Fkt2
SP 0x3FFFFFFFFFFFFFD0 Sicherung $0 Fkt
0x3FFFFFFFFFFFFFD8 Sicherung $1 Fkt
0x3FFFFFFFFFFFFFE0 Sicherung $2 Fkt
0x3FFFFFFFFFFFFFE8 1. Parameter für Fkt
0x3FFFFFFFFFFFFFF0 2. Parameter für Fkt
0x3FFFFFFFFFFFFFF8 3. Parameter für Fkt
0x4000000000000000
316 6 MMIX-Prozessor

• Die Funktion Fkt kann nun das Ergebnis von Fkt2 für ihre weiteren Berech-
nungen verwenden. Hat die Funktion Fkt ihre Berechnungen abgeschlossen,
kopiert sie ihren Rückgabewert auf den Stack, stellt die von ihr gesicherten Re-
gister wieder her, passt den Stackpointer so an, dass er auf den Rückgabewert
zeigt und kehrt schließlich zum Funktionsaufrufer zurück.

... ...
STO $1,:SP,5*8
LDO $0,:SP,0
LDO $1,:SP,1*8
LDO $2,:SP,2*8
ADD :SP,:SP,5*8
GO $0,:$0,0

0x3FFFFFFFFFFFFFB8 Sicherung $1 Fkt 2


0x3FFFFFFFFFFFFFC0 Sicherung $2 Fkt 2
0x3FFFFFFFFFFFFFC8 Rückgabewert von Fkt2
0x3FFFFFFFFFFFFFD0 Sicherung $0 Fkt
0x3FFFFFFFFFFFFFD8 Sicherung $1 Fkt
0x3FFFFFFFFFFFFFE0 Sicherung $2 Fkt
0x3FFFFFFFFFFFFFE8 1. Parameter für Fkt
0x3FFFFFFFFFFFFFF0 2. Parameter für Fkt
SP 0x3FFFFFFFFFFFFFF8 Rückgabewert von Fkt
0x4000000000000000
6.5 MMIX Befehle 317

• Der Funktionsaufrufer kann nun das Ergebnis der Funktion Fkt über den
Stackpointer auslesen und danach den Stackpointer wieder anpassen, so dass
er auf die selbe Stelle zeigt wie vor dem Aufruf der Funktion Fkt.

LDO $1,:SP,0
ADD :SP,:SP,8

0x3FFFFFFFFFFFFFB8 Sicherung $1 Fkt 2


0x3FFFFFFFFFFFFFC0 Sicherung $2 Fkt 2
0x3FFFFFFFFFFFFFC8 Rückgabewert von Fkt2
0x3FFFFFFFFFFFFFD0 Sicherung $0 Fkt
0x3FFFFFFFFFFFFFD8 Sicherung $1 Fkt
0x3FFFFFFFFFFFFFE0 Sicherung $2 Fkt
0x3FFFFFFFFFFFFFE8 1. Parameter für Fkt
0x3FFFFFFFFFFFFFF0 2. Parameter für Fkt
0x3FFFFFFFFFFFFFF8 Rückgabewert von Fkt
SP 0x4000000000000000
318 6 MMIX-Prozessor

Aufgaben

a) Geben Sie den Befehl an, mit dem Sie den Stackpointer als globales Register an-
legen, mit 0x4000000000000000 initialisieren und über die Marke SP ansprechbar
machen.

b) Geben Sie die Befehle an, mit denen der Funktionsaufrufer aus dem Namensraum
Main: heraus Register 3 und 4 als Parameter auf dem Stack ablegt und danach
die global definierte Funktion Str aufruft. Die Rücksprungadresse soll in Register
0 abgelegt werden.

c) Geben Sie die Befehle an, mit denen Sie den Namensraum Str: anlegen, dann die
Funktion Str beginnen und die Register 0, 1 und 2 auf den Stack sichern.
6.5 MMIX Befehle 319

d) Tragen Sie in nachfolgende Abbildung die auf dem Stack gespeicherten Werte ein
und geben Sie die Position des Stackpointers an.

0x3FFFFFFFFFFFFFD0

0x3FFFFFFFFFFFFFD8

0x3FFFFFFFFFFFFFE0

0x3FFFFFFFFFFFFFE8

0x3FFFFFFFFFFFFFF0

0x3FFFFFFFFFFFFFF8

0x4000000000000000

e) Geben Sie die Befehle an, mit denen Sie die übergebenen Parameter in die Register
1 und 2 einlesen.

f) Geben Sie die Befehle an, mit denen Sie den Wert aus Register 1 als Ergebnis
auf dem Stack ablegen, die auf den Stack gesicherten Register wieder herstel-
len, den Stackpointer anpassen und zurück zum Funktionsaufrufer springen. Die
Rücksprungadresse steht in Register 0 und soll auch wieder dort abgelegt werden.
320 6 MMIX-Prozessor

g) Geben Sie die Befehle an, mit denen Sie den Namensraum Str: wieder beenden.

h) Geben Sie die Befehle an, mit denen der Funktionaufrufer das Ergebnis vom Stack
in das Register 1 einliest und den Stackpointer anpasst.
6.5 MMIX Befehle 321

T i) Was ist der Stack?

T j) Wo beginnt der Stack und in welche Richtung wächst er?

T k) Was ist der Stack-Pointer?

T l) Wie werden Daten adressiert, die auf dem Stack liegen?


322 6 MMIX-Prozessor

T m) Welche Operationen muss man ausführen um die Werte zweier Register (acht Byte
breite Datenworte) auf dem Stack abzulegen?

T n) Wie wird der Stack bei Funktionsaufrufen verwendet?


6.5 MMIX Befehle 323

T o) Geben Sie den Befehl an mit dem Sie für den Stack-Pointer ein globales Register
reservieren und dieses mit 0x4000 0000 0000 0000 initialisieren.

T p) Warum initialisieren wir den Stack-Pointer mit 0x4000 0000 0000 0000, d.h. mit
dem Beginn des Poolsegments, und nicht mit dem Ende des Datensegments?

T q) Geben Sie die MMIX-Befehle an, mit denen Sie Register $1 und $2 auf den Stack
schreiben und dann die Funktion fkt aufrufen. Nehmen Sie an, dass Ihr Code im
Namensraum Main: steht und fkt im Namensraum Fkt: unter dem Namen :fkt
angelegt wurde. Sichern Sie die Rücksprungadresse in Register 0.
324 6 MMIX-Prozessor

Nehmen Sie an, dass Sie eine Funktion im Namensraum Fkt: implementieren.

T r) Geben Sie die MMIX-Befehle an, mit denen Sie die Register 0, 1, 2 und 3 auf den
Stack sichern und anschließend zwei acht Byte breite Parameter vom Stack in die
Register 1 und 2 einlesen.

T s) Zeichnen Sie, wie der Stack nach diesen Operationen aussieht.


6.5 MMIX Befehle 325

T t) Im Hauptprogramm wurden die Parameter in die Register 1 und 2 geschrieben.


Im Unterprogramm wurden Register 1 und 2 dann auf den Stack gesichert und
dann dieselben Werte wieder vom Stack in Register 1 und 2 geladen, obwohl
sich die Werte von Register 1 und 2 in der Zwischenzeit nicht geändert hatten.
Warum haben wir und diesen Schritt nicht gespart sondern dieselben Werte, die
in Registern 1 und 2 waren, nochmal reingeschrieben?

T u) Warum speichert man die Rücksprungadresse auf dem Stack?

T v) Was würde passieren, wenn der Stack so groß wird, dass er mit den Daten
zusammenstößt, die am Beginn des Datensegments liegen?
326 6 MMIX-Prozessor

T w) Geben Sie die MMIX-Befehle an, mit denen Sie den Inhalt von Register 3 als
Ergebnis auf dem Stack ablegen, dann die Register 0, 1, 2 und 3 wiederherstellen
und anschließend zurück zum Funktionsaufrufer springen.

T x) Nehmen Sie an, Sie sind wieder im Hauptprogramm. Geben Sie die Befehle an mit
denen Sie das Ergebnis der Funktion vom Stack in das Register 1 einlesen.

T y) Warum muss der Stack-Pointer angepasst werden nachdem das Ergebnis vom
Stack geladen wurde?
6.5 MMIX Befehle 327

Beispielprogramm: Quadratische Gleichung

In dieser Übung schreiben Sie ein MMIX Programm zur p


Lösung der Quadratischen
2 b± b 2 4·a·c
Gleichung a · x + b · x + c = 0 mit der Formel x1,2 = 2·a zu lösen. Die Variable
a, b und c sind als Festkommazahlen gegeben; das Ergebnis soll als Gleitkommazahl
angegeben werden.

a) Geben Sie den MMIX Befehl an, mit dem Sie den Stack-Pointer anlegen und über
die Marke SP ansprechbar machen.

Zunächst soll das Hauptprogramm implementiert werden.

b) Geben Sie den MMIX-Befehl an, mit dem Sie den Namensraum Main: eröffnen.

c) Reservieren Sie an Adresse 0x2000 0000 0000 0000 die 64 Bit breiten Speicherworte
A, B, C, X1 und X2 und initialisieren Sie A mit 2, B mit 4 und C mit 8.

d) Geben Sie den Befehl an, mit dem Sie Register 1 durch buf ansprechbar machen.
328 6 MMIX-Prozessor

e) Beginnen Sie das Hauptprogramm, legen Sie A, B und C auf dem Stack ab und
rufen Sie dann die global definierte Funktion QuadGleich auf. Speichern Sie dabei
die Rücksprungadresse in Register $0.

f) Geben Sie den MMIX Code an, mit dem Sie die Ergebnisse x1 und x2 der Funktion
vom Stack auslesen und im Arbeitsspeicher an den Marken X1 bzw. X2 ablegen.

g) Geben Sie die Anweisungen an, mit denen Sie das Programm und den Namens-
raum Main: beenden.
6.5 MMIX Befehle 329

Im Folgenden soll die Funktion QuadGleich implementiert werden, von der folgender
Programm-Code bereits gegeben ist:

PREFIX QuadGleich:

a IS $1
b IS $2
c IS $3
x1 IS $4
x2 IS $5
disk IS $6
buf1 IS $7
buf2 IS $8

Der Funktion QuadGleich werden die Parameter a, b und c wie folgt auf dem Stack
übergeben:
SP ! a
b
c

h) Geben Sie an der Marke :QuadGleich die Befehle an, mit denen Sie die verwende-
ten Register auf den Stack sichern und die Parameter a, b und c dann vom Stack
in die Register a, b und c einlesen.

:QuadGleich
330 6 MMIX-Prozessor

i) Geben Sie den MMIX-Befehlscode an, der


• im Fall a = 0 das Ergebnis x = c/b berechnet, dieses dann sowohl in
x1 und x2 speichert und dann an die Marke Speichern springt, und
• im Fall a 6= 0 an die Marke Anicht0 springt.

j) Geben Sie an Marke Anicht0 den MMIX Code an, mit dem Sie die Diskriminante
b 2 4 · a · c mittels Festkomma-Arithmetik berechnen und das Ergebnis in Register
disk ablegen.

Anicht0
6.5 MMIX Befehle 331

k) Geben Sie den MMIX Code an mit dem Sie


• im Fall disk < 0 an die Marke Dneg verzweigen,
• im Fall disk = 0 an die Marke D0 verzweigen und
• im Fall disk > 0 an die Marke Dpos verzweigen.

l) Geben Sie an Marke Dneg den MMIX Code an, mit dem Sie x1 und x2 auf NaN
setzen; verzweigen Sie dann an die Marke Speichern.

Dneg

m) Geben Sie an Marke D0 den MMIX Code an, mit dem Sie b/2a berechnen und
das Ergebnis sowohl in x1 als auch in x2 ablegen. Verzweigen Sie danach an die
Marke Speichern.

D0
332 6 MMIX-Prozessor

n) Geben Siepan Marke Dpos die MMIX Befehle an, mit denen Sie x1 und x2 gemäß
b 2 4·a·c
x1,2 = b± 2·a berechnen und das Ergebnis in x1 und x2 ablegen. Springen
Sie dann an die Marke Speichern. Beachten Sie, dass die Diskriminante bereits
berechnet wurde und als Festkommazahl in Register disk abgelegt ist.

Dpos

o) Geben Sie an Marke Speichern die MMIX Befehle an, mit denen Sie x1 und x2 auf
den Stack sichern, zum Funktionsaufrufer zurückspringen und den Namensraum
QuadGleich: beenden.

Speichern
333

7 Pipelining
Nachfolgende Abbildung zeigt die bekannte Datenpfad-Schaltung.

Steuerung
4
Add

8
0
1
31…24

Allzweck-
64 BZ 64 Registerblock clk
Zugriffs-
Art

0 Daten-
15…0 16 $X $X Eingang
1 64 64
Adresse 0 Daten-
48
X
Speicher
Befehls- 23…16 $Y
8 64 Daten-
Speicher Y Ausgang
15…8 8
32 ALU Adresse
Daten Z $Z 0
7…0 8 64

1
0 64
56

Der Befehlsablauf ist wie folgt: Durch Takten des Befehlszählers BZ wird die Befehl-
sadresse um die Befehlswortbreite in Byte erhöht, so dass das als nächstes auszu-
führende Befehlswort am Befehlsspeicher ausgegeben wird. Durch das Befehlswort
bestimmt sich, welche Allzweckregister adressiert werden, welche Operation an der
ALU eingestellt wird, welche Zugriffsart am Datenspeicher ausgewählt wird, wie die
Multiplexer angesteuert werden und wann/ob Allzweck-Registerblock oder Speicher
getaktet werden.
Wenn der durch den Befehlszähler adressierte Befehl abgearbeitet ist, wird der Befehls-
zähler erneut getaktet und der nächste Befehl wird ausgeführt.
Durch diese Vorgehensweise wird der gesamte Datenpfad vom gerade ausgeführten
Befehl immer komplett belegt. Obwohl also z.B. bei einem Additions-Befehl die Addition
bereits durchgeführt wurde und nur noch das Ergebnis in den Registerblock geschrieben
werden muss, ist die ALU blockiert und kann von keinem anderen Befehl verwendet
werden. Damit werden die im Datenpfad verbauten Komponenten nicht optimal genutzt.
Um die Komponenten des Datenpfads besser auszunutzen, können die einzelnen
Komponenten (oder auch Teile davon) durch Register separiert und die Komponenten
dann unabhängig von einander verwendet werden. Dieses Vorgehen wird Pipelining
genannt, die Trennungs-Register dementsprechend Pipelining-Register.
334 7 Pipelining

7.1 Pipelining-Datenpfad
Nachfolgende Abbildung zeigt einen Pipelining-Datenpfad.

Sp.-Puls
Reg.-Schreiben
Ergebnisauswahl ES
Sp.-Schreiben
4 Reg.-Puls Zugriffs-Art 2 SP ES
64 Clk1
Steuerung ALU-Funktion 8
Add 24..31
64 Direktoperand AF SP ES
Clk2 2
X-Auswahl

64 Clk3
Clk4
32
BZ Registerblock
64 Schreiben Zugriffs- Schrei-
8 Art ben
64 Schreib- 64 64
Daten $X Lese- $X $X Schreib-
Adresse 16..23 Daten $X Daten
32 0 64 64
BR Schreiben/ Lese- $Y
Befehls- Lesen $X Daten $Y 64
1 64 Erg Lese- Lese
Speicher Lese- ALU Adr. 0
Daten $Z
$Z 0 64
ALU Daten Dat.
8..15
Daten Lesen $Y Daten- Erg
1
0..7 Dir ALU
32 Lesen $Z 1 Speicher
Op.
8 64
64
0
16..23 56 X X X
8 8 8

64

Befehlsspeicher, Allzweck-Registerblock (Operanden bereitstellen), ALU, Datenspeicher


und der Übergang ALU/Datenspeicher ! Allzweck-Registerblock (Ergebnis/Lesewort in
Register ablegen) sind durch sog. Pipelining-Register voneinander getrennt. Gleichzeitig
teilen die Pipelining-Register den Datenpfad in Stufen, auch Phasen genannt, ein. Bei
dem gezeigten Datenpfad sind es fünf Stufen/Phasen:
• Befehl holen (BH; Befehls-Speicher),
• Befehl decodieren und Operanden bereitstellen (BD; Allzweck-Registerblock
und Steuerung),
• Befehl ausführen (AF; ALU),
• Speicherzugriff (SP; Datenspeicher) und
• Ergebnis schreiben (ES; Allzweck-Registerblock).

Durch dieses Vorgehen können die von den einzelnen Komponenten bereitgestellten
Datenworte sofort in den Pipelining-Registern zwischengepuffert werden. Damit werden
die Komponenten frei und können sofort von nachfolgenden Befehlen genutzt werden.
Dadruch verringert sich zwar nicht die Auführungszeit der einzelnen Befehle. Der Befehls-
7.1 Pipelining-Datenpfad 335

Durchsatz des Datenpfads (Anzahl der Befehle, die pro Zeiteinheit abgearbeitet werden
können) kann bei einer n stufigen Pipeline jedoch bis um den Faktor n gesteigert werden.

Ein Pipeline-Füll-Diagramm zeigt für verschiedene Zeitpunkte ti an, welche Befehle sich
gerade in welcher Pipeline-Stufe befinden. Gegeben ist folgende MMIX-Befehlssequenz:

ADD $1,$2,3
SUB $2,$2,$3
MUL $3,$3,5
DIV $4,$4,4
LDW $5,$254,0
LDO $6,$254,8
OR $7,$7,#AC
AND $8,$8,#DC
NEG $9,0,5

a) Tragen Sie in das nachfolgende Pipeline-Füll-Diagramm die Zuordnung Befehl $


Pipelinestufe für die angegebenen Zeitpunkte 1, 2, ... , 9 ein.

1 2 3 4 5 6 7 8 9
t [clk]

BH BD AF SP ES BH BD AF SP

BH BD AF SP ES BH BD AF

BH BD AF SP ES BH BD

BH BD AF SP ES BH

BH BD AF SP ES
336 7 Pipelining

Sobald die Pipeline gefüllt ist, wird mit jedem Takt ein Befehl abgearbeitet.

b) Ab welchem Zeitpunkt ist die Pipeline gefüllt?

c) Bis zu welchem Faktor kann der gezeigten Pipelining-Datenpfad Programme


schneller ausführen als der zuvor kennengelernte Datenpfad, der kein Pipelining
unterstützt?

d) Welche Anforderung muss man an die einzelnen Stufen eines Pipelining-


Datenpfads stellen, damit man die Komponenten des Datenpfads bestmöglichst
ausnutzt und den maximalen Performance-Gewinn erzielen kann?

Nehmen Sie folgende Registerbelegung an: $1 = 0x11, $2 = 0x22, $3 = 0x33, $4 = 0x44.

e) Tragen Sie in die angegebenen Pipeline-Register diejenigen Werte ein, die sich bei
Ausführung der unter den Pipeline-Registern abgebildeten Befehle ergeben.

Reg. Schr.:
Befehlssequenz:
Erg. Ausw.:
SUB $3,$3,1
ADD $1,$2,3
SR $4,$2,2 Sp. Schr.: Reg. Schr.:
STT $1,$254,0
Zugr.-Art: Erg. Ausw.:

ALU: 0x21 Sp. Schr.: Reg. Schr.:


Dir. Op.: Zugr.-Art: Erg. Ausw.:

$X: $X: Lese-Daten:


$Y:

STT $1,$254,0 $Z: Erg. ALU: Erg. ALU:


Dir. Op.:

X: X: X:
STT $1,$254,0 SR $4,$2,2 ADD $1,$2,3 SUB $3,$3,1
7.2 Pipelining-Konflikte 337

7.2 Pipelining-Konflikte
Durch die gleichzeitige Ausführung mehrerer Befehle können verschiedene Konflikte
(engl. hazards) auftreten.

Datenkonflikte
Benötigt ein Befehl ein Datenwort, das von einem vorausgehenden Befehl berechnet,
jedoch noch nicht in den Allzweck-Registerblock abgespeichert wurde, spricht man von
einem Datenkonflikt. Beispiel:

ADD $1,$2,$3
MUL $3,$2,$1

Der Additionsbefehl liest in der BD-Phase Register 2 und 3 aus dem Registerblock aus
und berechnet in der AF-Phase das Ergebnis. Gleichzeitig adressiert der Multiplikati-
onsbefehl in der BD-Phase den Registerblock und liest die Register 2 und 1 aus. Der in
Register 1 gespeicherte Wert ist jedoch veraltet – er enthält noch nicht das Ergebnis des
Additionsbefehls. Dieses wäre erst nach Abschluss der ES-Phase des Additions-Befehls
verfügbar.

Erkennen von Datenkonflikten


Gegeben ist der nachfolgend abgebildete Ausschnitt aus einer MMIX-Codesequenz.

LDT $3,$2,32 Zeile 1


SUB $2,$4,8 Zeile 2
OR $1,$2,$3 Zeile 3
STO $2,$254,$1 Zeile 4

a) Geben Sie alle auftretenden Datenkonflikte an. Nehmen Sie dabei an, dass der
Registerblock ein Datenwort, das gerade in ihn hineingeschrieben wird, nicht
gleichzeitig am Ausgang ausgeben kann.
338 7 Pipelining

Gegeben ist der folgende Ausschnitt aus einer MMIX Codesequenz:

SUB $2,$5,10 Zeile 1


LDO $5,$0,2*8 Zeile 2
OR $1,$2,$3 Zeile 3
SRU $1,$5,$1 Zeile 4

b) Geben Sie alle auftretenden Datenkonflikte an. Nehmen Sie dabei an, dass der
Registerblock ein Datenwort, das gerade in ihn hineingeschrieben wird, nicht
gleichzeitig am Ausgang ausgegeben werden kann.

Gegeben ist der folgende Ausschnitt aus einer MMIX Codesequenz:

ADD $1,$3,1 Zeile 1


OR $2,$1,$3 Zeile 2
SRU $1,$2,$1 Zeile 3
STO $1,$254,0 Zeile 4

T c) Geben Sie alle auftretenden Datenkonflikte an. Nehmen Sie dabei an, dass der
Registerblock ein Datenwort, das gerade in ihn hineingeschrieben wird, nicht
gleichzeitig am Ausgang ausgegeben werden kann.
7.2 Pipelining-Konflikte 339

Auflösen von Datenkonflikten durch Einfügen von NOP-Befehlen


Um in obigem Beispiel sicherzustellen, dass der Multiplikations-Befehl den vom
Additions-Befehl geänderten Wert verwendet, können zwischen Additions-Befehl und
dem Multiplikations-Befehl sog. NOP-Befehle eingefügt werden. NOP steht für ‘‘no
operation’’ und meint Befehle, die ‘‘nichts tun’’, d.h. keine Zustandsänderung (Änderung
von Werten in Registern, Speicher) bewirken. Beim MMIX wird der NOP-Befehl SWYM
(‘‘sympathize with your machinery’’) genannt.

a) Geben Sie an, mit Sie mit SWYM-Befehlen zwischen ADD $1,$2,$3 und MUL $3,$2,$1
dafür sorgen, dass der Multiplikations-Befehl den vom Additions-Befehl geänder-
ten Wert aus dem Registerblock ausliest.

Sp.-Puls
Reg.-Schreiben
Ergebnisauswahl ES
Sp.-Schreiben
4 Reg.-Puls Zugriffs-Art 2 SP ES
64 Clk1
Steuerung ALU-Funktion 8
Add 24..31
64 Direktoperand AF SP ES
Clk2 2
X-Auswahl

64 Clk3
Clk4
32
BZ Registerblock
64 Schreiben Zugriffs- Schrei-
8 Art ben
64 Schreib- 64 64
Daten $X Lese- $X $X Schreib-
Adresse 16..23 Daten $X Daten
32 0 64 64
BR Schreiben/ Lese- $Y
Befehls- Lesen $X Daten $Y 64
1 64 Erg Lese- Lese
Speicher Lese- ALU Adr. 0
Daten $Z
$Z 0 64
ALU Daten Dat.
8..15
Daten Lesen $Y Daten- Erg
1
0..7 Dir ALU
32 Lesen $Z 1 Speicher
Op.
8 64
64
0
16..23 56 X X X
8 8 8

64
340 7 Pipelining

T b) Geben Sie an, wie Sie mit SWYM-Befehlen zwischen LDB $1,$254,0 und MUL
$3,$2,$1 dafür sorgen, dass der Multiplikations-Befehl den vom Lade-Befehl
geänderten Wert aus dem Registerblock ausliest.

Auflösen von Datenkonflikten mittels Befehlsumstellung


Datenkonflikte mit NOP-Befehle aufzulösen funktioniert zwar, verringert jedoch bei
Datenabhängigkeiten den durch Pipelining effektiv erreichbaren Befehls-Durchsatz.
Unter Umständen können jedoch zwischen der Änderung eines Werts und der nächsten
Verwendung des geänderten Werts Befehle eingefügt werden, die ohnehin ausgeführt
werden müssen und unabhängig vom geänderten Wert sind.

Betrachten Sie nachfolgende Befehlssequenz.

ADD $1,$2,$3
SWYM
SWYM
SWYM
MUL $3,$2,$1
SUB $4,$5,1
SRU $5,$5,2
SL $6,$3,2

a) Geben Sie an, wie Sie den Code durch Befehlsumstellung schneller ausführbar
machen können.
7.2 Pipelining-Konflikte 341

Gegeben ist die nachfolgend angegebene Befehlssequenz.

ADD $1,$2,$3
SWYM
SWYM
SWYM
MUL $2,$5,$1
SUB $4,$3,1
SRU $5,$6,2

T b) Geben Sie an, wie Sie den angegebenen Code durch Befehlsumstellung schnel-
ler ausführbar machen können als durch ausschließliches Einfügen von NOP-
Befehlen.
342 7 Pipelining

Auflösen von Datenkonflikten durch ‘‘Stalls’’


Werden Datenkonflikte nicht bereits durch Befehlsumstellung und Einfügen von NOP-
Befehlen vermieden, können Prozessoren Datenkonflikte auch selbst erkennen und
entsprechende Pipeline-Stufen so lange anhalten, bis der Konflikt aufgelöst ist. Um bei
angehaltenen Pipeline-Stufen denselben Befehl nicht mehrfach auszuführen, werden
sog. ‘‘Stalls’’ eingefügt. Dazu werden die Steuer-Einträge der ‘‘angehaltenen’’ Stufen so
modifiziert, dass keine Schreibzugriffe auf Register oder Speicher erfolgen. Durch das
teilweise Anhalten von Pipelinestufen verringert sich der Befehlsdurchsatz.

Sp.-Puls
Auflösen von Datenkonflikten durch Forwarding-Pfade
Reg.-Schreiben
Forwarding-Pfade sind zusätzliche Leitungen, über welche noch nicht in den Regis-
Ergebnisauswahl ES
terblock Sp.-Schreiben
geschriebene Ergebnisse an andere Pipelining-Stufen weitergeleitet werden
Reg.-Puls können. 2 SP ES
Zugriffs-Art
Steuerung ALU-Funktion 8
24..31 a) Erweitern Sie nachfolgenden Datenpfad-Ausschnitt um Forwarding-Pfade, mit de-
Direktoperand AF SP ES
nen Sie sowohl Ergebnisse der ALU als auch aus dem Datenspeicher ausgelesene
Clk2
Werte am Z-Eingang der ALU bereitstellen können. 2
X-Auswahl

Clk3
Clk4
32
Registerblock
Schreiben Zugriffs- Schrei-
8 Art ben
Schreib- 64 64
Daten $X Lese- $X $X Schreib-
16..23 Daten $X Daten
32 0 64 64
Schreiben/ Lese- $Y
Lesen $X Daten $Y 64
1 64 Erg Lese- Lese
Lese- ALU Adr. 0
Daten $Z
$Z 0 64
ALU Daten Dat.
8..15
Lesen $Y Daten- Erg
1
0..7 Dir ALU
Lesen $Z 1 Speicher
Op.
8 64
64
0
16..23 56 X X X
8 8 8

64
7.2 Pipelining-Konflikte 343

Betrachten Sie folgende Befehle:

ADD $1,$2,$3
SUB $3,$2,$1

b) Kann der SUB-Befehl durch Forwarding-Pfade so auf den vom ADD-Befehl be-
rechneten Wert zugreifen, dass in der AF-Phase der SUB-Befehl direkt nach dem
ADD-Befehl bearbeitet werden kann?

Betrachten Sie folgende Befehle:

LDO $1,$254,0
SUB $3,$2,$1

c) Was ist hier anders?

d) Was für Konsequenzen ergeben sich daraus?


344 7 Pipelining

Nehmen Sie folgende Register-Belegung an: $1 = 0x01, $2 = 0x22, $3 = 0x03, $254


= 0x2000000000000000. Nehmen Sie desweiteren an, dass im Speicher an der OCTA-
Adresse 0x2000000000000000 der Wert 0x0123456789ABCDEF steht.

e) Tragen Sie in nachfolgende Abbildung den Inhalt der Pipeline-Register für die unter
den Pipeline-Registern angegebenen Befehle ein. Geben Sie für alle irrelevanten
Einträge ‘‘X’’ an. Nehmen Sie an, dass zwischen dem Ausgang des Datenspeichers
und dem Eingang des nach der BD-Phase angeordneten Pipeline-Registers ein
Forwarding-Pfad geschaltet ist.

Reg. Schr.:
Erg. Ausw.:

Sp. Schr.: Reg. Schr.:


Zugr.-Art: Erg. Ausw.:

ALU: 0x21 Sp. Schr.: Reg. Schr.:


Dir. Op.: Zugr.-Art: Erg. Ausw.:

$X: $X: Lese-Daten:


$Y:

STT $1,$254,0 $Z: Erg. ALU: Erg. ALU:


Dir. Op.:

X: X: X:
STT $1,$254,0 ADD $1,$3,2 Stall LDT $3,$254,$1
7.2 Pipelining-Konflikte 345

Nehmen Sie die folgenden Registerwerte an: $1 = 0x11, $2 = 0x22, $3 = 0x33, $254 =
0x2000000000000000

T f) Tragen Sie in nachfolgende Abbildung den Inhalt der Pipeline-Register für die unter
den Pipeline-Registern angegebenen Befehle ein. Geben Sie für alle irrelevanten
Einträge ‘‘X’’ an. Nehmen Sie an, dass von der ALU-benötigte und noch nicht in
den Registerblock geschriebene Ergebnisse über Forwarding-Pfade an das der
BD-Phase folgende Pipeline-Register geleitet werden.

Reg. Schr.: 1
Erg. Ausw.: 1

Sp. Schr.: 0 Reg. Schr.: 1

Zugr.-Art: X Erg. Ausw.: 1

ALU: 0x05 Sp. Schr.: 0 Reg. Schr.: 1


Dir. Op.: Zugr.-Art: X Erg. Ausw.: 1

$X: $X: Lese-Daten:


$Y:

ADD $3,$254,0 $Z: Erg. ALU: Erg. ALU:


Dir. Op.:

X: X: X:
ADD $3,$254,0 SUB $1,$3,$2 OR $2,$2,36 AND $3,$2,28
346 7 Pipelining

Strukturkonflikte
Benötigen zwei Befehle gleichzeitig eine Hardware-Resource, spricht man von einem
Strukturkonflikt. Ein Beispiel für einen Strukturkonflikt beim MMIX ist die gleichzeitige
Verwendung des Adresseingangs X des Allzweck-Registerblocks:
• Ein Register-Register-Befehl befindet sich in der ES-Phase und will sein Er-
gebnis in das Register X schreiben. Dazu muss er den Registerblock über den
Adress-Eingang X adressieren.
• Gleichzeitig befindet sich ein Speicherbefehl in der BD-Phase und will ebenfalls
den Adress-Eingang X verwenden, um Register X aus dem Registerblock
auszulesen und dann im Speicher abzulegen.

Verwendet der Speicherbefehl ein X-Register, dessen Wert über einen Forwarding-Pfad
erreicht werden kann, kann der Strukturkonflikt dadurch aufgelöst werden.
Anderenfalls muss der Speicherbefehl zurückgestellt werden, d.h. es muss ein Stall
eingefügt werden.

Gegeben ist der nachfolgend abgebildete Ausschnitt aus einer MMIX-Codesequenz.

LDT $3,$2,32 Zeile 1


SUB $2,$4,8 Zeile 2
OR $1,$2,$3 Zeile 3
STO $2,$254,$1 Zeile 4

a) Wo tritt ein Strukturkonflikt auf? Wie kann dieser behoben werden?


7.2 Pipelining-Konflikte 347

Gegeben ist die folgende Codesequenz:

LDT $3,$2,32 Zeile 1


SUB $2,$4,8 Zeile 2
OR $1,$2,$3 Zeile 3
STO $2,$254,$1 Zeile 4

b) Tragen Sie in nachfolgendes Pipeline-Füll-Diagramm die ausgeführten Befehle


sowie die benötigten Forwarding-Pfade ein, wenn sie den Strukturkonflikt mit
einem Forwarding-Pfad auflösen.

BH BD AF SP ES

BH BD AF SP ES

BH BD AF SP ES

BH BD AF SP ES

T c) Tragen Sie in nachfolgende Tabelle ein, wie Sie den Strukturkonflikt mit einem Stall
auflösen können.

1 2 3 4 5 6 7 8 9 10

LDT

SUB

OR

STO
348 7 Pipelining

Steuerungskonflikte
Befinden Sie im Programmcode bedingte Sprünge, dann entscheidet sich erst in der
AF-Phase des Sprungbefehls, ob zum Sprungziel verzweigt wird, oder ob der auf
den aktuellen Befehl folgende Befehl als nächstes ausgeführt werden soll. Es ist also
möglich, dass in der BH-Phase Befehle in den Datenpfad geladen werden, die gar
nicht ausgeführt werden sollen. In diesem Fall müssen die fälschlicherweise geladenen
Befehle verworfen werden und im Anschluss die richtigen Befehle geladen werden. Man
nennt dieses Vorgehen ‘‘Pipeline-Flush’’, da die Pipeline geleert wird.
Um bei bedingten Verzweigungen in der Befehlsphase mit hoher Wahrscheinlichkeit den
richtigen Befehl zu laden, unterstützt der MMIX für jeden Sprungbefehl zwei Varianten:
• Bei ‘‘normalen’’ Sprungbefehle (BZ, BN, BNN, ...) wird angenommen, dass
nicht verzweigt wird. Dementsprechend werden nach dem Sprungbefehl die
unmittelbar folgenden Befehle in die Pipeline geladen.
• Bei den P-Versionen der Sprungbefehle (PBZ, PBN, PBNN, ...) wird ange-
nommen, dass verzweigt wird (probable branch). Dementsprechend werden
nach dem Sprungbefehl die am Sprungziel stehenden Befehle in die Pipeline
geladen.
7.2 Pipelining-Konflikte 349

Betrachten Sie nachfolgendes Programm.

LOC #100
GREG @
Main LDA base_a,A
LDA base_b,B
SET i,1000
SET s,0
BZ i,Ende
LDB a,base_a,i
LDB b,base_b,i
MUL a,a,b
ADD s,s,a
SUB i,i,1
JMP Start
Ende STO s,S
TRAP 0,Halt,0

a) Geben Sie die Adressen an, die der MMIX-Prozessor in der BH-Phase adressiert,
wenn sich der BZ-Befehl in der BD- und in der AF-Phase befindet.

b) Geben Sie die Adressen an, die der MMIX-Prozessor in der BH-Phase adressiert,
wenn der BZ-Befehl durch einen PBZ-Befehl ersetzt würde und sich dieser in der
BD- bzw. in der AF-Phase befindet.
350 7 Pipelining

T c) Geben Sie MMIX-Befehle an, die den nachfolgenden C-Code implementieren.


Verwenden Sie zur Realisierung der do-while-Schleife diejenige Variante des
Sprungbefehls, der mit höherer Wahrscheinlichkeit die tatsächlich auszuführenden
Befehle in die Pipeline lädt.

C-Code: int a, b;

a = 100;
b = 0;

do
{
b += (a * b);
a--;
} while( a >= 0);

MMIX-Code:

T d) Um wieviele Takte würde der Code langsamer ausgeführt werden, wenn die falsche
Variante des Sprungbefehls verwendet werden würde?
8.1 Motivation 351

8 Cache

8.1 Motivation
Pipelining-Register werden gleichzeitig getaktet. Dadurch wird die Performance eines
Pipelining-Systems von der langsamsten Stufe bestimmt.
• BD- und ES-Phase können schnell abgearbeitet werden, da hier keine aufwen-
digen Operationen notwendig sind.
• Die Dauer der AF-Phase hängt vom jeweiligen Befehl ab: Manche Befehle
können sehr schnell ausgeführt werden (z.B. ODER-Befehle), andere Befehle
(z.B. Multiplikation, Division, Wurzel) dauern wesentlich länger.
• Die BH- und SP-Phasen dauern sehr lang, da sich der Speicher ausserhalb des
Prozessors befindet.
• Längere Verbindungsleitungen führen zu längeren Signallaufzeiten und
höheren parasitären Kapazitäten.
• Speicherbausteine werden über ein eigenes Protokoll angesprochen,
das von einer Hardware-Schaltung implementiert wird. Dadurch ent-
stehen zusätzliche Gatterlaufzeiten.
• Aus Platz- und Kostengründen (Ausbeute) ist der Arbeitsspeicher
in der Regel aus langsamen DRAM-Bausteinen (1 Transistor + 1
Kondensator pro Speicherstelle) aufgebaut und nicht aus schnellen
SRAM-Bausteinen (6 Transistoren pro Speicherstelle).
• Durch die große Menge an Arbeitsspeicher (z.B. 16 Milliarden Byte
RAM $ 256 Register zu je 64 Bit) dauert die Adressierung sehr
lange: Es müssen viele Gatter durchlaufen werden, höhere parasitäre
Kapazitäten etc.

Analysen von Speicherzugriffen haben gezeigt, dass während der Ausführung von
Programmen häufig auf die selben oder benachbarte Speicherstellen zugegriffen wird.
Dabei wird zwischen örtlicher und zeitlicher Lokalität unterschieden.
352 8 Cache

Örtliche Lokalität bedeutet, dass beim Zugriff auf eine Speicherstelle sehr wahrscheinlich
auch auf eine Speicherstelle in der Nähe zugegriffen wird. Das hat u.a. folgende
Ursachen:
• Die natürliche Befehlsabfolge ist sequentiell und aufeinander folgende Befehle
liegen hintereinander im Speicher.
• Aufeinander folgende Befehle bzw. Befehle an Adressen ‘‘in der Nähe’’ be-
schäftigen sich in der Regel mit demselben Problem (z.B. selbe Funktion) und
verwenden deswegen auch die selben Daten bzw. zusammengehörige (z.B. zur
selben Funktion gehörige) Daten.
• Zusammengehörige Daten werden (wie zusammengehörige Befehle) im Spei-
cher an benachbarten Adressen abgespeichert. Beispiele:
• Bei Arrays werden die einzelnen Elemente direkt hintereinander im
Speicher abgelegt.
• Bei der Allokation von Daten auf dem Heap (z.B. mit malloc, new, ...)
wird vom Betriebssystem ein Zeiger auf einen zusammenhängenden
Speicherbereich zurückgegeben.
• Lokale Variable werden nach Funktionen gruppiert der Funktions-
Aufrufreihenfolge entsprechend auf dem Stack abgelegt.

Zeitliche Lokalität bedeutet, dass es bei einem Zugriff auf eine Speicherstelle sehr wahr-
scheinlich ist, dass innerhalb eines kurzen Zeitraums wieder auf dieselbe Speicherstelle
zugegriffen wird. Das hat u.a. folgende Gründe:
• Variable werden in der Regel mehrfach verwendet, aus Prinzip mindestens
zweimal: Auf eine Variable lesend zuzugreifen macht nur Sinn, wenn zuvor
etwas hineingeschrieben wurde. Ebenso macht es nur Sinn, etwas in eine
Variable hineinzuschreiben, wenn das geschriebene Datenwort auch wieder
ausgelesen wird.
• Für Zugriffe auf verschiedene Elemente eines Arrays wird immer dieselbe
Basisadresse verwendet.
• Ein Schleifenzähler wird bei jedem Schleifendurchlauf geändert und für einen
Vergleich abgefragt.
• Befindet sich ein Befehl in einer Schleife, so werden mit jeder Iteration
• die Adressen derselben Befehle in den Befehlszähler geladen und
• dieselben Variablen verwendet.
8.2 Speicher-Hierarchien 353

Aufgrund der Zeitlichen Lokalität können Speicherzugriffe dadurch beschleunigt werden,


dass beim erstmaligen Zugriff auf eine Speicheradresse das adressierte Wort für zukünf-
tige Zugriffe in einem auf dem Prozessor-Die befindlichen schnellen Puffer-Speicher,
dem sog. Cache-Speicher, zwischengespeichert wird. Wird erneut auf die selbe Spei-
cheradresse zugegriffen, kann das im Cache-Speicher vorhandene Wort verwendet und
der langsame Zugriff auf den Arbeitsspeicher vermieden werden.
Werden zusätzlich Worte von benachbarten Adressen in den Cache-Speicher geladen,
kann neben der Zeitlichen Lokalität auch die Örtliche Lokalität zur Verringerung der
Speicherzugriffszeit ausgenutzt werden. Beim sog. Prefetching werden Befehle/Daten
im Voraus ‘‘auf Verdacht’’ vom Arbeitsspeicher angefordert, d.h. ohne Vorliegen eines
konkreten Lade- oder Speicherbefehls. Wird dann tatsächlich ein Lade- oder Speicher-
befehl mit einer entsprechenden Adresse ausgeführt, stehen die Daten bereits im
Cache-Speicher, was den Zugriff deutlich beschleunigt.

8.2 Speicher-Hierarchien
Um sehr schnell auf gespeicherte Daten zugreifen zu können, müssen diese sehr schnell
adressiert werden können. Voraussetzung für eine schnelle Adressierung ist, dass die
Daten nur aus einer kleinen Datenmenge ausgewählt werden müssen und nicht aus einer
großen Datenmenge (parasitäre Kapazitäten, zusätzliche (mehrstufige) Adressierungs-
Logik, ...). Aus diesem Grund werden Speichersysteme häufig hierarchisch aufgebaut.
Nachfolgende Abbildung zeigt ein Beispiel für eine Speicherhierarchie.

1 Prozessortakt
256 Register zu je 64 Bit Prozessor-Register
0,4 ns

1 Prozessortakt
32 kB pro Prozessorkern L1-Cache
0,4 ns

10 Prozessortakte
256 kB pro Prozessorkern L2-Cache
4 ns

8 MB geteilt von mehreren 50 Prozessortakte


L3-Cache
Prozessorkernen 20 ns

16 GB geteilt von mehreren 150 Prozessortakte


Arbeitsspeicher
Prozessorkernen 60 ns

1 TB geteilt von allen 250 bzw. 25.000 Takte


SSD/HDD
Prozessorkernen 100 ns bzw. 10 ms
354 8 Cache

Je weiter oben sich ein Speicherlement in der Hierarchie befindet desto schneller und
kleiner ist es. Je weiter unten sich ein Speicherelement in der Hierarchie befindet, desto
mehr Daten kann es aufnehmen – ist aber auch dementsprechend langsamer.

8.3 Begriffsklärungen
Das Grundprinzip von Caches beruht darauf, Datenworte aus großen langsamen Spei-
chern in kleinen schnellen Speichern (Caches) zu puffern. Das Puffern findet blockweise
statt, d.h. es werden immer nur komplette Speicher-Blöcke im Cache abgelegt. Diese
Blöcke werden auch Rahmen (engl. frames) oder Zeilen (engl. cache lines) genannt.

Cache-Hit, Hit-Time und Hit-Rate


Ist bei einem Speicherzugriff das adressierte Datenwort bereits im Cache vorhanden,
spricht man von einem Cache-Hit (engl. hit = Treffer). In diesem Fall ist die Zugriffszeit
auf das Datenwort kurz. Die Zugriffszeit im Falle eines Cache-Hits nennt man Hit-Time,
die mittlere Auftritts-Wahrscheinlichkeit für einen Cache-Hit nennt man Hit-Rate.

Cache-Miss, Miss-Time und Miss-Rate


Ist das adressierte Datenwort nicht im Cache verfügbar, spricht man von einem Cache-
Miss. Das Datenwort muss dann erst aus dem nachgeschalteten (langsameren/größeren)
Speicher in den Cache geladen werden. Die Zeit, bis das Datenwort verfügbar ist, nennt
man Miss-Time. Die mittlere Auftritts-Wahrscheinlichkeit für einen Cache-Miss nennt
man Miss-Rate.

Verdrängungsstrategien
Durch die geringe Größe der schnellen Speicher ist deren Aufnahmekapazität stark
begrenzt. Ist ein kleiner schneller Speicher voll, müssen erst Daten vom kleinen schnellen
in den großen langsamen Speicher zurückgeschrieben werden. Erst wenn durch diese
sog. Verdrängung wieder Platz geschaffen wurde, können neue Daten vom großen
langsamen in den kleinen schnellen Speicher geladen werden. Gibt es mehrere Cache-
Rahmen, an denen ein Arbeitsspeicher-Rahmen abgelegt werden kann, muss zunächst
entschieden werden, welcher Cache-Rahmen verdrängt werden soll. Dazu gibt es
mehrere Strategien, z.B.:
• LRU: LRU steht für least recently used und meint, dass derjenige Rahmen
verdrängt wird, der am längsten nicht verwendet wurde. Die Implementierung
ist aufwendig.
• LFU: LFU steht für least frequently used und meint, dass der am seltensten
benutzte Rahmen verdrängt wird.
8.3 Begriffsklärungen 355

• FIFO: FIFO steht für first in first out und meint, dass Rahmen in der Reihenfolge
verdrängt werden, in der sie in den Cache-Speicher geschrieben wurden.
• Random: Die Auswahl des zu verdrängenden Rahmens erfolgt zufällig, d.h.
ohne feste Regel. Dieses (planlose) Vorgehen kann gegenüber den anderen
Verdrängungsstrategien durchaus Vorteile bieten: Ist die Reihenfolge der Da-
tenzugriffe beispielsweise iterativ konsekutiv und die Menge der Daten so groß,
dass nicht alle Daten gleichzeitig in den Cache passen, dann kann durch die
Zufälligkeit sehr wahrscheinlich eine Hitrate > 0 erreicht werden, während LRU
definitiv zu einer Hit-Rate von 0 führt.
• Optimal: Es werden diejenigen Daten verdrängt, die am spätesten benötigt
werden. Dieses Verfahren ist zwar optimal, in der Praxis jedoch nicht einsetzbar,
da in der Regel nicht im Voraus bekannt ist, auf welche Daten zukünftig
zugegriffen wird (Datenabhängigkeiten etc.). Das Verfahren kann jedoch als
Referenz zu Bewertung anderer Verfahren verwendet werden.

Schreibstrategien
Wird auf ein im Cache-Speicher vorhandenes Datenwort schreibend zugegriffen, gibt es
zwei mögliche Vorgehensweisen:
• Write-Through: Das zu schreibende Datenwort wird sowohl im Cache-Speicher
als auch auf den anderen Hierarchie-Ebenen (z.B. Arbeitsspeicher) aktualisiert.
Dadurch werden in einem Mehrkern-Prozessorsystem Änderungen auch für
andere Prozessorkerne zugänglich. Um die Befehlsverarbeitung nicht aufzu-
halten, werden die Schreibzugriffe gepuffert und asynchron im Hintergrund
ausgeführt.
• Write-Back: Das zu schreibende Datenwort wird nur im Cache-Speicher ak-
tualisiert. Die Synchronisierung mit den anderen Hierarchie-Ebenen erfolgt erst
bei der Verdrängung des entsprechenden Cache-Blocks.

Wird auf ein nicht im Cache befindliches Datenwort schreibend zugegriffen, gibt es
ebenfalls zwei Vorgehensweisen:
• Write-Allocate: Das Datenwort wird im Cache gespeichert. Dazu muss ggf.
zunächst ein Cache-Block verdrängt werden, bevor der zur Speicheradresse
gehörige Cache-Block in den Cache geladen werden kann. Ist der passende
Cache-Block geladen, wird das neue Datenwort darin abgelegt.
• Write-No-Allocate/Write-Around: Das Datenwort wird nicht im Cache gespei-
chert. Das kann sinnvoll sein, wenn klar ist, dass das Datenwort nicht mehr
356 8 Cache

benötigt wird und ein Speichern ggf. die Verdrängung eines später benötigten
Datenworts zur Folge hätte.

Aufgaben

a) Bei der Ausführung eines Programms auf einem System mit L1 Cache-Speicher
und Arbeitsspeicher wird eine Hit-Rate von 70% beobachtet. Wie groß ist die
Miss-Rate?

b) Bei der Ausführung eines Programms wird eine Hit-Rate von 90 % gemessen. Die
Hit-Time beträgt 1 ns, die Miss-Time 50 ns. Wie groß ist die mittlere Speicher-
Zugriffszeit?

c) Ein Programm besteht aus 90 Lade- und 10 Speicher-Befehlen, für deren Ausfüh-
rung insgesamt 1,28 µs beobachtet werden. Wie groß ist die Hit-Rate, wenn die
Hit-Time 1 ns und die Miss-Time 60 ns betragen?
8.4 Direkt-Abgebildeter Cache 357

8.4 Direkt-Abgebildeter Cache


Beim Direkt-Abgebildeten Cache (engl. direct mapped cache) wird jeder Speicher-
Adresse genau eine feste Cache-Adresse zugeordnet. Dazu wird die Speicheradresse
in drei Teile aufgeteilt:
• Die f Bit breite Rahmen-Nummer (engl. frame number) wählt einen von 2f
Cache-Rahmen (= Cache-Block = Cache-Zeile) aus.
• Die b Bit breite Byte-Auswahl wählt aus den 2b pro Rahmen abgespeicherten
Byte ein Byte aus. Wird nicht ein einzelnes Byte sondern ein aus mehre-
ren Byte zusammengesetztes Datenwort adressiert, kann durch Löschen der
niederwertigsten Bits eine entsprechende Wort-Adresse erzwungen werden.
• Mit dem k Bit breiten Schlüssel (engl. key) kann überprüft werden, ob in
dem ausgewählten Rahmen die zur Speicheradresse gehörigen Daten abgelegt
sind. Diese Überprüfung ist notwendig, da bei einem 2n = 2k+f +b Byte großen
Arbeitsspeicher jeweils 2k unterschiedliche 2b Byte große Arbeitsspeicher-
Blöcke auf den selben durch f adressierten Cache-Rahmen abgebildet werden.

Arbeitsspeicher-Adresse (k + f + b Bits)

k Bits f Bits b Bits

Schlüssel Rahmen-Nr. Byte-Auswahl

k (key) f (frame) b bytes


Rahmen (frame)

b
0 v 2 - 1 ... ... 2 1 0
1 v
v
v
v
v
v

f
2-1 v

k Bits
In diesen k⋅2 f Bits des sog. In diesen 2f+b Byte sind die
Tag-RAMs ist der von jedem Cache-Daten abgespeichert
Cache-Rahmen verwendete (Cache-Inhalt)
Schlüssel abgespeichert
358 8 Cache

Wird ein neuer Rahmen im Cache abgelegt, so wird der Schlüssel-Teil der
Arbeitsspeicher-Adresse an Adresse f des sog. Tag-RAMs (engl. tag = Etikett) ab-
gelegt. Bei einem erneuten Zugriff muss das durch die Rahmen-Nummer ausgewählte
Tag mit dem Schlüssel-Teil der Arbeitsspeicher-Adresse verglichen werden.
• Sind der Schlüssel und das abgespeicherte Tag identisch, dann ist in dem durch
f adressierten Rahmen tatsächlich das adressierte Datenwort gespeichert.
Durch die Byte-Auswahl b kann das entsprechende Datenwort dann adressiert
und ausgelesen werden.
• Sind Schlüssel und Tag unterschiedlich, dann ist im adressierten Rahmen nicht
der zum Datenwort gehörige Speicher-Block abgelegt, sondern einer der 2k 1
möglichen anderen. Bevor auf den Cache zugegriffen werden kann, muss der im
Cache gespeicherte Rahmen zunächst in den Arbeitsspeicher verdrängt wer-
den. Anschließend kann der adressierte Speicher-Block vom Arbeitsspeicher
in den zugehörigen Cache-Rahmen kopiert werden. Um die Arbeitsspeicher-
Adresse des im Cache abgespeicherten Datenworts später wieder eindeutig
identifizieren zu können, wird der Schlüssel-Teil der Speicheradresse im Tag-
RAM an der durch f adressierten Stelle abgelegt.

Zum Vergleich des Schlüssels mit dem Tag werden k 1 Bit-Vergleicher benötigt.
Das sog. Valid-Bit zeigt an, ob im adressierten Cache-Rahmen gültige Daten stehen.
Zu Beginn sind alle Valid-Bits gelöscht. Wird ein Rahmen vom Arbeitsspeicher in den
Cache geladen, wird das Valid-Bit auf 1 gesetzt.
Neben dem Valid-Bit wird bei Caches mit write-back-Schreibstrategie zusätzlich ein sog.
Dirty-Bit verwendet, welches anzeigt, ob die im Rahmen befindlichen Daten geändert
wurden. Geänderte Daten müssen beim Verdrängen wieder in den Arbeitsspeicher
kopiert werden, unveränderte nicht.
Durch die einfache Rahmenauswahl sind direktabgebildeten Caches sehr schnell. Erfol-
gen jedoch Zugriffe von Adressen mit identischen Rahmen-Nummern, aber unterschied-
lichen Schlüsseln, so verdrängen sich die Zugriffe permanent gegenseitig, auch wenn
noch andere Rahmen frei wären. Verdrängungsstrategien wie LRU o.ä. zur Auswahl
des zu verdrängenden Rahmens finden hier keine Anwendung, da der zu verdrängende
Rahmen direkt durch f festgelegt ist.

Aufgaben

a) Wieviele Einträge hat das Tag-RAM, wenn zur Codierung der Rahmen-Nummer 20
Bits verwendet werden?
8.4 Direkt-Abgebildeter Cache 359

b) Welcher Rahmen wird beim Zugriff mit der 64 Bit breiten Arbeitsspeicher-Adresse
0x0123456789ABCDEF ausgewählt, wenn der Schlüssel mit 40 Bits und die
Byteauswahl mit 12 Bits codiert wird?

c) Welcher Rahmen wird beim Zugriff mit der 64 Bit breiten Arbeitsspeicher-Adresse
0x0123456789ABCDEF ausgewählt, wenn der Schlüssel mit 38 Bits und die
Byteauswahl mit 10 Bits codiert wird? Geben Sie den Wert hexadezimal an.

d) Wieviele 1-Bit-Vergleicher sind allgemein zum Vergleich des Schlüssels mit dem
adressierten Tag-RAM-Eintrag notwendig?

e) Warum werden bei einem Arbeitsspeicher-/Cache-Zugriff die oberen k Bits der


Arbeitsspeicher-Adresse im Tag-RAM abgelegt?

f) Wie groß ist ein Cache-Rahmen, wenn zur Codierung der Byte-Auswahl 12 Bits
verwendet werden?

g) In einem Cache-Rahmen können 16 Octas abgelegt werden. Wieviele Bits werden


zur Codierung der Byteauswahl benötigt?
360 8 Cache

8.5 Voll-Assoziativer Cache


Bei einem Voll-Assoziativen Cache (engl. fully associative cache) können die Daten eines
Arbeitsspeicher-Rahmens in jedem beliebigen Cache-Rahmen abgelegt werden. So wird
sichergestellt, dass erst dann Rahmen entsprechend der eingesetzten Verdrängungs-
strategie (z.B. LRU) verdrängt werden müssen, wenn alle Cache-Rahmen belegt sind.
Die Wahrscheinlichkeit für eine Verdrängung ist beim Voll-Assoziativen Cache somit
geringer als beim Direktabgebildeten Cache. Jedoch ist beim Voll-Assoziativen Cache
die Identifikation des korrekten Rahmens aufwendiger () langsamer), da der Schlüssel
mit den Tags aller Rahmen verglichen werden muss.

Aufgaben

a) Wie muss die Arbeitsspeicher-Adresse zur Adressierung eines Voll-Assoziativen


Caches aufgeteilt werden?

b) Ein vollassoziativer MMIX-Cache-Speicher verwendet eine Rahmengröße von 256


Byte. Wieviele Bits werden zur Codierung des Schlüssels verwendet?

c) Ein 32 kByte großer vollassoziativer MMIX-Cache-Speicher verwendet eine Rah-


mengröße von 256 Byte. Wieviele 1-Bit-Vergleicher sind zum Vergleich des Schlüs-
sels mit den Tags notwendig?
8.6 Set-Assoziativer Cache 361

8.6 Set-Assoziativer Cache


Ein Set-Assoziativer Cache (engl. set associative cache) kann als Kompromiss zwischen
einem Direkt-Abgebildeten und einem Voll-Assoziativen Cache angesehen werden.
Die Arbeitsspeicher-Adresse wird wie beim Direkt-Abgebildeten Cache in drei Teile
aufgeteilt. Der mittlere Teil ist hier jedoch nicht einem einzigen Rahmen zugeordnet,
sondern einer Menge (engl. set) an Rahmen. Die Anzahl der Rahmen in dieser Menge
heißt Assoziativität a. Nach der Adressierung der potentiellen Rahmen müssen beim
Set-Assoziativen Cache nur a Tags parallel mit dem Schlüssel verglichen werden.
Verglichen mit dem Direkt-Abgebildeten Cache ist die Rahmensuche aufwendiger, die
Verdrängungswahrscheinlichkeit jedoch geringer. Verglichen mit dem Voll-Assoziativen
Cache ist die Rahmensuche weniger aufwendig, die Verdrängungswahrscheinlichkeit
jedoch höher.
Arbeitsspeicher-Adresse (k + s + b Bits)

k Bits s Bits b Bits

Schlüssel Set-Nr. Byte-Auswahl

Assoziativität
k (key) s (set) b bytes
a=2 Rahmen (frame)

b
v 2 - 1 ... ... 2 1 0
0
v
v
1
v
v
2
v
v

2 s- 1
v

k Bits
In diesen k⋅2s Bits des sog. In diesen a⋅2s+b Byte sind die
Tag-RAMs ist der von jedem Cache-Daten abgespeichert
Cache-Rahmen verwendete (Cache-Inhalt)
Schlüssel abgespeichert

Zur Detektion, ob ein Arbeitsspeicher-Rahmen im Cache liegt, muss der Schlüssel der
Arbeitsspeicher-Adresse mit allen Tags des durch die Set-Nummer adressierten Cache-
Sets verglichen werden. Die Entscheidung, welcher Rahmen eines Sets verdrängt werden
muss, erfolgt entsprechend der angewendeten Verdrängungsstrategie (z.B. LRU).
362 8 Cache

Aufgaben

a) Wieviele 1-Bit-Vergleicher sind für einen 4 fach Set-Assoziativen MMIX-Cache


notwendig, wenn die Rahmengröße 2048 Byte beträgt und bei jeder 228 -sten
Speicheradresse auf dasselbe Set zugegriffen wird? Wieviele Sets hat der Cache?

b) Über wieviele Cache-Rahmen verfügt ein 8 fach Set-Assoziativer MMIX-Cache,


wenn zur Codierung der Set-Nummer 13 Bit verwendet werden?

Ein 8 fach Set-Assoziativer MMIX-Cache hat eine Größe von 1 MB. Die Rahmengröße
beträgt 32 Byte.

c) Wieviele Bits werden zur Codierung der Byteauswahl, der Setnummer und des
Schlüssels verwendet?
8.6 Set-Assoziativer Cache 363

Ein 16 fach Set-Assoziativer MMIX-Cache hat 2048 Cache Sets. Zum Vergleich des
Schlüssels mit den Tags werden 688 Vergleicher verwendet.

d) Welche Rahmengröße hat der Cache?

Ein Set-Assoziativer Cache verwendet zur Codierung des Schlüssels 41 Bit, zur Codie-
rung der Setnummer 16 Bit und zur Codierung der Byteauswahl 7 Bit.

e) Geben Sie für folgende Arbeitsspeicher-Adressen die zugehörige Set-Nummer an.

0x2000 0000 0000 0000:

0x2000 0000 0123 4567:

0x2000 0000 478B 0228:

Das könnte Ihnen auch gefallen