Prof. Dr.-Ing. K. Diepold - mzwebserver.ldv.ei.tum.de CS1 Skript.pdf · und Aufbau untersuchen. Nachdem wir uns bis zu den auf der Hauptplatine befindlichen Komponen-ten vorgearbeitet

TECHNISCHE UNIVERSITÄT MÜNCHEN Fakultät für Elektrotechnik und Informationstechnik L e h r s t u h l f ü r D a t e n v e r a r b e i t u n g Prof. Dr.-Ing. K. Diepold

Computertechnik – Computersysteme

SS 2007

Takt

Befehls-CacheKap. 6.3

TLB

BD-PhaseKap. 4.2.3,4.2.4,

BH-PhaseKap. 4.2.1,4.2.2

Zusatz-Logik fürkomplexeBefehle

AF-Phase IntegerRechenwerk/ALUKap. 4.2.5, 4.2.6, 4.4.4

AF-Phase GleitkommaRechenwerk/ALUKap. 4.4.4

Mik

ropr

ogra

mm

-Lo

gik,

~ K

ap. 4

.4.5

Daten-CacheKap. 6.3

TLB

BusKap. 1.1.2

Sprung-Vorher-sage, ~Kap. 8.2

Logik für Bus-SchnittstelleKap. 5

Altes CS1-Skript

1-1

Inhalt

1 Motivation: Wie funktioniert ein Computer? ...............................1-5 1.1 Komponenten eines Computers............................................................................................... 1-5

1.1.1 Peripherie-Geräte und Netzteil ...................................................................................... 1-7 • Netzteil ................................................................................................................................. 1-7 • Grafikkarte.......................................................................................................................... 1-10 • DVD-ROM......................................................................................................................... 1-19 • DVD-Brenner ..................................................................................................................... 1-27 • Festplatte ............................................................................................................................ 1-28

1.1.2 Komponenten auf der Hauptplatine - Überblick........................................................... 1-36 • Prozessor ............................................................................................................................ 1-38 • Arbeitsspeicher ................................................................................................................... 1-43 • Busse .................................................................................................................................. 1-50 • GMCH = Graphics and Memory Controller Hub (B)......................................................... 1-59 • ICH5 = Input/Output Controller Hub (5. Generation) (C).................................................. 1-59 • SIO-Controller = Super Input/Output Controller (D) ......................................................... 1-59

1.2 Von Neumann-Architektur....................................................................................................... 1-60 1.3 Harvard-Architektur ................................................................................................................. 1-64 1.4 Vom Algorithmus zum Prozessor – Abstraktionsebenen.................................................... 1-65

2 Assembler- und Befehlssatz-Ebene ............................................2-1 2.1 Rechnerarchitektur auf Assembler- und Befehlssatz-Ebene ................................................ 2-1 2.2 Programme ................................................................................................................................. 2-2

2.2.1 Anweisungen für den Prozessor.................................................................................... 2-2 • Befehlssatz............................................................................................................................ 2-2 • Register................................................................................................................................. 2-3 • Arbeitsspeicher ..................................................................................................................... 2-4

2.2.2 Anweisungen für den Assembler ................................................................................... 2-6 2.2.3 Anweisungen für den Loader ......................................................................................... 2-6

2.3 Klassifizierung von Befehlssätzen ........................................................................................... 2-7 2.3.1 Klassifizierung nach der Anzahl der Operanden ........................................................... 2-7

• Dreiadressmaschine.............................................................................................................. 2-7 • Zweiadressmaschine............................................................................................................. 2-7 • Einadressmaschine ............................................................................................................... 2-7 • Nulladressmaschine.............................................................................................................. 2-7

2.3.2 Klassifizierung nach der Bereitstellung der Operanden ................................................ 2-8 • Register-Register-Architektur (Load-Store-Architektur) ..................................................... 2-8 • Register-Speicher-Architektur.............................................................................................. 2-9 • Akkumulator-Architektur ................................................................................................... 2-10 • Stack-Architektur ............................................................................................................... 2-10

2.3.3 Klassifizierung nach der Mächtigkeit der einzelnen Befehle ....................................... 2-11 • CISC-Architektur ............................................................................................................... 2-11 • RISC-Architektur ............................................................................................................... 2-11 • VLIW-Architektur .............................................................................................................. 2-13

2.3.4 Klassifizierung nach Orthogonalität ............................................................................. 2-14 2.4 Performance auf Assembler- bzw. Befehlsatz-Ebene .......................................................... 2-14

2.4.1 Begriff "Performance" .................................................................................................. 2-14 2.4.2 Entstehung der Programmausführungs-Zeit................................................................ 2-14 2.4.3 Performance-Messung................................................................................................. 2-15 2.4.4 Gesetz von Amdahl...................................................................................................... 2-17

Michael Zwick

1-2

3 Assembler- und Befehlssatz-Ebene beim MMIX.........................3-1 3.1 MMIX-Modellrechner .................................................................................................................. 3-1 3.2 Architektur .................................................................................................................................. 3-2

3.2.1 Programmiermodell........................................................................................................ 3-2 3.2.2 Register.......................................................................................................................... 3-2

• Allzweckregister (GPR = General Purpose Register)........................................................... 3-2 • Spezialregister ...................................................................................................................... 3-3

3.2.3 Speicherorganisation ..................................................................................................... 3-4 • Textsegment ......................................................................................................................... 3-5 • Datensegment ....................................................................................................................... 3-5 • Poolsegment ......................................................................................................................... 3-6 • Stacksegment........................................................................................................................ 3-6 • Für Betriebssystem reservierter Bereich............................................................................... 3-6

3.2.4 Speicher-Zugriffsarten ................................................................................................... 3-7 3.3 Befehlsformat ............................................................................................................................. 3-8 3.4 Befehlstypen............................................................................................................................. 3-10

3.4.1 MMIX-Befehlssatz........................................................................................................ 3-10 3.4.2 Loader-Befehle ............................................................................................................ 3-10 3.4.3 Assembler-Befehle....................................................................................................... 3-11

3.5 Befehlssatz ............................................................................................................................... 3-13 3.5.1 Nomenklatur und Operandenverwendung................................................................... 3-13 3.5.2 Laden und Speichern................................................................................................... 3-14 3.5.3 Laden von Registern mit Direktoperand ...................................................................... 3-15 3.5.4 Arithmetische Operationen .......................................................................................... 3-16 3.5.5 Bitweise Verknüpfungen .............................................................................................. 3-17 3.5.6 Schiebe-Befehle........................................................................................................... 3-18 3.5.7 Vergleich von Zahlen ................................................................................................... 3-18 3.5.8 Bedingte Zuweisungen ................................................................................................ 3-19 3.5.9 Verzweigungen ............................................................................................................ 3-20 3.5.10 Sprünge und Funktionsaufrufe .................................................................................... 3-21 3.5.11 Interrupt-Befehle .......................................................................................................... 3-22 3.5.12 Gleitkomma-Konvertierung .......................................................................................... 3-24 3.5.13 Andere Operationen..................................................................................................... 3-25

3.6 Befehlscodierung ..................................................................................................................... 3-26 3.6.1 Allgemein ..................................................................................................................... 3-26 3.6.2 Codierung des Opcodes .............................................................................................. 3-27 3.6.3 Codierung der Operanden ........................................................................................... 3-28

3.7 Programmierung ...................................................................................................................... 3-29 3.7.1 Funktionsaufrufe .......................................................................................................... 3-29

• Motivation .......................................................................................................................... 3-29 • Ablauf der Verwendung einer Funktion (allgemein).......................................................... 3-29 • Parameterübergabe in Registern ......................................................................................... 3-30 • Parameterübergabe auf dem Stack...................................................................................... 3-32

3.7.2 Erzeugung von Namensräumen .................................................................................. 3-42 • Motivation .......................................................................................................................... 3-42 • Die Anweisung PREFIX.................................................................................................... 3-42 • Beispiel ............................................................................................................................... 3-42

3.7.3 Beispiel: skalprodfkt.mms ............................................................................................ 3-44 3.7.4 Lokale Marken ............................................................................................................. 3-46

• Motivation .......................................................................................................................... 3-46 • Setzen von lokalen Marken ................................................................................................ 3-46 • Verwendung lokaler Marken als Sprungziel ...................................................................... 3-46

1-3

4 Mikroarchitektur-Ebene ................................................................4-1 4.1 Funktionseinheiten .................................................................................................................... 4-1

4.1.1 Befehlsspeicher ............................................................................................................. 4-1 4.1.2 Datenspeicher................................................................................................................ 4-2 4.1.3 Registerblock ................................................................................................................. 4-4 4.1.4 Register.......................................................................................................................... 4-6

• D-Register ............................................................................................................................ 4-6 • Schieberegister ..................................................................................................................... 4-7

4.1.5 Rechenwerk (ALU)......................................................................................................... 4-7 4.1.6 Steuerung....................................................................................................................... 4-8 4.1.7 Multiplexer...................................................................................................................... 4-8 4.1.8 Demultiplexer ................................................................................................................. 4-9 4.1.9 Decoder........................................................................................................................ 4-10 4.1.10 Leitungen und Busse ................................................................................................... 4-10

4.2 Zusammensetzen des Datenpfads ......................................................................................... 4-12 4.2.1 Holen eines Befehls aus dem Befehlsspeicher ........................................................... 4-12 4.2.2 Auswahl des nächsten Befehls.................................................................................... 4-12 4.2.3 Dekodieren des Befehls............................................................................................... 4-13 4.2.4 Bereitstellen der Operanden........................................................................................ 4-14 4.2.5 Ausführen des Befehls/Berechnung von Daten........................................................... 4-14 4.2.6 Steuerung der Auswahl der ALU-Funktion und des Direktoperanden ........................ 4-15 4.2.7 Ergebnis in den Registerblock schreiben .................................................................... 4-16 4.2.8 Ergebnis als Sprungziel verwenden ............................................................................ 4-17 4.2.9 Lesezugriffe auf den Datenspeicher ............................................................................ 4-17 4.2.10 Schreibzugriffe auf den Datenspeicher........................................................................ 4-19

4.3 Performance des Single-Cycle-Datenpfads........................................................................... 4-19 4.4 Aufbau der Funktionseinheiten auf Mikroarchitektur-Ebene .............................................. 4-20

4.4.1 Speicher ....................................................................................................................... 4-20 4.4.2 Registerblock ............................................................................................................... 4-20 4.4.3 Register........................................................................................................................ 4-21

• Schieberegister ................................................................................................................... 4-22 4.4.4 Rechenwerk ................................................................................................................. 4-23

• Kombinatorischer Schieber (Shifter) .................................................................................. 4-23 • Rechenwerk: Addition und Subtraktion ............................................................................. 4-24 • Multiplikations-Werk ......................................................................................................... 4-25 • Divisions-Werk................................................................................................................... 4-32

4.4.5 Steuerung..................................................................................................................... 4-39 • Zustandsautomat................................................................................................................. 4-39 • Mit Multiplexern ................................................................................................................ 4-39 • Mit PLA.............................................................................................................................. 4-39 • Mit (P)ROM ....................................................................................................................... 4-39

5 Ebene der Digitalen Logik ............................................................5-1 5.1 Logikgatter.................................................................................................................................. 5-1

5.1.1 UND-Verknüpfung (AND)............................................................................................... 5-1 5.1.2 ODER-Verknüpfung (OR) .............................................................................................. 5-1 5.1.3 NICHT-Verknüpfung (NOT) ........................................................................................... 5-1 5.1.4 NICHT-UND-Verknüpfung (NAND)................................................................................ 5-1 5.1.5 NICHT-ODER-Verknüpfung (NOR) ............................................................................... 5-2 5.1.6 Exklusiv-ODER-Verknüpfung/Antivalenz (XOR)............................................................ 5-2

5.2 Performance auf Logik-Ebene: Gatterlaufzeiten..................................................................... 5-2 5.2.1 Ein- und Ausgangspegel bei Logikschaltungen............................................................. 5-2 5.2.2 Entstehung von Gatterlaufzeiten ................................................................................... 5-5

1-4

5.2.3 Kritischer Pfad................................................................................................................ 5-8 5.2.4 Verkürzung des kritischen Pfads durch Verwendung zusätzlicher Hardware ............... 5-9

5.3 Aufbau der Kombinatorischen Funktionseinheiten ............................................................. 5-11 5.3.1 Kombinatorische Schaltungen ..................................................................................... 5-11 5.3.2 Rechenwerk: Logik-Einheiten ...................................................................................... 5-11

• NICHT-Einheit (NOT unit) ................................................................................................ 5-11 • ODER-Einheit (OR unit) .................................................................................................... 5-11 • UND-Einheit (AND unit) ................................................................................................... 5-12

5.3.3 Rechenwerk: Addierer und Subtrahierer ..................................................................... 5-12 • 1-Bit Halbaddierer .............................................................................................................. 5-12 • 1-Bit Volladdierer............................................................................................................... 5-13 • 64-Bit Ripple-Carry Addierer............................................................................................. 5-16 • 64-Bit Carry-Look-Ahead (CLA) Addierer........................................................................ 5-17 • Einstufiger Carry-Look-Ahead Addierer............................................................................ 5-17 • Zweistufiger Carry-Look-Ahead Addierer.......................................................................... 5-21 • Dreistufiger Carry-Look-Ahead Addierer .......................................................................... 5-22

5.3.4 Status-Einheit............................................................................................................... 5-23 5.3.5 Multiplexer.................................................................................................................... 5-23 5.3.6 Demultiplexer/Decoder ................................................................................................ 5-25

5.4 Aufbau der Sequentiellen Funktionseinheiten...................................................................... 5-25 5.4.1 Was bedeutet „sequentiell“? ........................................................................................ 5-25 5.4.2 Speicher ....................................................................................................................... 5-25 5.4.3 Register........................................................................................................................ 5-25 5.4.4 Additions- und Subtraktions-Werk ............................................................................... 5-25 5.4.5 Verwendung des Subtraktionswerks für Vergleichsoperationen ................................. 5-26

6 Performance-Erhöhung auf Mikroarchitektur-Ebene .................6-1 6.1 Multi-Cycle-Datenpfad ............................................................................................................... 6-1 6.2 Pipelining .................................................................................................................................... 6-3

6.2.1 Implementierung ............................................................................................................ 6-3 6.2.2 Auswirkung auf die Ausführungszeit.............................................................................. 6-4 6.2.3 Pipeline-Stufen-Füll-Diagramm...................................................................................... 6-5 6.2.4 Pipeline-Konflikte (Hazards) .......................................................................................... 6-6

• Daten-Konflikte (data hazards)............................................................................................. 6-6 • Struktur-Konflikte (structural hazards)................................................................................. 6-9 • Steuerungs-Konflikte (control hazards).............................................................................. 6-10

6.3 Cache......................................................................................................................................... 6-12 6.3.1 Problemstellung ........................................................................................................... 6-12 6.3.2 Speicherhierarchie ....................................................................................................... 6-13 6.3.3 Cacheorganisationen ................................................................................................... 6-15

• Direktabgebildeter Cache (direct mapped cache) ............................................................... 6-15 • Vollassoziativer Cache (fully associative cache)................................................................ 6-16 • Set-Assoziativer Cache (set associative cache) .................................................................. 6-17

6.3.4 Schreibstrategien ......................................................................................................... 6-18 • Write-Through.................................................................................................................... 6-18 • Write-Back ......................................................................................................................... 6-18

6.3.5 Verdrängungsalgorithmen............................................................................................ 6-18 • LRU (least recently used) ................................................................................................... 6-18 • Zyklische Verdrängung ...................................................................................................... 6-18 • Zufällige Verdrängung ....................................................................................................... 6-18

6.3.6 Verfahren zur Verringerung der Transfer-Zeit ............................................................. 6-19 6.3.7 Prefetching................................................................................................................... 6-19 6.3.8 Abhängigkeit der Miss-Rate von der Rahmengrösse .................................................. 6-20 6.3.9 Metriken ....................................................................................................................... 6-21

1-5

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

1-6

Wir schrauben die Seitenverkleidung ab …

Abb. 2: Öffnen eines Computers

… und identifizieren die dann erscheinenden Komponenten.

DB

DR

DL

FPGK

FW

NT

Abb. 3: Geräte in einem Computer

1-7

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).

1-8

Ausgangsspannung +3,3 V +5 V +5 VSB +12 V

Strom (max.) 26 A 42 A 2,5 A 18 A

Leistung (max.) 12,5 W 216 W

max. Gesamtleistung 450 W

220 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-richter

~ °

° °

°=

Leistungs-Schalter

° °

°

HF-Trafo

°°

°°

Gleich-richter

~ °

° °

°

Tiefpass-Filter

°

°

°

°•

•

••

•

•

••

•

•=

Potential-trennung Regler

°

°• °

°

°°

°°

=

230 V ~5 V =

1 2 3 4 5

67 Abb. 6: Prinzip-Aufbau eines Schaltreglers

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

1

23

2

3

3

4

5

6

7

Abb. 7: Identifizierung von Schaltregler-Komponenten

1-9

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.

11

12

13

14

15

16

17

18

19

20

2

3

4

5

6

7

8

9

10

1

+3,3 V

GND

+5 V

GND

+5 V

GND

PW_OK

+5 VSB

+12 V

+3,3 V

-12 V

GND

PS_ON

GND

GND

GND

-5 V

+5 V

+5 V

+3,3 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.

1-10

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

Speicherchips mit Kühlkörper

AGP-Anschluss(Verbindung zum Prozessor)

BIOS

Anschluss für denMonitor (DVI)

Anschluss für denMonitor (VGA)

GPU mit Kühlkörper(GPU = GraphicsProcessing Unit)

Stecker für zusätzliche Stromversorgung

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

1-11

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. Die einzelnen Byte im Video-Speicher werden direkt auf Pixel1-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.

R G B R G B R

R G B R GB

R G B R G B R

R G B R GB

…

…

0x3F

0x00

0x78

0xFF

0xE8

…

pro Grundfarbe 1 Byte� 24 Bit Farbtiefe

1 Pixel

Video-Speicher in der Grafikkarte Bildschirm

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.

1-12

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.

R G B R G B R

R G B R GB

R G B R G B R

R G B R GB

…

…Fluoreszierende Schicht

Lochblende

3 Elektronenstrahlen

Spulen zur Ablenkungder Elektronenstrahlen

Kathoden

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.

1-13

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.

R

G

B

Hsync

Vsync t

1. Zeile 2. Zeile letzte Zeile 1. Zeile

1. Bild 2. Bild Abb. 14: Signale am VGA-Anschluss

1-14

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

0x00

0x78

0xFF

0xE8

…

RAMDAC (für Rot)

RAMDAC (für Grün)

RAMDAC (für Blau)

…

•••••

•••••

••••

•

Prozessor Video-Speicherauf der Grafikkarte

Digital-Analog-Wandler(RAMDAC)

VGA-Buchse

…

c:\>

Bildschirm

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.

1-15

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. Nachfolgende Abbildung zeigt, wie ein kurzer Ausschnitt der Linie auf den Pixeln2 zu liegen kommt.

einzelnePixel

Farbpunkteauf dem

Bildschirm

zu zeichnendeLinie

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.

1-16

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

0xFF

0xE8…

RAMDAC (für Rot)

RAMDAC (für Grün)

RAMDAC (für Blau)

•••••

•••••

••••

•

Prozessor Front- undBack-Buffer

Digital-Analog-Wandler(RAMDAC)

VGA-Buchse

c:\>

Bildschirm

0x4C

0x38

0x79

0x00

0xFE

…

…

…

wird gerade erstellt undim Anschluss dargestellt

wird gerade dargestellt

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.

1-17

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.

1-18

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.

1-19

• DVD-ROM Das in Abb. 3 auf Seite 1-6 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

1-20

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:

Leseseite der DVD

Beschriftung der DVD/Etikett

reflektierendeALU-Schicht

Träger (Land)

Land

Pit

Drehrichtung

Polycarbonat

Abb. 24: Aufbau einer DVD-ROM

1-21

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.

Leseseite der DVD


reflektierendeALU-Schicht

Träger (Land)

Land

Pit

Drehrichtung

Polycarbonat

Laser

Halbdurchläs-siger Spiegel

Photo-Detektor Auswertung der SignaleUmwandlung in einzelneByte

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.

! gegenphasigen Wellen beide Wellen genau auslöschen. Die Wellen überlagen sich also de-

struktiv, man spricht von destruktiver Interferenz.

1-22

Betrachtet man die Pits und das Land auf der DVD von der Leseseite her, fällt folgendes auf:

destruktive Interferenz

konstruktive Interferenz

destruktiveInterferenzLaser

Ansicht von unten(Leseseite)

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 Leseseitereflektiertes Laserlicht

konstruktive Interferenz(es wird viel Licht reflektiert)

destruktive Interferenz(es wird fast kein Lichtreflektiert, da sich dieWellen gegenseitig aus-löschen)

Abb. 28: Reflexionen an der DVD

Die rotierende DVD reflektiert also

! beim Auftreffen des Laserstrahls auf Land das komplette Licht. ! beim Auftreffen des Laserstrahls auf Pits fast kaum Licht.

1-23

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.

Zeit

Spannung

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-Fourteen-Modulation (EFM), in der ein Byte (8 Bits) durch 14 sog. Channel-Bits kodiert wird.3 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).

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

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

1-24

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.

verschiebbare Linsen

halbtransparenter Layer

reflektierender Layer

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.

Antriebsmotor

DVD

Motor zur horizontalen Positionierung der LinseGewindestange Spulen zur vertikalen Positionierung der Linse

Linse

Abb. 32: Prinzip-Aufbau einer DVD-Mechanik

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

Abb. 33: DVD-Laufwerk

1-25

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

Motor zum horizontalenVerschieben der Linse

Linse

Auflagepunktfür die DVD

(Antrieb)

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.

1-26

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

1-27

• DVD-Brenner Das in Abb. 3 auf Seite 1-6 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.

Leseseite


Polycarbonat

reflektierendeSchicht

Schutzschicht

Land

Pit

Drehrichtung

nicht reflektierendeschwarze 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)

Pits

Land

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).

1-28

• Festplatte Das in Abb. 3 auf Seite 1-6 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.

Schreib-/Lese-Kopf

magnetisierbareSpeicherplatte

schwenkbarerArm

PermanentmagnetArmpositionierung(Elektromagnet)

Anschluss für die Elektronik

Abb. 40: Aufau einer Festplatte

1-29

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).

t

Bewegungsrich-tung der Platte

Stromverlaufbeim Schreiben

Trägermaterialaus Glaskeramik

magnetisierbareSchicht

Schreib-/Lesekopf

SpuleMagnetfeldlinien

NS SN S NSNN N S

+-

Abb. 41: Datenspeicherung auf der Festplatte durch Magnetisierung

Nachfolgende Abbildung zeigt den Vorgang der Magnetisierung der Festplatte.

N S

+-

Magnetisierung (Äquivalent-Magnet) keine Magnetisierung

ungeordneteElementarmagnetegeordnete

Elementarmagnete

Magnetfeldlinien

Spule

Abb. 42: Magnetisierung

1-30

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-netische Nichtleiter schließen.4 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.

t

Bewegungsrich-tung der Platte

Stromverlaufbeim Lesen

Trägermaterialaus Glaskeramik

magnetisierbareSchicht

Schreib-/Lesekopf

SpuleMagnetfeldlinien

NS SN S NSNN N S

•

+

-

•OpAmp

t1 t2

Strommessung(siehe Stromverlauf)

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) regist-riert, ausgewertet und in einzelne Byte dekodiert. Diese Byte stellen dann die auf der Festplatte abge-speicherte 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.

1-31

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.

Spuren Sektor 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-

1-32

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 mmDicke des Luftkissens, auf dem die Köpfe schweben 20 nmUmdrehungsgeschwindigkeit der äußeren Spuren (Radius = 4 cm, 7200 U/min) 110 km/h

Spurabstand (bei 1500 Spuren pro cm) 6,7 µmBit-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 mDicke des Luftkissens, auf dem die Köpfe schweben 1 cmUmdrehungsgeschwindigkeit der äußeren Spuren (Radius = 4 cm, 7200 U/min) 55.000.000 km/h

Spurabstand (bei 1500 Spuren pro cm) 3,35 mBit-Abstand 25 cm

Abb. 47: Skalierte Festplatten-Daten

1-33

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-Magnete

Spule (am Arm montiert)

Drehlager zur Rotationdes Arms

drehbar gelagerterArm

Permanent-Magnet zumHalten desArms in derParkposition

Abb. 48: Mechanik zur Armpositionierung

1-34

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.

Servo-Informationen

Sektoren

Abb. 49: Servo-Information

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-ramtern, der Ist- und der Soll-Position den nötigen Spulenstrom bestimmt.5

Regler

Laufwerk

•+ SpulenstromSoll-Position

Ist-Position

aktuellerFehler

Abb. 50: Regelkreis

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.

1-35

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. 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.

DB

DR

DL

FPGK

FW

NT

Abb. 51: 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.

1-36

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:

A

B

FS

B4

B4

B4

B4

B1

B2

B3 C

C1

C2C3

C3

C4

C5

C6

C7

C7

C7

C7

C7

C7

D

C9

D1

D2

D3

D4

D5D6

HI

C8

LA

Abb. 52: Hauptplatine eines Computers

Die grosse grüne Platine ist die Hauptplatine unseres Computers, die auch Mainboard oder Mother-board genannt wird. Auf der Hauptplatine sind alle wichtigen Komponenten des PCs untergebracht, die nicht so wie die Festplatte oder das DVD-Laufwerk als Peripherie-Geräte angesehen werden. Auf ihr befindet sich der Prozessor (A) der Hauptspeicher (B4), der Chipsatz (B, C), viele Anschlussmög-lichkeiten 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.

1-37

A

B

DDR-RAM

AGP-Port

C

Gigabit-Ethernet-Controller

Anschlüssefür USB 2.0

2 Anschlüssefür Serial-ATA

2 Anschlüssefür ATA 100

Audio-CodecAC `97 3

Takt-GeneratorCPU, PCI, …

SMBus 2.0/I2C-Bus

D

Anschluss Dis-ketten-Laufwerk

PS/2 AnschlussTastatur

PS/2 AnschlussMaus

Anschluss fürseriellen Port

Anschluss fürparallelen Port

Anschluss fürVentilator

Prozessor-Bus, 4$200 MHz(FSB = Front Side Bus)

HI = Hub Interface266 MByte/s

Kanal A3,2 GyteB/s

Kanal B3,2 GByte/s

PCI-Bus133 MByte/s

2,1 GByte/s

266 MByte/s

480 MBit/s

150 MByte/s

100 MByte/s

100 MBit/s

LPC-Interface(Low Pin Count)

Analoger VGA-Anschluss

Festplatte

DVD-ROM

DVD-Brenner

6 PCI-Slots

DDR-RAM

DDR-RAM

DDR-RAM

Grafikkarte

TFT-Bildschirm

DVIB1

B2

B3

B4

C1

C2

B4

B4

B4

C3

C4

C6

C7

FS

HI

D1

D2

D3

D4

D5

D6

Disketten-Laufwerk

Tastatur

Maus

FireWire-Adapter

GK

FP

DR

DB

FW

DL

Netzteil

NT

230 V ~

Ethernet-Controller

USB2.0-Controller

Intel 82801EBICH5

2 SATA-Controller

ATA 100Controller

AC `97Controller

PCI-Controller

LPC-interfaceController

CMOS-RAM

System-Managmnt.

Bios-interf.Controller Flash-Bios

SMBusController

SuperInput/Output

Controller

RS 232Controller

LPTController

FloppyController

TastaturController

MausController

Drehzahl-regelung

LAN-Anschluss

LA

1 GBit/s

Intel 82865GGMCH

HI Controller

CSA-Controller

DDR-RAMController

AGP-Controller

Grafik-Controller

FSB Logik/Treiber

ProzessorIntel P4

Befehls-Cache

Daten-Cache

Adress-Umsetzer

Rechen-Werk

Steuer-Werk

C9

Batterie C8

Abb. 53: Schematischer Aufbau eines Computers

1-38

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. 54: 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. 52 und Abb. 53 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

n-1 1 02Numerierung der Bits:

Datenwort mit Wortbreite n

…

LSBMSB

Abb. 55: Datenwort

1-39

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.

Registerblockmit Registern•

BR:

BZ:

Steuerwerk

ALUFlags:

FSB = Front Side Bus

Steuerung

2

13

•

•

Abb. 56: Laden von Befehlen in den Prozessor

Dazu wird vom sog. Steuerwerk6 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).

1-40

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).


BR:

BZ:

Steuerwerk

ALUFlags:


Steuerung5

•

•

6

4

5

4

Abb. 57: 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).


BR:

BZ:

Steuerwerk

ALUFlags:


Steuerung

9

7

8

•

•

10

7

Abb. 58: Bereitstellen von Operanden über den FSB

1-41

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).


BR:

BZ:

Steuerwerk

ALUFlags:


Steuerung •

•

1112

14

13

Abb. 59: 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.

O C Z S W I X

Overflow: Überlauf bei vorzeichenbehafteten Zahlen

Carry (Übertrag): Überlauf bei vorzeichenlosen Zahlen

Zero: Ergebnis ist Null

Sign (Vorzeichbit): Ergebnis ist negativ

Überlauf bei Gleitkomma-Festkomma-Wandlung

Ungültige Gleitkomma-Operation (z.B. )1!

Gleitkomma-Division durch Null

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

E

Abb. 60: Flag-Register

1-42

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 Ziel-adresse (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).


BR:

BZ:

Steuerwerk

ALUFlags:


Steuerung •

• 1715

1619

20

18

21

Abb. 61: 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. 56 (Seite 1-39)].

Addierer

BZ

Wortbreite desaktuellen Befehls

+

zum FSB

Abb. 62: Anpassen des Befehlszählers

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

1-43

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. 52 und Abb. 53 mit B4 gekennzeichneten Komponenten sind die DDR-RAM-Module, die zusammen den Arbeitsspeicher des Computers bilden.

Abb. 63: 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).

1-44

3

2 4 5 7

6

1 8

Abb. 64: Datenfluß im PC

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

0x10

0x2F

0x4B

0xC3

0x960x83

0x5D

0x00..00

0x00..01

0x00..02

0x00..03

0x00..040x00..05

0xFF..FF

Datum (1 Byte)

Speicher-Inhalt(Daten)

Speicher-Adressen

LesenSchreiben

Daten

Steuer-leitungen

•

1Adressez.B. 0x00..02

2

3

4

5

60x4B0x4B7

8

9

10

11

Abb. 65: 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-

1-45

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 ad-ressierten 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-cher Winkel-Geschwindigkeit7 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.

N3

P1

N1 N2

N4

P2

UB

Zeilenleitung (Auswahl)

Spa

ltenl

eitu

ng

Spa

ltenl

eitu

ng in

verti

ert

Bit Bit

Abb. 66: 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.

1-46

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.

N3

P1

N1 N2

N4

P2

UB

Zeilenleitung (Auswahl)

Spa

ltenl

eitu

ng

Spa

ltenl

eitu

ng in

verti

ert

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

7+ -

8

+

+5

+6

9-

-

-

10

11+

13+

12

+14

+15 +

16

17-

2 3

-14

18

19 -

X

Y

Abb. 67: 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“.

1-47

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

N3

P1

N1 N2

N4

P2

UB

Zeilenleitung (Auswahl)S

palte

nlei

tung

Spa

ltenl

eitu

ng in

verti

ert

Bit Bit

-

+

+-1

816 -

9

10 -

+

11UB � 1UB � 0 12

+-

UB/2UB/2

3 +

UB/2UB/26 6

Precharge

7 -

+4 +45 5

-2

X

Y

N5 N6

Abb. 68: 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.

1-48

! 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.

1-49

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

C

Spaltenleitung

Zeile

nlei

tung

Abb. 69: 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. Da Laden und Entladen bei Kondensatoren immer Zeit benötigt (U(t) = U0

$ e-RC/t), 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.

1-50

Wie wir in Abb. 64 auf Seite 1-44 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. 53 auf Seite 1-37 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).

Steuerwerk/Leitwerk

Rechenwerk/ALU

Registerblockmit Registern

ArbeitsspeicherProzessor (CPU)Bus

••

BR:

Abb. 70: 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.

1-51

! 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.

Bus

Daten-Bus:1010

Inhalt

0110

101012

t

Adr.

Bus besteht aus Adress-,Daten- und Steuer-Bus.

Spannungs-Pegel auf den Bus-leitungen in Abhängigkeit der Zeit.

Wert am Adress-Bus wähltdie Speicherzelle aus, in diedie Daten geschrieben werden.

tschreiben

10

10

10

10

Bit 3

Bit 2

Bit 1

Bit 0

0000

0001

0010

0011

0100

0101

0110

0111

1000

1001

1010

1011

11001101

1110

1111

10

10

10

10

Bit 3

Bit 2

Bit 1

Bit 0

10

10

Lesen

Schreiben

Adress-Bus:

Steuer-Bus:

Prozessor schreibtDaten 1010 anAdresse 0110und gibt an derLeitung „Schrei-ben“ eine fallen-de Flanke aus.

4

3

6

5

8

9

7

Abb. 71: Bussignale und deren Verwendung beim Schreibzugriff

1-52

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:

Bus

Daten-Bus:1010

Inhalt

101010

t

Adr.


Spannungs-Pegel auf den Bus-leitungen in Abhängigkeit der Zeit.

Wert am Adress-Bus wähltdie Speicherzelle aus, aus derdie Daten gelesen werden.

tschreiben

10

10

10

10

Bit 3

Bit 2

Bit 1

Bit 0

0000

0001

0010

0011

0100

0101

0110

0111

1000

1001

1010

1011

11001101

1110

1111

10

10

10

10

Bit 3

Bit 2

Bit 1

Bit 0

10

10

Lesen

Schreiben

Adress-Bus:

Steuer-Bus:Prozessor legtAdresse 0110auf den Adress-Bus, hält denDatenbus hoch-ohmig und gibtauf der LeitungLesen eine fal-lende Flankeaus. Damit zeigter, dass dieAdresse jetzt gültig ist und sofort gelesenwerden soll.

8

2

4

3

7

5

6

01101

9

9

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).

1-53

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.

Bus

Daten-Bus:

0110

101041

t


Pegel auf den Busleitungenin Abhängigkeit der Zeit.

Am Bus angeschlossene Ge-räte überprüfen die Adresseund übernehmen ggf. die Daten.

tschreiben

10

10

10

10

Bit 3

Bit 2

Bit 1

Bit 0

10

10

10

10

Bit 3

Bit 2

Bit 1

Bit 0

10

10

Lesen

Schreiben

Adress-Bus:

Steuer-Bus:

Prozessor schreibtDaten 1010 andie Adresse 0110und gibt an derLeitung „Schrei-ben“ eine fal-lende Flankeaus.

5

2

11

10

Adresse ==meine?

Gerät 1

ja nein

7

8

Adresse ==meine?

Gerät 2

ja nein

1010

7

9

12

Adresse ==meine?

Gerät 3

ja nein

7

8

Adresse ==meine?

Gerät 4

ja nein

7

81010

30110

6

1010

30110

6

1010

30110

6

1010

30110

6

Abb. 72: 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).

1-54

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:

Bus

Daten-Bus:

0110

1010121

t


Pegel auf den Busleitungenin Abhängigkeit der Zeit.

Am Bus angeschlossene Ge-räte überprüfen die Adresseund legen ggf. die Daten aufden Bus.

10

10

10

10

Bit 3

Bit 2

Bit 1

Bit 0

10

10

10

10

Bit 3

Bit 2

Bit 1

Bit 0

Lesen

Schreiben

Adress-Bus:

Steuer-Bus:

Prozessor liestDaten aus derSpeicherstelle0110 eines ex-ternen Gerätsein.

10

2

7

Adresse ==meine?

Gerät 1

ja nein

4

5

Adresse ==meine?

Gerät 2

ja nein

1010

4

6

Adresse ==meine?

Gerät 3

ja nein

4

5

Adresse ==meine?

Gerät 4

ja nein

4

5

30110

30110

1010

30110

9

30110

10

10

8 11

11

Abb. 73: 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).

1-55

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

Steuerwerk/Leitwerk

Rechenwerk/ALU


c:\>

Arbeitsspeicher

Prozessor (CPU)

Bus

Peripherie:

Festplatte

Diskettenlaufwerk

Bildschirm

Tastatur

CD-/DVD-Laufwerk

Bios-Programm(Flash)

LAN, USB, FireWire

Bios-Daten(batteriegepuffert)in enthalten•

••

••

•

•

•

•

•

BR:

DR

DB

C1

FP

DL

C9

C

A

B4

GK

D5

Abb. 74: 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 Controller 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.

1-56

! Die Peripherie dient zur Ein- und Ausgabe von Daten + 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. Da es wesentlich günstiger8 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.

1-57

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. 74 auf Seite 1-55 gezeigten stark vereinfachten Rechner-Architektur. Die Unterschiede sind klar erkennbar: In unserem vereinfachten Modell (Abb. 74) 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. 75 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 spezifischen FSB-Protokoll9 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...

1-58

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

B

DDR-RAM

AGP-Port

C

Gigabit-Ethernet-Controller

Anschlüssefür USB 2.0

2 Anschlüssefür Serial-ATA

2 Anschlüssefür ATA 100

Audio-CodecAC `97 3

Takt-GeneratorCPU, PCI, …

SMBus 2.0/I2C-Bus

D

Anschluss Dis-ketten-Laufwerk

PS/2 AnschlussTastatur

PS/2 AnschlussMaus

Anschluss fürseriellen Port

Anschluss fürparallelen Port

Anschluss fürVentilator

Prozessor-Bus, 4$200 MHz(FSB = Front Side Bus)

HI = Hub Interface266 MByte/s

Kanal A3,2 GyteB/s

Kanal B3,2 GByte/s

PCI-Bus133 MByte/s

2,1 GByte/s

266 MByte/s

480 MBit/s

150 MByte/s

100 MByte/s

100 MBit/s

LPC-Interface(Low Pin Count)

Analoger VGA-Anschluss

Festplatte

DVD-ROM

DVD-Brenner

6 PCI-Slots

DDR-RAM

DDR-RAM

DDR-RAM

Grafikkarte

TFT-Bildschirm

DVIB1

B2

B3

B4

C1

C2

B4

B4

B4

C3

C4

C6

C7

FS

HI

D1

D2

D3

D4

D5

D6

Disketten-Laufwerk

Tastatur

Maus

FireWire-Adapter

GK

FP

DR

DB

FW

DL

Netzteil

NT

230 V ~

Ethernet-Controller

USB2.0-Controller

Intel 82801EBICH5

2 SATA-Controller

ATA 100Controller

AC `97Controller

PCI-Controller

LPC-interfaceController

CMOS-RAM

System-Managmnt.

Bios-interf.Controller Flash-Bios

SMBusController

SuperInput/Output

Controller

RS 232Controller

LPTController

FloppyController

TastaturController

MausController

Drehzahl-regelung

LAN-Anschluss

LA

1 GBit/s

Intel 82865GGMCH

HI Controller

CSA-Controller

DDR-RAMController

AGP-Controller

Grafik-Controller

FSB Logik/Treiber

ProzessorIntel P4

Befehls-Cache

Daten-Cache

Adress-Umsetzer

Rechen-Werk

Steuer-Werk

C9

Batterie C8

Abb. 75: Architektur eines Computers

1-59

Im Folgenden sind die Funktionen der Haupt-Bridges stichpunktartig zusammengestellt. • GMCH = Graphics and Memory Controller10 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]) • ICH5 = Input/Output Controller Hub (5. Generation) (C)

! „Datenverteiler“ für mittel schnelle bis schnelle Geräte ! verfügt über diverse Ein- und Ausgabe-Controller, insbesondere für PCI11 und IDE12 ! 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 Cont-roller-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.

1-60

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 rennomierten ETH (Eidgenössische Technische Hochschule) Zürich bestand.13 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. 76: 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.

1-61

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 dar-auf 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.

1-62

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- undAusgabe

Steuerwerk/Leitwerk

Rechenwerk/ALU


c:\>

Prozessor

Abb. 77: 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:

3 5 7 2n 1

nx x x xsin x x ... ( 1) ...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.

1-63

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.

Da von Neumann auf eine Patentierung seiner Erweiterungen verzichtete14, 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.

1-64

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

Ein- undAusgabe

Steuerwerk/Leitwerk

Rechenwerk/ALU


c:\>

Prozessor

Speicher für Befehle

Abb. 78: 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-ler15 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 Harvard-Architektur für Embedded-Prozessoren16 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.

1-65

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.

Übersetzung durchden Menschen

Algorithmus-Ebene

Hochsprachen-Ebene

Assembler-Ebene

Übersetzungdurch Compiler

Befehlssatz-Ebene

Übersetzungdurch Assembler

Ebene der digitalen Logik

Interpretation oderdirekte Ausführungdurch die Hardware

Steuerung

Mikroarchitektur-Ebene

*.asm

*.obj

*.exe

*.asm

*.obj

LinkerLinker

Mikro-programm

Gatter/Hardware

*.c *.c

Assem-bler

Com-piler

Hardware-Steuerung

Elektr.Signale

Inter-pretation

Bei

m E

ntw

urf

Zur

Lauf

zeit

i = n, x = 0

i > 0

x = x + aibii = i – 1

Biblio-thek*.obj

Problemlösungin Algorithmus-Form

Problemlösungin Hochsprache(z.B. C)

Maschinen-nahe Form derProblemlösung

Maschinencodeder Problem-lösung

Aufbau desProblemlösers(Rechner/Pro-zessor) ausSpeicher, ALU …

Aufbau vonSpeicher, ALU..aus Logik-Gattern

Gru

ndl.

d. In

form

atik

Com

pute

rtec

hnik

/Com

pute

rsys

tem

e

Transistor-Ebene

Layout-Ebene

Transistoren

Halbleiter-Strukturen

Aufbau vonLogik-Gatternaus Tran-sistoren

Aufbau vonTransistorenaus n- und p-Schichten

Inte

gr. S

chal

tung

en

Abb. 79: Abstraktionsebenen

1-66

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

1

21 2 n 1 1 2 2 n n

n

b

bx [a a a ] a b a b a b

b

¯¡ °¡ °¡ °= ¸ = + + +¡ °¡ °¡ °¡ °¡ °¢ ±

" "#

Abb. 80: Formel zur Berechnung eines Skalarprodukts

oder Diagramme.

i = n, x = 0i > 0

x = x + aibii = i – 1

Abb. 81: 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. 80 darge-stellten Buchstaben, Zahlen (Indices) und Symbole interpretieren muss und zusätzlich über die Infor-mation verfügen, dass die in Abb. 80 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.

*.c *.c

i = n, x = 0i > 0

x = x + aibii = i – 1

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

1-67

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. 79, der in *.c-Dateien abgespeicherten C-Quellcode in Assembler-Code übersetzt.

*.asm *.asm

*.c *.c

Compiler

Abb. 83: 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.

1-68

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 = LDO z,v,w z = <v + w> MUL y,y,z y = * <v + w> ADD x,x,y x = x + * <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. 79 entnommene Darstellung verdeutlicht diesen Vorgang.

*.asm

*.obj

*.exe

*.asm

*.obj

LinkerLinker

Assem-bler

Biblio-thek*.obj

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

1-69

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. 79 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. Im Gegensatz dazu beschäftigt sich der in Abb. 79 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.

1-70

Lesen $Y

Schreiben/Lesen $X

Schreib-Daten $X

Lese-Daten $Z

Lese-Daten $Y

Registerblock

0..7

8..15

DatenALU

64

BZ64

Adresse

Add64

4

64

64

640

1

64

64

64

64

Daten-Speicher

Adr.

Schreib-Daten

Lese-Daten

32

16..23 Lese-Daten $X

64

ALU-Funktion

Ergebnisauswahl

Steuerung

8

BZ übernehmen

Lesen $Z

Befehls-Speicher

24..31

Abb. 85: 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.

Q0

Q1

Q2

Q63

D0

D1

D2

D63

BZ

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

1-71

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. 87: 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:

Ausgang

VDD

Eingang 1

Eingang 2

GND

Abb. 88: 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.

2-1

2 Assembler- und Befehlssatz-Ebene

2.1 Rechnerarchitektur auf Assembler- und Befehlssatz-Ebene

Die Assembler- und Befehlssatz-Ebene bildet die Schnittstelle zwischen Hard- und Software. Programme, die in Hochsprachen (wie z.B. „C“) geschrieben wurden, werden vom Compiler in As-sembler-Befehle übersetzt.17 Programme können aber auch direkt in Assembler-Sprache geschrieben werden, wie wir noch sehen werden. Programme in Assembler-Sprache lassen sich mit einem sog. Assembler in „Nullen und Einsen“ über-setzen, die dann in einer Objektdatei abgelegt werden. Diese „Nullen und Einsen“ sind die Schnittstel-le zwischen Hard- und Software: Sie werden aus Assembler-Befehlen erzeugt, im Speicher abgelegt und dann bei der Ausführung von der Hardware interpretiert. Im Folgenden ist nocheinmal die im vorigen Kapitel kennengelernte Rechner-Architektur abgebildet.

Daten-Speicher Befehls-Speicher

Ein- undAusgabe

Steuerwerk/Leitwerk

Rechenwerk/ALU

Registerc:\>

Prozessor

Abb. 89: Rechner-Architektur

Wie sieht diese Architektur auf Assembler- und Befehlssatzebene aus? Da die eben erwähnten „Nullen und Einsen“ die Schnittstelle zwischen Hard- und Software darstellen, befinden sich die Assembler-Befehle, um die sich dieses Kapitel dreht, noch eine Ebene über der Hardware (vgl. Abb. 79), also in der Software. Auf der Assembler- und Befehlssatz-Ebene sieht man also nicht direkt die Hardware (Abb. 89), sondern die Anweisungen, die nötig sind, um die Hardware zu benutzen. Es gibt dabei drei verschiedene Arten von Anweisungen, die in Programmen zusam-mengefasst werden: Anweisungen für den Prozessor, Anweisungen für den Assembler und Anwei-sungen für den Loader.

17 Oft erzeugen Compiler auch direkt die „Nullen und Einsen“ der Objektdatei (s.u.). Der Schritt der Assemblierung wird dabei oft vom Compiler mit übernommen.

2-2

2.2 Programme

Programme bestehen aus Anweisungen für den Prozessor, Anweisungen für den Assembler und Answeisungen für den Loader. 2.2.1 Anweisungen für den Prozessor Prozessor-Anweisungen sind Befehle, die direkt vom Prozessor ausgeführt werden. Im Gegensatz zu Befehlen einer Hochsprache wie z.B. C beziehen sie sich immer direkt auf die im Prozessor verfügba-ren Ressourcen, sind also Anweisungen, um beispielsweise einen Wert von einer bestimmten Adres-se im Daten-Speicher in ein bestimmtes Register zu laden (z.B. LOAD R1,0x1234568) oder um zwei in bestimmten Registern stehenden Werte dem Rechenwerk zu übergeben, dort zu addieren und das Ergebnis dann wieder in einem bestimmten Register abzulegen (z.B. ADD R2,R3,R4). • Befehlssatz Welche Befehle ein Prozessor ausführen kann, ist im Befehlssatz festgelegt. Der Befehlssatz ist dabei nichts anderes als eine Liste, in der

! alle Befehle des betreffenden Prozessors stehen

! für jeden Befehl erklärt wird, was dieser Befehl eigentlich macht (z.B. zwei Zahlen addieren)

! angegeben ist, welche Operanden mit dem Befehl verwendet werden können + z.B.: drei Register (zwei als Quelle, einer als Ziel) + z.B.: zwei Register (ein Register ist sowohl Quelle als auch Ziel) + z.B.: ein Register und eine Speicher-Adresse + …

! angegeben ist, wie die angegebenen Operanden vom Befehl verwendet werden

+ z.B.: in den Registern stehen direkt die Werte, die addiert werden + z.B.: in den Registern stehen Arbeitsspeicheradressen; die Werte die addiert werden sollen,

liegen dann im Speicher an dieser Adresse + …

Befehle eines Befehlssatzes lassen sich im Allgemeinen in folgende Kategorien einteilen:

! Arithmetische Befehle + Grundrechenarten (Addition, Subtraktion, Multiplikation, Division) für Integer-Werte + Grundrechenarten für Gleitkomma-Werte + Links- und Rechts-Schieben + …

! Sprungbefehle (Befehle zur Steuerung des Kontrollflusses)

+ Bedingte Sprünge

• Sprung hängt von einer Bedingung ab, z.B. „springe, wenn Wert in Register $1 Null ist“ ! Realisierung von if…then…else-Konstrukten ! Realisierung von Schleifen

+ Unbedingte Sprünge

• es wird immer gesprungen, unabhängig von einer Bedingung ! Programmverzweigung ! Aufruf von Funktionen

2-3

! Befehle für Speicherzugriffe + Laden von Daten aus dem Speicher in ein Register oder direktes Weiterleiten von Daten

aus dem Speicher an das Rechenwerk + Abspeichern von Daten aus einem Register in den Arbeitsspeicher oder direktes Schreiben

eines Rechenwerk-Ergebnisses in den Arbeitsspeicher

+ Die gesamte Kommunikation des Prozessors mit den Ein- und Ausgabegeräten (z.B. Fest-platte, CD-ROM, Tastatur etc.) wird in der Regel über Speicherzugriffe realisiert

• Ein- und Ausgabegeräten werden in einen bestimmten Speicherbereich des Prozessors eingeblendet

• Schreibzugriffe auf diese Speicheradresse landen dann bei dem jeweiligen Gerät • Lesezugriffe auf diese Speicheradressen lesen dann vom jeweiligen Gerät Daten ein

• Register Ein Register ist ein spezieller, sehr schneller Datenspeicher, der genau ein Wort18 abspeichern kann und direkt im Prozessor untergebracht ist. Prozessoren verfügen in der Regel über mehrere Register, die im sog. Registerblock (engl. register file) zusammengefasst sind. Man unterscheidet generell zwei Arten von Registern:

! Allzweckregister (engl. General Purpose Register, GPR) + werden zum Zwischenspeichern von Variablen verwendet + können vom Programmierer beliebig verwendet werden

• als Quelloperanden für beliebige Befehle • als Zieloperanden für beliebige Befehle

+ Beim Befehl ADD $1,$2,$3 werden beispielsweise • die Werte, die in den Registern $2 und $3 stehen, addiert und • das Ergebnis im Register $1 abgelegt

! Spezialregister (engl. Special Purpose Register, SPR) + haben eine besondere, an die Hardware angepasste Funktion + können vom Programmierer nur im Zusammenhang mit dieser speziellen Funktion genutzt

werden + werden oft dazu verwendet, um

• im Prozessor bestimmte Abläufe zu steuern (im Befehlszähler-Register steht beispiels-weise immer die Adresse, von der der nächste Befehl geholt werden soll)

• bestimmte Einstellungen an der Hardware vorzunehmen (z.B. Festlegung der Übertra-gungsgeschwindigkeit der seriellen Schnittstelle eines Mikrocontrollers)

+ können oft nur von bestimmten Befehlen gelesen oder geschrieben werden • Spezialregister können also in der Regel nicht als Operanden für Prozessor-

Anweisungen wie ADD etc. verwendet werden Register werden in Prozessoranweisungen als Operanden verwendet und bei der Programmierung in Assembler-Code direkt angegeben. Dazu werden oft Buchstaben (zur Kennzeichnung eines bestimm-ten Registertyps) mit Zahlen (zur Kennzeichnung des Registers) kombiniert.

! für Allzweckregister wird oft $0, $1, $2, … oder R0, R1, R2, … oder EAX, EBX, ECX, … ge-schrieben, um die Allzweckregister mit der Nummer 0, 1, 2… zu bezeichnen

18 Ein Wort ist die Verallgemeinerung eines Bytes: Während ein Byte immer genau aus 8 Bit besteht, ist die Anzahl der Bits, die ein Wort bilden, nicht festgelegt. Ein Wort wird oft für verschiedene Prozessoren unterschiedlich definiert und entspricht in der Regel der Anzahl der Bits, die (der gerade betrachtete) Prozessor gleichzeitig verarbeiten kann. Kann ein Prozessor 8 Bit gleichzeitig verarbeiten, spricht man von einer 8 Bit Wortbreite. Dementsprechend spricht man von einem Prozessor mit 32 Bit Wortbreite, wenn 32 Bits gleichzeitig verarbeitet werden können. Bei einem 32 Bit-Prozessor umfasst ein Halbwort somit 16 Bits und ein Doppelwort (DWORD) 64 Bits.

2-4

! für Spezialregister wird of rA, rB, rC, … oder CR0, CR1, CR2, … (CR für „Control Register“) ver-wendet, oft werden aber auch bestimmte Namen wie z.B. IDTR für „Interrupt Descriptor Table Register“ verwendet

Unabhängig vom Typ des jeweiligen Registers können Registern bei der Programmierung benutzerde-finierte Namen zugewiesen werden, was dem Programmierer die Arbeit enorm vereinfachen kann. So lässt sich beispielsweise über einen geeigneten Befehl vereinbaren, dass Register $0 auch über den Namen Ergebnis angesprochen werden kann. Der Programmierer weiß dann immer gleich, was er ursprünglich mit dem Register $0 vorhatte. • Arbeitsspeicher Der Arbeitsspeicher ist ein wesentlich langsamerer Speicher als es die Register sind, dafür lässt er sich wesentlich günstiger herstellen. Aufgrund des sehr günstigen Preis-Leistungs-Verhältnisses ver-fügen Computersysteme über Arbeitsspeicher, dessen Speicherkapazität die von Registern in der Regel um mehrere Grössenordnungen übertrifft. Aktuelle Arbeitsspeicher sind in der Regel byteadressierbar, d.h. die kleinste adressierbare Einheit ist ein Byte, also 8 Bit. Auf Assembler- und Befehlssatz-Ebene kann man sich den Arbeitsspeicher als Tabelle vorstellen: In jeder Tabellenzeile kann ein einzelnes Byte gespeichert werden, die Adresse19 des Bytes entspricht dabei der laufenden Nummer der Tabellenzeile.

Adresse Inhalt

0x0……01 0x120x0……02 0x340x0……03 0x56 jeweils 1 Byte0x0……04 0x780x0……05 0x90 #0x0……060x0……070x0……080x0……090x0……0A

# #

0xF……FE0xF……FF

Bei Zugriffen auf den Speicher zum Lesen oder Schreiben muss man dem Speicher mitteilen, auf welche Speicherzellen zugegriffen werden soll. Der Speicher muss dazu adressiert werden, d.h. es muss eine Adresse an den Speicher angelegt werden. Auf Assembler- bzw. Befehlssatz-Ebene gibt es mehrere Möglichkeiten, Speicher zu adressieren. Diese werden unter dem Begriff Adressierungsarten zusammengefasst.

19 Es ist üblich, die Adresse hexadezimal, also zur Basis 16 anzugeben, da dann eine einfache Umwandlung in Binärzahlen (Basis 2) möglich ist (1 Stelle in der Basis 16 ergibt dann immer genau 4 Stellen in der Basis 2).

2-5

Allgemein unterscheidet man u.a. folgende Adressierungsarten:

! … ! …

Diese Adressierungsarten funktionieren für beliebige Wortbreiten, also sowohl für 8 Bit-, für 16 Bit-, für 32 Bit-, für 64 Bit-Zahlen usw.

! Abspeichern einzelner Byte + jedem Byte wird eine 8 Bit-Speicherzelle zugewiesen + Elemente eines Byte-Arrays werden einfach hintereinander im Speicher abgelegt + Beispiel: char Vorlesung[] = ƎComputertechnikƎ;

• als 1. Byte wird der ASCII-Wert des Buchstabens ƍCƍ, also 0x43 im Speicher abgelegt • als 2. Byte wird der ASCII-Wert des Buchstabens ƍoƍ, also 0x6F im Speicher abgelegt • …

! Abspeichern von aus mehreren Byte zusammengesetzten Worten + 32 Bit Wort besteht aus 4 Byte + Beispiel: int Jahr = 2005;

• Jahr wird als 32 Bit Wert 0x000007D5 abgespeichert • 32 Bit Wert besteht aus den vier Byte 0x00, 0x00, 0x07 und 0xD5 • In welcher Reihenfolge sollen diese vier Byte jetzt im Speicher abgelegt werden? • ĺ 2 gängige Formate: Big-Endian und Little-Endian

+ Big Endian Format

• z.B. beim MMIX-Prozessor oder bei Motorola • Abspeichern von aus mehreren Byte zusammengesetzten Worten in der Weise, dass

das höherwertigste Byte (also das Byte ganz links) adressiert wird

+ Little Endian Format • z.B. bei Intel-Prozessoren • Abspeichern von aus mehreren Byte zusammengesetzten Worten in der Weise, dass

das niederwertigste Byte (also das Byte ganz rechts) adressiert wird

• Beispiel: char Vorlesung[] = ƎComputertechnikƎ; int Jahr = 2004;

ƍCƍƍoƍƍmƍ

ƍkƍƍ\0ƍ0x000x000x070xD4

2004

Computertechnik

DatenBig Endian

DatenLittle Endian

ƍCƍƍoƍƍmƍ

ƍkƍƍ\0ƍ0xD40x070x000x00

0x000x010x02

0x0E0x0F0x100x110x120x13

Adresse

Abb. 90: Little- und Big-Endian Format

2-6

+ Problem beim Datenaustausch zwischen Big- und Little-Endian Rechnern • Kopieren der Daten � Reihenfolge der einzelnen Byte wird beibehalten • Bei Byte-Array (char Vorlesung[] = ƎComputertechnikƎ;) kein Problem • Bei aus mehreren Byte zusammengesetzten Worten (int Jahr = 2004;) sind die

Byte auf dem Zielrechner in der falschen Reihenfolge • Vorlesung[] hat weiterhin den Wert ƎComputertechnikƎ • Jahr hat jetzt den Wert -737738752 • sinnvolles Kopieren nur dann möglich, wenn beim Kopieren bekannt ist, ob gerade das

Byte eines aus mehreren Byte zusammengesetzten Wortes kopiert wird oder nicht und aus wievielen Byte das zusammengesetzte Wort besteht

2.2.2 Anweisungen für den Assembler Der Assembler ist das Programm, das Assembler-Programme in „Nullen und Einsen“ übersetzt und diese in einer Objektdatei ablegt. Anweisungen für den Assembler sind solche Befehle, die nicht direkt vom Prozessor ausgeführt werden. Assembler Befehle werden

! entweder direkt vom Assembler verarbeitet

+ Beispiele hierfür ist die Angabe von Marken, an die während der Programmausführung hin-gesprungen werden kann

SUB $1,$2,$3 Reg. $3 von $2 abziehen, Erg. nach $1

BZ $1,Ziel Nach Ziel springen, wenn $1 = 0, sonst mit nächster Zeile weitermachen DIV $5,$3,$1 Division Ziel ADD $2,$3,$4 wird in beiden Fällen ausgeführt

+ diese Marken sind nicht Teil des Befehlssatzes, der vom Prozessor verarbeitet wird + die Marken werden während der Assemblierung (also während des Übersetzens in „Nullen

und Einsen“) in echte Adressen übersetzt + im Befehlswort stehen dann die echten Adressen, nicht die Marken

! oder als Loader-Befehle mit in die Objektdatei geschrieben, um dann beim Laden des Pro-gramms vom Loader (derjenige Betriebssystem-Teil, der Programme, die ausgeführt werden sollen, in den Arbeitsspeicher lädt und initialisiert) interpretiert und ausgeführt zu werden.

2.2.3 Anweisungen für den Loader Loader-Befehle sind in der Objektdatei enthaltene Anweisungen, die den Loader (s.o.) beim Laden des Programms in den Arbeitsspeicher unterstützen. Beispiele hierfür sind Anweisungen, die

! beim Laden des Programms in den Arbeitsspeicher dem Loader sagen, an welche Stelle das Programm geladen werden soll

! vor dem Start des auszuführenden Programms vom Betriebssystem Speicher für globale und

statische Variable allozieren (reservieren) und diesen dann mit den zugehörigen Werten initiali-sieren

Die Loader-Befehle werden vom Betriebssystem interpretiert. Als Folge führt das Betriebssystem dann bestimmte Prozessor-Befehle aus, die die Funktion der Loader-Befehle implementieren.

2-7

2.3 Klassifizierung von Befehlssätzen

In diesem Kapitel werden verschiedene Möglichkeiten angegeben, wie Befehlssätze klassifiziert wer-den können. Als Beispiel wird dabei stehts folgende Addition verwendet:

A = B + C

Quelloperanden

Zieloperand Operation

2.3.1 Klassifizierung nach der Anzahl der Operanden • Dreiadressmaschine

! die Maschinenbefehle sind so ausgelegt, dass alle drei Operanden explizit angegeben werden können

! Beispiel: ADD $1,$2,$3 " Addiere die Werte, die in Register $2 und $3 stehen und lege das Ergebnis in Register $1 ab

• Zweiadressmaschine

! es können immer nur zwei Operanden explizit angegeben werden ! der Zieloperand entspricht immer dem ersten Quelloperanden ! Beispiel: ADD $1,$2 " Addiere die Werte, die in Register $1 und $2 stehen und lege das Er-

gebnis in Register $1 ab • Einadressmaschine

! es kann immer nur ein Operand explizit angegeben werden ! als Zieloperand und als einer der beiden Quelloperanden wird implizit immer ein sog. Akkumula-

tor-Register verwendet ! der zweite Quelloperand kann explizit angegeben werden und kann entweder ein Register oder

eine Arbeitsspeicheradresse sein ! Beispiel: ADD $1 " Addiere zum Akkumulator den Wert, der in Register $1 steht

• Nulladressmaschine

! es kann kein Operand explizit angegeben werden ! Beispiel: ADD " Addiere die beiden Werte, die auf dem Stack liegen und lege das Ergebnis

wieder auf dem Stack ab

2-8

2.3.2 Klassifizierung nach der Bereitstellung der Operanden • Register-Register-Architektur (Load-Store-Architektur)

! bei der Ausführung von Rechenoperationen befinden sich sowohl die beiden Quell-Operanden als auch der Ziel-Operand stets in Registern

! auf den Arbeitsspeicher kann nur mit speziellen Lade- und Speicherbefehlen zugegriffen wer-den, d.h. es gibt z.B. keine arithmetischen Befehle, die als Operanden Arbeitspeicher-Adressen aufnehmen können � Load-Store-Architektur

! Berechnung von A = B + C (vgl. auch nachfolgende Abbildung)

Load $2,b Einlesen des Operanden B vom Arbeitsspeicher in Register $2 (1). b ist

hierbei als diejenige Adresse anzusehen, an der der Wert des Operan-den B steht, d.h. B == 

Load $3,c Einlesen des Operanden C vom Arbeitsspeicher in Register $3 (2) Add $1,$2,$3 Register $2 und $3 addieren, Ergebnis in Register $1 ablegen (3) Store $1,a Register $1 im Arbeitsspeicher an Adresse a ablegen (4), wobei a ana-

log zu vorher der Adresse von A entspricht

Arbeits-speicher1

2

3 3

3

4

3

Register-Block

Abb. 91: Register-Register-Architektur

! soll das Ergebnis weiterverwendet werden, so kann es in Register $1 verbleiben und von dort

aus direkt als Quell-Operand verwendet werden � man spart sich langsame Speicherzugriffe ! wenn B und C weiterverwendet werden, müssen sie nicht erneut aus dem Arbeitsspeicher gela-

den werden, da sie sich bereits in Registern befinden � Zeitvorteil

! � je mehr Register ein Prozessor hat, desto seltener müssen Zugriffe auf den langsamen Ar-beitsspeicher durchgeführt werden!

! da im Beispiel-Code für den Add-Befehl drei verschiedene Operanden angegeben werden kön-

nen, spricht man hier auch von einer Dreiadress-Maschine, wobei der Begriff Dreiadress-Maschine nicht auf Register-Register-Architekturen beschränkt ist

2-9

• Register-Speicher-Architektur

! bei der Ausführung von Rechenoperationen befindet sich mindestens einer der Operanden im Arbeitsspeicher

! Beispielhafter Ablauf der Berechnung A = B + C (vgl. nachfolgende Abbildung)

Load $1,b Einlesen des Operanden B vom Arbeitsspeicher (B steht an Adresse b) in

Register $1 (1) Add $1,c Addieren von C (Wert an Adresse c im Arbeitsspeicher) zum Operanden B,

also zum Register $1 � Ergebnis steht dann auch in Register $1 (2) Store $1,a Abspeichern des Ergebnisses aus Register $1 in den Arbeitsspeicher an die

Adresse a (3)

Arbeits-speicher

2

2

1

2

Register-Block

3

2

Abb. 92: Register-Speicher-Architektur

! Vorteile gegenüber Register-Register-Architektur

+ weniger Load- und Store-Befehle notwendig20 • � weniger Zugriffe auf den Befehls-Speicher • � Programm wird kürzer und benötigt weniger Speicherplatz

! Nachteile gegenüber Register-Register-Architektur

+ soll das Ergebnis hier weiterverwendet werden, muss es erst wieder aus dem langsamen Arbeitsspeicher geladen werden

! müssen zur Durchführung von Operationen nur zwei Operanden angegeben werden (in obigem

Beispiel-Code dient bei der Addition $1 sowohl als erster Quelloperand als auch als Zielope-rand), spricht man von einer Zweiadress-Maschine, wobei dieser Begriff nicht auf Register-Speicher-Architekturen beschränkt ist

20 Ist in Bezug auf die Ausführungsgeschwindigkeit kein echter Vorteil: Zeitintensive Befehle sind immer Befehle, die auf den Speicher zugreifen, da dieser in der Regel wesentlich langsamer ist als die Register. Ob der Speicherzugriff jetzt explizit durch einen Load-Befehl durchgeführt wird oder implizit durch bspw. einen ADD-Befehl, ist egal. Speicherzugriff bleibt Speicher-zugriff. Wesentlich mehr fällt hingegen ins Gewicht, dass bei einem Zugriff auf das Ergebnis dieses wieder aus dem Speicher geladen werden muss und nicht bereits in einem Register steht � Nachteil überwiegt.

2-10

• Akkumulator-Architektur

! Bei der Ausführung von Rechenoperationen befindet sich stets ein Operand im sog. Akkumula-tor-Register, weswegen dieser Operand nicht mehr adressiert werden muss

! � es muss nur noch ein weiterer Operand angegeben werden � Einadress-Maschine

! Ablauf der Befehlsausführung für A = B + C (vgl. nachfolgende Abbildung)

Load b Einlesen des Operanden B in das Akkumulator-Register (Datum B steht wieder an Adresse b) (1)

Add c Hinzuaddieren des Operanden C zum Akkumulator-Register � Ergebnis steht wieder im Akkumulator-Register (2)

Store a Akkumulator-Register in den Arbeitsspeicher an die Adresse a schreiben (3)

Arbeits-speicher2

Akkumulator-Register

22

2

13

Abb. 93: Akkumulator-Architektur

• Stack-Architektur

! 2 Register, die als Stack verwendet werden ! da im Voraus bekannt ist, welche Register als Quell- bzw. Zieloperand dienen, muss zur Be-

fehlsausführung (ausser zum Laden und Speichern) kein Operand angegeben werden ! � Nulladress-Maschine

! Ablauf der Befehlsausführung von A = B + C (vgl. nachfolgende Abbildung)

Push b Ablegen von B auf dem Stack (1) Push c Ablegen von C auf dem Stack (2) Add Register addieren, Ergebnis in Register $1 ablegen(3) Pop a Abspeichern des Ergebnisses (Register $1) an die Adresse a (4)

Arbeits-speicher

Register 1

2Register 2

1

3

3

3

3 4

Abb. 94: Stack-Architektur

2-11

2.3.3 Klassifizierung nach der Mächtigkeit der einzelnen Befehle • CISC-Architektur

! CISC " Complex Instruction Set Computer ! veraltetes Prozessor-Design

! Idee: für jede benötigte Aufgabe gibt es einen speziellen Maschinenbefehl

+ sehr viele, mächtige Maschinenbefehle + Funktionalität der Maschinenbefehle ähnlich der von Hochsprachen-Befehlen + viele Adressierungsmodi

! Vorteile

+ Hochsprachen-ähnliche Befehle � einfache Programmierung (Compiler damals sehr schlecht, wenn überhaupt vorhanden)

+ mächtige Befehle � geringe Programmgrösse � grosser Vorteil, da Speicher damals sehr teuer und langsam

! Nachteile

+ viele Befehle mit unterschiedlicher Länge des Befehlsworts � kaum Fliessbandverarbeitung (Pipelining) möglich

+ wenige, dafür sehr lange Taktzyklen pro Befehl � Befehle, die eigentlich in einem Bruchteil eines Taktzyklusses durchführbar wären, werden ausgebremst (allgemein kann pro Takt-zyklus maximal ein Befehl ausgeführt werden)

• RISC-Architektur

! RISC " Reduced Instruction Set Computer ! Heutzutage vorherrschendes Prozessor-Design

! Vorgeschichte: Quantitative Analyse der in Programmen verwendeten Befehle

+ Analyse, welche Befehle in Programmen wie oft (� quantitativ) benötigt werden + Ergebnisse

• es gibt ein paar wenige Befehle, die überproportional häufig verwendet werden • gerade die sehr oft vorkommenden Befehle sind sehr einfacher Natur • die extra für aufwendige Berechnungen eingefügten Spezial-Befehle werden fast nie

verwendet + Beispiel:

Rang Befehlstyp Anteil %

1 Datum aus dem Arbeitsspeicher laden (load) 22 %

2 Bedingte Verzweigung (conditional branch) 20 %

3 Vergleich (compare) 16%

4 Datum in den Arbeitsspeicher übertragen (store) 12 %

5 Addition (add) 8 %

6 UND-Verknüpfung (and) 6 %

7 Subtraktion (sub) 5 %

8 Datum von Register nach Register kopieren (move) 4 %

9 Funktionsaufruf (call) 1 %

10 Rücksprung (return) 1 %

Summe: 95 %

2-12

! Idee: Quantitativer Ansatz21 + Befehlssatz auf die in der Analyse (s.o.) häufig vorkommenden Befehle beschränken + � Befehlssatz mit wenigen und sehr einfachen Befehlen + zur Lösung komplexerer Probleme einfach mehrere einfache Befehle verwenden � Bau-

kasten-Prinzip (zuvor bei CISC: komplexes Problem ĺ ein sehr mächtiger Befehl) + � Auslagerung der Lösung komplexerer Probleme von der Hardware in den Compiler (in

die Software)

! Vorteile

+ Baukastenprinzip � Verlagerung von Befehls-Optimierungen von der Hardware in die Soft-ware

• Compiler-Technologie mittlerweile besser � Programmierer schreibt Programm mit we-nigen Hochsprachen-Befehlen und der Compiler übersetzt diese Befehle dann in viele, dafür sehr schnelle Maschinen-Befehle

• wenn neue, verbesserte Algorithmen für die Lösung eines Problems gefunden werden, muss nicht mehr die Implementierung des komplexen CISC-Befehls im Prozessor ge-ändert werden, sondern lediglich der Compiler (Software ist wesentlich einfacher änder-bar als Hardware!)

+ wenige, sehr einfache Befehle

• Steigerung der Zuverlässigkeit des Chips, da weniger Fehlerquellen (damals sehr wich-tig)

• einheitliches Befehlsformat, insbesondere konstante Befehlslänge möglich ! ermöglicht sehr einfache Hardware, da alle Befehle sehr ähnlich behandelt werden ! einfache Hardware � mehr Spielraum für Parallelverarbeitung ! einfache Realisierung der Fliessbandverarbeitung

• alle Befehle zeitlich ungefähr gleich lang ! kein Zeitverlust durch Warten auf komplexe, langsame Befehle ! hoher Gewinn bei der Fliessband-Verarbeitung

! Nachteile

• Höherer Speicherbedarf für das Programm • Programmgrösse jedoch immer weniger ausschlaggebend, da Speicher immer schneller

und billiger werden � Nachteil nicht so schlimm

! weitere wesentliche Merkmale + wenige Adressierungsarten (in der Regel Load-Store-Architektur) + viele Register � Reduzierung der Speicherzugriffe

21 vgl. Buch von Hennessy & Patterson: Computer Architecture – A Quantitative Approach

2-13

• VLIW-Architektur

! Name: VLIW " Very Long Instruction Word " Prozessor mit sehr langem Befehlswort

! Idee: RISC-Konzept auf Parallel-Verarbeitung übertragen

! Prozessor hat mehrere Ausführungseinheiten (AF), so dass er bspw. zwei Integer- und eine Gleitkomma-Operation gleichzeitig durchführen kann

! Compiler bzw. Assembler

+ gruppiert die in einem Programm vorhandenen sequentiellen Befehle so, dass möglichst immer alle Ausführungseinheiten (AE)22 Arbeit haben

+ fasst die gruppierten Befehle zu einem langen Befehlswort zusammen, dass dann vom Pro-zessor parallel ausgeführt wird

add $1,$2,$3fsub $10,$8,$7sub $5,$9,$4

0x200102030x060A08070x24050904

0x2001020324050904060A0807

Programm(mehrere Befehle)

übersetztes Programm(mehrere Befehlsworte)

1 langes Befehlswortfür VLIW-Architektur

AE 1(Int)

AE 2(Int)

AE 3(GK)

Prozessor mit 3Ausführungseinheiten (AF)(2 x Integer, 1 x Gleitkomma)

Abb. 95: VLIW-Konzept

! Vorteile + Optimierungen einfach durchführbar, da nur der Compiler/Assembler und nicht der Prozes-

sor geändert werden muss (vgl. RISC-Architektur) + keine grosse Zunahme der Prozessor-Komplexität, da viel Intelligenz im Compiler steckt

• Geschwindigkeitsvorteil bei der Programmausführung • Prozessor kann günstiger hergestellt werden

! Nachteile + Code muss neu übersetzt werden + Code-Kompatibilität geht verloren

22 Ausführungseinheit: Derjenige Teil eines Prozessors, der Berechnungen durchführt. VLIW-Architekturen verfügen über meh-rere Ausführungseinheiten, die parallel betrieben werden können.

2-14

2.3.4 Klassifizierung nach Orthogonalität Orthogonaler Befehlssatz " die einzelnen Befehle sind ihrer Funktionalität nach vollkommen disjunkt. Es gibt also keine Befehle, die sich in ihrer Funktionalität überlappen.

2.4 Performance auf Assembler- bzw. Befehlsatz-Ebene

2.4.1 Begriff "Performance"

! Performance = Leistung = ArbeitZeit

! Arbeit beim Computer: Programmausführung " Abarbeitung aller Befehle des Programms

! Zeit beim Computer: Programmausführungs-Zeit

! Leistungsvergleich meherer Systeme am einfachsten, wenn

! 1Arbeit = konst. Performance Programmausführungs-Zeit

� �

! (je schneller, desto besser) 2.4.2 Entstehung der Programmausführungs-Zeit

! Abbildung der Hochsprache auf Maschinen-Code + & " 1 Taktzyklus + µ " 1 Speicherzugriff

Hochsprache

Assembler-CodeLDO a,aref,0 Laden: a = <aref+0> ȝ+ȞADD buf,d,c Addition: buf = d + c ȞMUL buf,buf,a Multiplikation: buf = buf * a 10ȞSUB a,b,buf Subtraktion: a = b – buf ȞSTO a,aref,0 Speichern: <aref+0> = a ȝ+Ȟ

a = b – (d + c)*a

Maschinen-Code0x8D010600 " 10001101000000010000011000000000 ȝ+Ȟ0x20050403 " 00100000000001010000010000000011 Ȟ0x18050501 " 00011000000001010000010100000001 10Ȟ0x24010205 " 00100100000000010000001000000101 Ȟ0xAD010600 " 10101101000000010000011000000000 ȝ+Ȟ

Compiler

Assembler

2-15

i ialle Befehle i

Anzahl der Gesamtzyklen des Programms

Speicherzugriffszeit( CPI Befehlsanzahl ) Anzahl der Speicherzugriffe Zyklusdauer

Zyklusdauer$ + $ $

ª º« »ª º« »« »« »« »¬ ¼

¦��

! Programmausführungs-Zeit:

! CPI = Cylces per instruction " TaktzyklenBefehl

! Zyklusdauer

Zyklusdauer

Ȟ2Ȟ

Prozessortakt

2.4.3 Performance-Messung

! In der Regel relative Performance-Messung + Vergleich mehrerer Systeme + Bestimmung der Leistungserhöhung eines Systems nach einer Modifikation

! Selbes Programm auf mehreren Rechnern

+ Arbeit = konst. + Performance ~ Ausführungs-Geschwindigkeit

! Idealfall: Ein Benutzer, der immer nur dasselbe Programm verwendet + Ausführungszeit auf mehreren Systemen bestimmen + Schnellster Rechner ist für den Benutzer dann der Beste

! Realität: Viele Benutzer, die jeweils mehrere unterschiedliche Programme verwenden

! Unterschiedliche Beanspruchungen durch unterschiedliche Programme

+ Anzahl der Gleitkommaoperationen + Anzahl der Integeroperationen + Anzahl der Speicherzugriffe

sind in unterschiedlichen Programmen verschieden

! Benchmarks: Referenzprogramme, die das Mittel der verwendeten Programme möglichst gut repräsentieren sollen

! Einteilung von Benchmarks:

2-16

Benchmarks

Nicht synthetische(echte) Benchmarks

SynthetischeBenchmarks

Programme, die extra für die Verwendung als Benchmarkgeschrieben wurden.

Reale Programme, die als Benchmarkausgewählt wurden.

! Vorteil synthetischer Benchmarks: Kurze Codesequenzen möglich � Einfache Optimierung von Rechnerarchitektur und Compiler � Zu Design-Beginn (noch kein Compiler verfügbar) einfach per Hand codierbar

! Nachteil: Ausschliessliche Optimierung der in Benchmarks enthaltenen Befehlsfolgen führt auf-grund der geringen Benchmark-Länge zu einem hohen prozentualen Anteil der optimierten Be-fehle und somit zur Verzerrung der Leistungsdarstellung

! Arten der Programmausführungszeit

Start P1 BS P2 BS Ende P1BS BSP1 BS P1 BSBS

Antwortzeit

Benutzer-CPU-Zeit

Benutzer-CPU-Zeit + Betriebssystem (BS)-CPU-Zeit

+ Antwort-Zeit • Vom Benutzer wahrgenommene Zeit • Quasi-paralleler Ablauf von Programmen � keine Eignung zur Performance-

Bestimmung

+ Benutzer-CPU-Zeit • Nur ungenaue Messung der vom Betriebssystem verbrauchten Zeit möglich • Unterschiedliche Betriebssysteme � Messung unterschiedlicher Programmlängen �

Arbeit nicht konstant!

+ Benutzer-CPU-Zeit + Betriebssystem-CPU-Zeit • Vorteil: Zugehörigkeit von Programmteilen zum Betriebssystem z.T. schwer bewertbar

2-17

! Definition + System-Performance: Auf unbelastetem System vergangene Zeit + CPU-Performance: Benutzer-CPU-Zeit

! Zeitmessung

+ i i

alle Befehle i

Anzahl der Gesamtzyklen desProgramms

Ausführungs-Zeit eines Programms ( CPI Befehlsanzahl ) Zyklusdauer= $ $¦��

+ Parameterbestimmung

• Zyklusdauer: Dokumentation des Sytems (z.B. 2,4 GHz � Zyklusdauer = 12,4

ns)

• CPIi ! Befehlssatz des Prozessors � Dokumentation ! Problem: Nicht konstant bei Verwendung von Pipelining und Cache ! Abhilfe: Simulation, HW-Zähler

• Befehlsanzahli

! Software-Tools (Profiling) ! HW-Zähler auf CPU

! MIPS: Million instructions per second: Kein geeignetes Performance-Maß, da keine Aussage über die Mächtigkeit der Befehle gemacht wird (Arbeit unbekannt � Keine Aussage über die Leistung möglich)

! MFLOPS: Million floating point operations per second: Aus den 1970/80-er Jahren; Nachteil wie MIPS

2.4.4 Gesetz von Amdahl

! Erhöhung der Performance durch Verbesserung einer bestimmten Eigenschaft ist durch die An-zahl der Verwendungen dieser Eigenschaft beschränkt

! Beispiel: Programmauführungszeit beträgt 10 Sekunden, 2 Sekunden davon entfallen auf Spei-

cherzugriffe

� Durch Optimierung des Speichersystems können maximal 2 Sekunden Programmausfüh-rungszeit gespart werden, d.h. die System-Performance kann sich (auch bei einer unendlichen Verbesserung des Speichersystems) nur um max. 2/10 = 20 % verbessern

! Folgen aus dem Amdahl-Gesetz

+ Verbesserung eines Teilaspekts eines Systems schlägt sich nicht direkt proportional in der Verbesserung der Performance des Gesamtsystems nieder

+ Umkehrschluss

Verbesserung des häufig vorkommenden Falls um einen bestimmten Faktor ergibt einen höheren Perfor-mance-Gewinn als die Verbesserung des nicht so häu-fig vorkommenden Falls (make the common case fast).

3-1

3 Assembler- und Befehlssatz-Ebene beim MMIX

3.1 MMIX-Modellrechner

! erfunden von Donald Ervin Knuth

+ 10. Januar 1938 in Milwaukee, Wisconsin/USA geboren + ausserordentlicher Professor für Mathematik am California Institute of Technology (Caltech)

bis 1968 + ab 1968 Professor für Computertechnik (computer science) und Elektrotechnik in Stanford + 25 Ehrendoktor-Titel + ist insbesondere durch seine 3 Bücher „The Art of Computer Programming“ bekanntgewor-

den, die unter anderem neben den Büchern Einsteins und Mandelbrots zu den wichtigsten wissenschaftlichen Büchern des (letzten) Jahrhunderts gezählt werden

+ 4. Teil der Reihe „The Art of Computer Programming“ gerade in Arbeit + hat aufgrund seiner Unzufriedenheit mit der typografischen Gestaltung seiner ersten Bücher T XE erfunden, was ihn eigenen Angaben nach 12 Jahre lang von seinem eigentlichen Ziel, der Analyse und Darstellung von Algorithmen, abgehalten hat

+ MIX

• römische Zahl 1009, die sich als Mittelwert mehrerer CISC-Rechner-Kennzahlen ergibt • MIX = ¬ (360 + 650 + 709 + 7070 + U3 + SS80 + 1107 + 1604 + G20 + B220 + S2000 +

920 + 601 + H800 + PDP-4 + II) / 16 ¼ = ¬16150 / 16¼ = 1009 • ist der Name des hypothetischen Rechners, den Donald Knuth für die Analyse von Algo-

rithmen in „The Art of Computer Programming“ entwickelt hat

+ MMIX • römische Zahl 2009, die sich als Mittelwert mehrerer RISC-Rechner-Kennzahlen ergibt • MMIX = (CrayI + IBM801 + RISCII + ClipperC300 + AMD29K + Motorola88K + IBM601

+ Inteli960 + Alpha21164 + POWER2 + MIPSR400 + HitachiSuperH4 + StrongARM110 + Sparc64) / 14 = 28126 / 14 = 2009

• RISC-Version des alten MIX-Rechners, mit dem Donald Knuth die Algorithmen in den gerade bearbeiteten Bände 4-6 der Reihe „The Art of Computer Programming“ be-schreibt

+ mehr unter www-cs-faculty.stanford.edu/~knuth/

Abb. 96: Donald E. Knuth

3-2

! MMIX ist ein Prozessor-Modell + nicht real existent � keine legacy-Effekte, d.h. keine unsaubere (und damit schwer ver-

ständliche) Architektur aufgrund von Rückwärtskompatibilitäten + für Lehr- und Forschungszwecke + sehr einfach, da extrem regulär + Software-Simulations-Tools verfügbar ĺ Praktikum + gcc-Compiler verfügbar

3.2 Architektur

3.2.1 Programmiermodell Register-Register-Architektur (Load-Store-Architektur) 64 Bit Wortbreite (Register, Rechenwerk, Daten- und Adress-Bus) sehr viele Register (256 Stück) Adressierbarer Speicherbereich: 264 Byte 256 Befehle, die zumeist nur 1 Takt benötigen

Laden

Speichern

PUT

GET

Spezialregister Allzweckregister Arbeitsspeicher

$X $Y $Z

Abb. 97: MMIX-Prozessor

3.2.2 Register • Allzweckregister (GPR = General Purpose Register)

! 256 Stück (0…255) ! werden zum Zwischenspeichern von Variablen und Operanden verwendet ! teilen sich auf in

+ Bereich der lokalen Register

• erstreckt sich von Register $0 bis zum Register $(<rL> – 1), wobei das Spezialregister rL (s.u.) die Nummer des ersten marginalen Registers enthält

• Beispiel ! in rL steht der Wert 7 ! � Bereich lokaler Register erstreckt sich von Register $0 bis Register $6

• beschreibt diejenigen Register, die gerade vom (Unter-) Programm verwendet werden

3-3

+ Bereich der marginalen Register • erstreckt sich vom durch die in rL stehende Nummer bezeichneten Register bis zu dem

Register, das eins unter dem durch rG (s.u.) gekennzeichneten Register liegt • Beispiel:

! in rL steht der Wert 7 ! in rG steht der Wert 245 ! � marginale Register sind die Register $7 bis $244

• beschreibt den noch unbenutzten Registerbereich, der z.B. für Unterprogramme ver-wendet werden kann

+ Bereich der globalen Register

• alle Register zwischen $<rG> und $255 • Beispiel:

! in rG steht der Wert 245 ! � globale Register sind dann die Register $245 bis $255

• globale Register dienen zur Aufnahme globaler Variable, die auch in Unterprogrammen sichtbar sind (siehe auch Abschnitt „Registerstack“ in Kap. 3)

globaleRegister

marginaleRegister

$255

rG

rL

$0

lokaleRegister

Abb. 98: Allzweckregister beim MMIX

• Spezialregister

! beim MMIX 32 Stück vorhanden ! können nur über die MMIX-Befehle PUT und GET angesprochen werden (vgl. Kap. 2.8.13) ! Ermöglichen die Steuerung/Konfiguration bestimmter Prozessor-Eigenschaften (z.B. Freischal-

ten bestimmter Interrupts) ! Melden dem Benutzer das Auftreten bestimmter Ereignisse (z.B. Division durch Null, Überlauf

etc.)

3-4

3.2.3 Speicherorganisation Der Adressbereich des MMIX ist in mehrere Segmente aufgeteilt.

0x0000000000000000= Text_Segment

0x00000000000000FF0x0000000000000100

0x1FFFFFFFFFFFFFFF0x2000000000000000= Data_Segment

0x3FFFFFFFFFFFFFFF0x4000000000000000= Pool_Segment

0x5FFFFFFFFFFFFFFF0x6000000000000000= Stack_Segment

0x7FFFFFFFFFFFFFFF

0x8000000000000000

0xFFFFFFFFFFFFFFFF

Für Betriebs-system reserviert

Stacksegment

Poolsegment

Datensegment

Interrupt-Vektoren

Text-Segment

Programm

Abb. 99: Speicherorganisation beim MMIX-Prozessor

3-5

• Textsegment ! dient zur Aufnahme des Programm-Codes (ab Adresse 0x100) ! auch Ablage von Konstanten ! an den Adressen 0x00 bis 0x8C stehen die Interruptvektoren

+ Code, der beim Auftreten einer Ausnahme (Trip) angesprungen wird + 4 Befehle pro Tabelleneintrag abspeicherbar + sollte Sprung in den Trip-Handler23 beinhalten

Adresse Inhalt0x000x040x080x0C0x100x140x180x1C0x200x240x280x2C0x300x340x380x3C0x400x440x480x4C0x500x540x580x5C0x600x640x680x6C0x700x740x780x7C0x800x840x880x8C

Sprung in Trip-Handler für GK-Zahl ungenau

Sprung in Trip-Handler für ungültige GK-Operation

Sprung in Trip-Handler für GK-Überlauf

Sprung in Trip-Handler für GK-Unterlauf

Sprung in Trip-Handler für GK-Divison durch Null

Sprung in Trip-Handler für allgemeine Trips

Sprung in Trip-Handler für Division durch Null

Sprung in Trip-Handler für Integer-Überlauf

Sprung in Trip-Handler für Überlauf bei GK-FK-Wandlung

Abb. 100: Interruptvektoren im Textsegment

• Datensegment

! dient zur Aufnahme der verwendeten Variablen, die beginnend bei 0x20…0 in Richtung stei-gender Adressen abgelegt werden

! nimmt bei uns beginnend bei 0x3F…F8 in Richtung fallender Adressen den Stack auf

23 Trip-Handler sind Funktion, die Ausnahmen (z.B. Division durch Null) bearbeiten.

3-6

• Poolsegment ! dient zur Kommunikation zwischen Betriebssystem und Anwendungsprogramm ! nimmt Aufrufparameter für das Programm und Ergebnisse des Programms auf

+ Register $0 enthält beim Programmstart die Anzahl der übergebenen Argumente (argc = argument count)

+ Register $1 enthält beim Programmstart einen Zeiger auf eine Zeigerliste im Poolsegment (argv = argument vector)

+ Zeigerliste ist mit Nullzeiger abgeschlossen + Zeigerliste enthält Zeiger auf Speicherbereiche im Poolsegment, in denen die einzelnen Ar-

gumente als 0-terminierter String abgelegt sind

+ Beispiel: D:\mmix –t5 skalprodarg 4 1 2 3 4 10 20 30 40

• $0 enthält den Wert 0x0A, da 10 Argumente übergeben werden • $1 enthält beim Start 0x4000000000000008 " Startadresse im Poolsegment • das Poolsegment sieht dann wie folgt aus:

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 p0x4000000000000018 0x4000000000000078 @ \0 \0 \0 \0 \0 \0 x0x4000000000000020 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 \00x4000000000000060 0x736b616c70726f64 s k a l p r o d0x4000000000000068 0x6172670000000000 a r g \0 \0 \0 \0 \00x4000000000000070 0x3400000000000000 4 \0 \0 \0 \0 \0 \0 \00x4000000000000078 0x3100000000000000 1 \0 \0 \0 \0 \0 \0 \00x4000000000000080 0x3200000000000000 2 \0 \0 \0 \0 \0 \0 \00x4000000000000088 0x3300000000000000 3 \0 \0 \0 \0 \0 \0 \00x4000000000000090 0x3400000000000000 4 \0 \0 \0 \0 \0 \0 \00x4000000000000098 0x3130000000000000 1 0 \0 \0 \0 \0 \0 \00x40000000000000a0 0x3230000000000000 2 0 \0 \0 \0 \0 \0 \00x40000000000000a8 0x3330000000000000 3 0 \0 \0 \0 \0 \0 \00x40000000000000b0 0x3430000000000000 4 0 \0 \0 \0 \0 \0 \00x40000000000000b8 0x0000000000000000 \0 0 \0 \0 \0 \0 \0 \0

Abb. 101: Poolsegment nach dem Programmaufruf

• Stacksegment ! hierhin werden bei der Verwendung der MMIX-Befehle PUSHJ und PUSHGO die vom Re-

gisterstack verdrängten Register automatisch ausgelagert ! mit dem MMIX-Befehl POP werden die zuvor vom Registerstack in das Stacksegment ausgela-

gerten Register von dort wieder in die entsprechenden Register zurückgeschrieben ! wird bei uns nicht verwendet, da wir den Stack selber verwalten

• Für Betriebssystem reservierter Bereich

! Für Programmierer nicht erreichbar ! geschützter Speicherbereich ! wird von uns nicht verwendet

3-7

3.2.4 Speicher-Zugriffsarten Beim MMIX-Prozessor sind Speicherzugriffe auf 4 verschiedene Wortbreiten möglich:

! Byte-Zugriff + Zugriff auf jedes einzelne im Speicher abgelegte Byte möglich (vgl. „ĺ“ in nachfolgender

Abbildung, Spalte „Byte“) + es können keine kleineren Einheiten als 1 Byte adressiert werden + jedes Byte hat eine eigene Adresse

! Wort-Zugriff

+ Zugriff auf 16 Bit breite Worte (im MMIX-Sprachgebrauch „Wyde“) + Beim Zugriff wird vom Speicher immer das LSB der Zugriffsadresse als 0 angesehen, wes-

halb der Zugriff ausschliesslich auf durch 2 teilbare Adressen stattfindet (vgl. „ĺ“ bei Wyde)

! Doppel-Wort-Zugriff + Zugriff auf 32 Bit breite Worte (im MMIX-Sprachgebrauch „Tetra“) + Beim Zugriff werden vom Speicher immer die beiden niederwertigsten Bits der Zugriffsad-

resse als 0 angesehen, weshalb der Zugriff ausschliesslich auf durch 4 teilbare Adressen erfolgt (vgl. „ĺ“ bei Tetra)

! Lang-Wort-Zugriff

+ Zugriff auf 64 Bit breite Worte (im MMIX-Sprachgebrauch „Octa“) + Beim Zugriff werden vom Speicher immer die drei niederwertigsten Bits der Zugriffsadresse

als 0 angesehen, weshalb der Zugriff ausschliesslich auf durch 8 teilbare Adressen erfolgt (vgl. „ĺ“ bei Octa)

Adresse Byte Wyde Tetra Octa

0...0 0000 0000 ĺ ĺ ĺ ĺ0...0 0000 0001 ĺ0...0 0000 0010 ĺ ĺ0...0 0000 0011 ĺ0...0 0000 0100 ĺ ĺ ĺ0...0 0000 0101 ĺ0...0 0000 0110 ĺ ĺ0...0 0000 0111 ĺ0...0 0000 1000 ĺ ĺ ĺ ĺ0...0 0000 1001 ĺ0...0 0000 1010 ĺ ĺ0...0 0000 1011 ĺ0...0 0000 1100 ĺ ĺ ĺ0...0 0000 1101 ĺ0...0 0000 1110 ĺ ĺ0...0 0000 1111 ĺ0...0 0001 0000 ĺ ĺ ĺ ĺ0...0 0001 0001 ĺ

1...1 1111 1011 ĺ1...1 1111 1100 ĺ ĺ ĺ1...1 1111 1101 ĺ1...1 1111 1110 ĺ ĺ1...1 1111 1111 ĺ

Abb. 102: Mögliche Speicherzugriffe beim MMIX-Prozessor

3-8

3.3 Befehlsformat

Ein MMIX-Programm besteht aus (mehreren) Befehlen, die in einer Textdatei einfach untereinander geschrieben werden. Jeder Befehl besteht aus 4 Feldern, die durch Leerzeichen (LZ) oder Tabulatoren voneinander ge-trennt sind.

! Marke + dient zum Verweis auf die aktuelle Programmzeile + ist optional24, muss also nicht mit angegeben werden

! Befehlscode (Operationscode, Opcode): der MMIX-Befehl, der ausgeführt werden soll

! Operanden: Operanden des MMIX-Befehls; 4 Möglichkeiten

+ Angabe von 3 Registern + Angabe von 2 Registern und einer 8 Bit breiten Konstanten + Angabe von 1 Register und einer 16 Bit breiten Konstanten + Angabe von einer 24 Bit breiten Konstanten

! Kommentar

+ hilft einem, sich beim späteren Betrachten des geschriebenen Programms wieder daran zu erinnern, was man mit der betreffenden Code-Zeile eigentlich wollte

+ ist optional

Marke Befehlscode Kommentar

[Marke] LZ Befehlscode LZ $X , $Y , $Z [LZ Kommentar]

[Marke] LZ Befehlscode LZ $X , $Y , Z [LZ Kommentar]

[Marke] LZ Befehlscode LZ $X , [LZ Kommentar]

[Marke] LZ Befehlscode LZ [LZ Kommentar]

Operanden

YZ

XYZ

Abb. 103: MMIX-Befehlsformat

Beispiel für einen MMIX-Befehl:

Addiere ADD $1,$2,$3 Register $1=$2+$3

ADD $1,$2,$3 geht auch ohne Marke

% diese Zeile ist ein Kommentar

// diese auch

Marke Befehlscode

Operanden Kommentar

24 „optional“ wird in nachstehender Abbildung durch eckige Klammern [] gekennzeichnet.

3-9

! Bedeutung des Befehls: Nehme den Inhalt von Register $2, addiere ihn zum Inhalt von Regis-ter $3 und lege das Ergebnis in Register $1 ab

! Befehlswort

+ besteht aus dem Befehlscode und den Operanden + ist nach der Übersetzung beim MMIX-Prozessor immer 32 Bit breit

! Nomenklatur

+ wird einer Zahl ein Dollarzeichen $ vorangestellt, ist die Zahl als Register zu interpretieren + beginnt eine Zeile mit einem Sonderzeichen (z.B. %, / etc.), so wird die komplette Zeile als

Kommentar interpretiert MMIX-Programme werden stets so geschrieben, dass die vier Felder Marke, Befehlscode, Operanden und Kommentar der einzelnen Befehle untereinander stehen � 4 Spalten � übersichtlicher Beispiel-Programm zur Berechnung eines Skalarprodukts: LOC Data_Segment 01 GREG @ 02 03 N OCTA 4 Vektordimension 04 ADR_A1 OCTA 1 a1 05 OCTA 2 a2 06 OCTA 3 a3 07 OCTA 4 a4 08 ADR_B1 OCTA 10 b1 09 OCTA 20 b2 10 OCTA 30 b3 11 OCTA 40 b4 12 13 u IS $1 Für Parameter 1 14 v IS $2 Für Parameter 2 15 w IS $3 Für Parameter 3 16 x IS $4 Für das Ergebnis 17 y IS $5 Für Zwischenberechnungen 18 z IS $6 Für Zwischenberechnungen 19 20 21 LOC #100 22 23 Main SETL x,0 Initialisierung 24 LDA u,ADR_A1 Referenz auf a1 in u speichern 25 LDA v,ADR_B1 Referenz auf b1 in v speichern 26 LDO w,N Vektordimension laden 27 MUL w,w,8 verwendete Worte haben 8 Byte 28 Start BZ w,Ende wenn fertig -> Ende 29 SUB w,w,8 w = w – 8 30 LDO y,u,w y = 31 LDO z,v,w z = <v + w> 32 MUL y,y,z y = * <v + w> 33 ADD x,x,y x = x + * <v + w> 34 JMP Start 35 36 Ende TRAP 0,Halt,0 Ergebnis steht in x 37

3-10

3.4 Befehlstypen

3.4.1 MMIX-Befehlssatz

! sind Befehle, die vom MMIX-Prozessor ausgeführt werden ! werden vom Assembler jeweils in eine 32 Bit-Zahl (8 Bit Befehlscode + 24 Bit Operanden) ü-

bersetzt ! werden zur Laufzeit vom Prozessor ausgeführt ! werden im nächsten Kapitel tabellarisch angegeben ! Beispiel: „ADD $1,$2,$3“, „SETL x,0“, „LDA u,ADR_A1“ etc.

3.4.2 Loader25-Befehle

! sind Befehle, die vom Loader beim Laden des Programms in den Arbeitsspeicher ausgeführt werden

! werden vom Assembler bei der Übersetzung in sog. Loader-Opcodes übersetzt und in die Ob-jektdatei (ausführbare Binärdatei) geschrieben, so dass sie dann beim Laden des Programms vom Loader interpretiert und ausgeführt werden können

! dienen dazu, dem Loader mitzuteilen, an welcher Stelle im Arbeitsspeicher er welche Daten ab-legen soll

+ Beispiel: LOC Data_Segment " LOC #2000000000000000 (vgl. Zeile 1) • LOC steht für „locate“ • weist den Loader an, alle Daten oder Befehle, die nach dieser Zeile kommen, ab der

Adresse 0x2000000000000000 der Reihe nach in den Arbeitsspeicher zu schreiben • da an Adresse 0x2000000000000000 das Datensegment beginnt, ermöglicht der LOC-

Befehl hier, Variablen anzulegen

+ Beispiel: LOC #100 (vgl. Zeile 22) • wie zuvor • da an Adresse 0x100 derjenige Teil des Textsegments beginnt, ab dem das Programm

im Speicher abgelegt wird, wird diese Anweisung in der Regel immer vor dem ersten MMIX-Befehl stehen, so dass die vom Assembler in 32 Bit-Zahlen übersetzten MMIX-Befehle dann vom Loader der Reihe nach ab Adresse 0x100 im Arbeitsspeicher abge-legt werden

+ Beispiel: ADR_A1 OCTA 1 (vgl. Zeile 5) • weist den Loader an, an der Speicherstelle 0x200000000000000826 ein 8 Byte grosses

Speicherwort zu reservieren und mit dem Wert 1 vorzubelegen • die vor den Befehl OCTA geschriebene Marke ADR_A1 ermöglicht, dass die Speicher-

stelle 0x2000000000000008 auch über die Marke ADR_A1 angesprochen werden kann • die Marke wird dann vom Assembler während der Übersetzung in die entsprechende

Adresse umgewandelt

25 Der Loader (auch Lader genannt) ist dasjenige Programm im Betriebssystem, das eine übersetzte, ausführbare Binärdatei im Arbeitsspeicher ablegt, so dass diese dort ausgeführt werden kann. Die Binärdatei enthält dabei Informationen darüber, an welche Stelle im Arbeitsspeicher die betreffenden Daten abgelegt werden sollen. Diese Informationen werden vom Loader ausgewertet und umgesetzt. 26 0x2000000000000008 kommt daher, dass die Anweisung LOC Data_Segment (vgl. Zeile 1) den Loader anweist, die nachfolgenden Befehle/Daten ab Adresse 0x2000000000000000 im Speicher abzulegen. Der GREG-Befehl ist ein Loader-Befehl, der ein Register vorbelegt und benötigt damit keinen Platz im Arbeitsspeicher. Die nächste Anweisung (N OCTA 4) ist wieder ein Loader Befehl, diesmal jedoch einer, der Speicher reserviert und initialisiert. Da durch diesen Befehl ein Octa, also 8 Byte reserviert werden, befindet sich die nächste freie Speicherstelle an Adresse 0x2000000000000008.

3-11

3.4.3 Assembler-Befehle ! sind Befehle bzw. Hinweise, die der Assembler während der Übersetzung auswertet ! werden nicht vom Prozessor ausgeführt! ! dienen in erster Linie dazu, dem Programmierer das Leben zu erleichtern

+ ermöglichen, dass Register mit Namen angesprochen werden können

• Beispiel: ADD x,x,y (vgl. Zeile 34) statt ADD $4,$4,$5 ! x IS $4 (vgl. Zeile 17) führt dazu, dass man statt $4 auch x schreiben kann ! vor der Assemblierung ersetzt der Assembler dann x wieder durch $4 (Präprozes-

sor) ! vgl. in C: #define x $4

+ ermöglichen, dass Stellen im Programm über Marken angesprochen werden können

• Adressrechnung durch Assembler � weitere Erleichterung • Beispiel: BZ w,Ende (vgl. Zeile 29) statt BZ w,7

+ ermöglichen, dass auch Stellen im Datenspeicher über Marken angesprochen werden kön-

nen • Benutzung der Marken wie Variablennamen • Adressrechung ebenfalls durch Assembler � Erleichterung für den Programmierer

• Beispiel: LDO w,N (vgl. Zeile 27) statt LDO w,$254,0

! die Marke N wird vom Assembler in eine Adresse umgesetzt ! jede MMIX-Adresse ist 64 Bit breit � passt nicht in das nur 32 Bit breite Befehlswort ! Lösung: Adresse über Basisregister adressieren ! Der 2. Operand ($Y) des LDO-Befehls gibt ein Basisregister27 an, in dem eine 64 Bit

breite Speicheradresse steht (in unserem Beispiel steht in Register $254 steht die Adresse 0x2000000000000000)

! Der 3. Operand ($Z) des LDA-Befehls gibt dann den Offset (0…255) an, der zum Basisregister hinzuaddiert werden muss (in unserem Beispiel der Wert 0)

Da Loader-Befehle vom Assembler zu Loader-Opcodes übersetzt werden, werden sie mit den As-sembler-Befehlen zu Assembler-Direktiven zusammengefasst.

27 Als Basisregister dienen hier die globalen MMIX-Register. Da die Anweisung GREG Ausdruck ein neues globales Regis-ter anlegt und mit Ausdruck initialisiert, legt die Anweisung GREG @ ein neues globales Register an und initialisiert dieses mit der aktuellen Adresse (@ " the place where we are at; die aktuelle Adresse kann durch Analyse der LOC-Anweisungen und der Anzahl der nachfolgenden Bytes bestimmt werden).

3-12

Nachfolgend abgebildete Tabelle listet die Assembler-Direktiven auf:

Befehl Operanden

LOC AusdruckLegt die Adresse fest, ab welcher der nachfolgende Assembler-Code in den Speicher eingetragen werden soll

ISBei der Assemblierung wird Ausdruck1 durch Ausdruck2 ersetzt

GREG AusdruckReserviert ein neues globales Register und initialisiert es mit Ausdruck

BYTE

Ausdruck 1, Ausdruck 2, ... Ausdruck n

Anstelle der Angabe einzelner durch Kommas getrennter Bytewerte kann eine in Anführungszeichen stehende Zeichenkette verwendet werden.

WYDE


TETRA


OCTA


LOCAL

BSPEC Ausdruck

Begin special mode: Kann beispielsweise von einem Compiler dazu verwendet werden, Debug-Informationen wie Zeilennummern o.ä. in die Objektdatei mit einzufügen.

ESPEC End special mode

Weist den Assembler an, nach der Assemblierung eine Fehlermeldung auszugeben, wenn der Wert von rG nicht größer ist als alle Register, die mit dieser Anweisung als lokal deklariert wurden

Beginnt einen Abschnitt, dessen Textinhalt direkt in die Ausgabedatei mit hineingeschrieben wird, aber nicht als Teil des assemblierten Programms geladen wirdBeendet den durch BSPEC angefangenen Abschnitt

Reserviert für jeden Ausdruck eine 1 Byte große Speicherzelle und initialisiert diese mit Ausdruck




Wirkung Erläuterung

@=Ausdruck

Ausdruck1 IS Ausdruck2

3-13

3.5 Befehlssatz

In diesem Kapitel werden die wichtigsten der insgesamt 256 MMIX-Befehle beschrieben. Weniger oft benötigte Befehle finden Sie im Anhang. 3.5.1 Nomenklatur und Operandenverwendung Im Folgenden wird die nachfolgend angegebene Nomenklatur verwendet:

! $X: Allgemeine Darstellung des ersten Operanden-Registers ! $Y: Allgemeine Darstellung des zweiten Operanden-Registers ! $Z: Allgemeine Darstellung des dritten Operanden-Registers

! X: Allgemeine Darstellung des Direktoperanden (8 Bit) an der ersten Operanden-Stelle ! Y: Allgemeine Darstellung des Direktoperanden (8 Bit) an der zweiten Operanden-Stelle ! Z: Allgemeine Darstellung des Direktoperanden (8 Bit) an der dritten Operanden-Stelle

! XY: Allgemeine Darstellung des Direktoperanden (16 Bit) an den Operanden-Stellen eins und zwei

! YZ: Allgemeine Darstellung des Direktoperanden (16 Bit) an den Operanden-Stellen zwei und drei

! XYZ: Allgemeine Darstellung des Direktoperanden (24 Bit) an den Operanden-Stellen eins, zwei und drei

! Beispiele + ADD $5,$8,2 � $X = $5, $Y = $8 und Z = 2 + BZ $1,#2048 � $X = $1, YZ = 0x2048 = 826410

Die Operanden werden wie folgt verwendet:

! bei fast allen Befehlen gilt das Schema:

+ erster Operand " Zieloperand + zweiter und dritter Operand " Quelloperanden

+ Beispiel: ADD $X,$Y,$Z

• Addiert die Inhalte der Register $Y und $Z und legt das Ergebnis in Register $X ab

+ Beispiel: ADD $X,$Y,Z • Addiert den Inhalt von Register $Y zur Konstanten Z und legt das Ergebnis in Register $X ab

! Ausnahme:

+ bei Speicherbefehlen gilt • erster Operand " Quelloperand • zweiter und dritter Operand geben als Summe die Adresse wider, an die etwas gespei-

chert werden soll, entsprechen also einer Art Zieloperand

+ Grund • für Addition der Operanden kann auf diese Weise das selbe Rechenwerk wie für die

Addition verwendet werden • � einfachere, regulärere und billigere Hardware

3-14

3.5.2 Laden und Speichern Laden: Datum wird vom Arbeitsspeicher in ein Register übertragen Speichern: Datum wird von einem Register in den Arbeitsspeicher übertragen

Befehl Operanden

$X,$Y,$Z$X,$Y,Z$X,$Y,$Z$X,$Y,Z$X,$Y,$Z$X,$Y,Z$X,$Y,$Z$X,$Y,Z$X,$Y,$Z$X,$Y,Z$X,$Y,$Z$X,$Y,Z$X,$Y,$Z$X,$Y,Z$X,$Y,$Z$X,$Y,Z$X,$Y,$Z$X,$Y,Z

LDA $X,LabelLoad address: Lädt die durch Label gekennzeichnete Adresse in Register X; wird vom Assembler durch ADDU ersetzt

$X,$Y,$Z

$X,$Y,Z

$X,$Y,$Z

$X,$Y,Z

$X,$Y,$Z$X,$Y,Z$X,$Y,$Z$X,$Y,Z$X,$Y,$Z$X,$Y,Z$X,$Y,$Z$X,$Y,Z$X,$Y,$Z$X,$Y,Z

Store byte: Schreibt ein Byte in den Speicher; Überlauf, wenn -128 > $X >127

LDSF$X=GK64(GK32(M4[$Y+$Z]))

$X=GK64(GK32(M4[$Y+Z]))

Load short float: Interpretiert den Inhalt einer 32-Bit-Speicherzelle als 32-Bit-GK-Zahl, konvertiert diese in eine 64-Bit-GK-Zahl und lädt diese in Register X

LDUNC

$X=M8[$Y+$Z]

$X=M8[$Y+Z]

Load octa uncached: Wie LDO, informiert das System jedoch darüber, dass der Wert und die Werte der angrenzenden Speicherzellen in nächster Zukunft nicht mehr benötigt werden und somit nicht in den Cache geladen werden müssen (Cache bypassing)

STBUM1[$Y+$Z]=$X mod 0x100 Store byte unsigned: Schreibt ein Byte in den

Speicher; kein Überlauf möglichM1[$Y+Z]=$X mod 0x100

LDHT$X=(M4[$Y+$Z]<<32) Load high tetra: Laden eines Tetras in die

linke Hälfte von $X; rechts mit 0 aufgefüllt$X=(M4[$Y+Z]<<32)

Load tetra unsigned: VZ-loses Laden eines Tetras; obere 4 Byte mit 0 aufgefüllt$X=M4[$Y+Z]

Load octa unsigned: Laden eines Octas; kein Unterschied zu LDO $X=M8[$Y+Z]

LDWU$X=M2[$Y+$Z] Load wyde unsigned: VZ-loses Laden eines

Wydes; obere 6 Byte mit 0 aufgefüllt$X=M2[$Y+Z]

Load tetra: VZ-behaftetes Laden eines Tetras; obere 4 Byte mit VZ aufgefüllt

Load octa: Laden eines Octas

Store wyde: Schreibt ein Wyde in den Speicher; Überlauf möglich

Store tetra: Schreibt ein Tetra in den Speicher; Überlauf möglich

STWM2[$Y+$Z]=$X

STTM4[$Y+$Z]=$XM4[$Y+Z]=$X

STWUM2[$Y+$Z]=$X mod 0x10000 Store wyde unsigned: Schreibt ein Wyde in

den Speicher; kein Überlauf möglichM2[$Y+Z]=$X mod 0x10000

$X=M8[$Y+Z]

STBM1[$Y+$Z]=$XM1[$Y+Z]=$X

LDOU$X=M8[$Y+$Z]

$X=Label

M2[$Y+Z]=$X

LDT

LDO

$X=s(M4[$Y+$Z])$X=s(M4[$Y+Z])

$X=M8[$Y+$Z]

LDTU$X=M4[$Y+$Z]

LDW$X=s(M2[$Y+Z])

Load byte: VZ-behaftetes Laden eines Bytes; obere 7 Byte mit VZ aufgefüllt

Load wyde: VZ-behaftetes Laden eines Wydes; obere 6 Byte mit VZ aufgefüllt

LDB$X=s(M1[$Y+$Z])$X=s(M1[$Y+Z])

$X=s(M2[$Y+$Z])

LDBU$X=M1[$Y+$Z] Load byte unsigned: VZ-loses Laden eines

Bytes; obere 7 Byte mit 0 aufgefüllt$X=M1[$Y+Z]


3-15

$X,$Y,$Z$X,$Y,Z$X,$Y,$Z$X,$Y,ZX,$Y,$ZX,$Y,Z

$X,$Y,$Z

$X,$Y,Z

$X,$Y,$Z

$X,$Y,Z

$X,$Y,$Z

$X,$Y,Z

Store tetra unsigned: Schreibt ein Tetra in den Speicher; kein Überlauf möglich

M4[$Y+$Z]=$X mod

STTU$X,$Y,$Z

$X,$Y,ZM4[$Y+Z]=$X mod 0x100000000

0x100000000

STUNC

M8[$Y+$Z]=$XStore octa uncached: Wie STO, informiert das System jedoch darüber, dass der Wert und die Werte der angrenzenden Speicherzellen in nächster Zukunft nicht mehr benötigt werden und somit nicht im Cache gehalten werden müssen

M8[$Y+Z]=$X

Store octa unsigned: Schreibt ein Octa in den Speicher; kein Unterschied zu STO

STOUM8[$Y+$Z]=$X

STOM8[$Y+$Z]=$X Store octa:

Schreibt ein Octa in den SpeicherM8[$Y+Z]=$X

STSF

M4[$Y+$Z]=GK32(GK64($X))Store short float: Interpretiert den Inhalt von Register X als 64-Bit-GK-Zahl, konvertiert diese in eine 32-Bit-GK-Zahl und speichert diese in die durch $Y und $Z bzw. Z angegebene Tetra-Speicherzelle

M4[$Y+Z]=GK32(GK64($X))

STCO

STHTM4[$Y+$Z]=$X>>32 Store high tetra: Schreibt die obere Hälfte

von Register X nach M4[$Y+$Z] bzw. M4[$Y+Z]

M8[$Y+Z]=$X

M4[$Y+Z]=$X>>32

M8[$Y+$Z]=X Store constant octabyte: Schreibt das Byte X als VZ-loses Octa in den SpeicherM8[$Y+Z]=X

3.5.3 Laden von Registern mit Direktoperand

Befehl Operanden

INCMLIncrease by medium low wyde: YZ um 16 nach links, dann VZ-lose Addition mit $X

INCMHIncrease by medium high wyde: YZ um 32 nach links, dann VZ-lose Addition mit $X

$X,YZ $X=($X+(YZ<<32)) mod 264

$X=($X+YZ) mod 264Increase by low wyde: YZ mit $X VZ-los addieren

$X,YZ $X=($X+(YZ<<16)) mod 264


SETL

SETML

$X=YZSet to low wyde: Setzt Bits 0…15 in Register X auf YZ; restliche Bits # 0

$X=(YZ<<16)Set to medium low wyde: Setzt Bits 16…31 in Register X auf YZ; restliche Bits # 0

SETMH

SETH

INCL

$X,YZ

$X,YZ

$X,YZ

$X,YZ

$X=(YZ<<32)Set to medium high wyde; Setzt Bits 32…47 in Register X auf YZ; restliche Bits # 0

$X,YZ $X=(YZ<<48)Set to high wyde: Setzt Bits 48…64 in Register X auf YZ; restliche Bits # 0

INCH $X,YZIncrease by high wyde: YZ um 48 nach links, dann VZ-lose Addition mit $X$X=($X+(YZ<<48)) mod 264

3-16

3.5.4 Arithmetische Operationen

Befehl Operanden

$X,$Y,$Z$X,$Y,Z$X,$Y,$Z$X,$Y,Z$X,$Y,$Z$X,$Y,Z$X,$Y,$Z$X,$Y,Z$X,$Y,$Z$X,$Y,Z$X,$Y,$Z$X,$Y,Z

$X,$Y,$Z$X,$Y,Z$X,$Y,$Z$X,$Y,Z

$X,Y,$Z$X,Y,Z$X,$Y,$Z$X,$Y,Z$X,$Y,$Z$X,$Y,Z$X,$Y,$Z$X,$Y,Z

$X=¬$Y/$Z¼rR=$Y mod $Z$X=0rR=$Y

$X=¬u(rD$Y) / / u($Z)¼ wenn u($Z)rR=u(rD$Y) mod >u(rD) mod u($Z)$X=rDrR=$Y

FDIV $X,$Y,$Z Floating divide: Division zweier GK-Zahlen

FREM $X,$Y,$Z

Floating remainder: y rem z " y-nz mit n = nächster zu y/z gelegener Integer. Bei Mehrdeutigkeit wird der gerade Integer verwendet

FSQRT $X,$Z Floating square root: Wurzel einer GK-Zahl

DIV$X,$Y,$Z $X,$Y,Z

Divide: Vorzeichenbehaftete Division; Dividend in $Y, Divisor in $Z, Quotient in $X, Rest in rR

NEGU

MULUrH$X=$Y*$Z Multiply unsigned: Produkt-Bits [127…64]

nach rH, Produkt-Bits [63…0] nach $X rH$X=$Y*Z

$X=($Y-$Z) mod 264 Negate unsigned: Negation ohne Überlauf

Add unsigned: Addition (im 2er-Komplement) ohne Überlauf

FADD $X,$Y,$Z $X=f($Y)+f($Z) Floating add: GK-Addition; Invalid-Exception bei ' - ' oder -' + '

$X=($Y+Z) mod 264

$X=(2$Y+$Z) mod 264

$X=(2$Y+Z) mod 264 2ADDU

Times 2 and add unsigned: Wie ADDU, jedoch Register Y zuerst mit 2 multipliziert

$X=$Y-Z

Wirkung

Divide unsigned: Dividend-Bits [127…64] in rD, Dividend-Bits [63…0] in $Y, Divisor in $Z; Rest der Division in Register rR

Erläuterung

Add: Addition im 2er-Komplement; Überlauf wenn Summe ( 263 oder < !263

Subtract: Subtraktion; Überlauf wenn Ergebnis ( 263 oder < 2-63

$X=(4$Y+$Z) mod 264

$X=(4$Y+Z) mod 264

$X=($Y-$Z) mod 264

$X=($Y-Z) mod 264

$X=$Y+$Z$X=$Y+Z

ADD

DIVU$X,$Y,$Z $X,$Y,Z

$X=$Y-$ZSUB

MUL

ADDU $X=($Y+$Z) mod 264

16ADDU $X=(16$Y+$Z) mod 264

$X=(16$Y+Z) mod 264

Times 4 and add unsigned: Wie ADDU, jedoch Register Y zuerst mit 4 multipliziertTimes 8 and add unsigned: Wie ADDU, jedoch Register Y zuerst mit 8 multipliziertTimes 16 and add unsigned: Wie ADDU, jedoch Register Y zuerst mit 16 multipliziert

4ADDU

8ADDU $X=(8$Y+$Z) mod 264

$X=(8$Y+Z) mod 264

Subtract unsigned: Subtraktion ohne Überlauf

NEG$X=Y-$Z Negate: Negation; Überlauf, wenn Ergebnis

( 263; Y = 0 � nur, wenn $Z = -263 $X=Y-Z

FSUB $X,$Y,$Z $X=f($Y)-f($Z)Floating subtract; GK-Subtraktion; Invalid-Exception bei ' - ' oder -' + '

FMULrH$X=f($Y)*f($Z)

$X=$Y*Z

SUBU

$X,$Y,$Z

$X=(f($Z))1/2

$X=$Y rem $Z

$X=($Y-Z) mod 264

$X=$Y*$Z

wenn $Z)0

wenn $Z=0

sonst

Multiply: VZ-behaftetes Produkt; Überlauf wenn Produkt < -263 oder ( 263

$X=f($Y)/f($Z)

Floating Multiply: Multiplikation zweier GK-Zahlen; Invalid-Exception bei (±0.0)·(±')rH$X=f($Y)*f(Z)

3-17

3.5.5 Bitweise Verknüpfungen

Befehl Operanden



$X,$Y,$Z$X,$Y,Z$X,$Y,$Z$X,$Y,Z$X,$Y,$Z$X,$Y,Z$X,$Y,$Z$X,$Y,Z

$X,$Y,$Z Bitwise multiplex: rMj==1 � $Xj=$Yj, $X,$Y,Z sonst $Xj=$Zj

ORH $X,YZ $X=$X|(YZ<<48)Bitwise or with high wyde: Bitweise ODER-Verknüpfung von Bit 48…63; die restlichen Bits von $X bleiben unverändert

ORMH $X,YZ $X=$X|(YZ<<32)Bitwise or with medium high wyde: Bitweise ODER-Verknüpfung von Bit 32…47; die restlichen Bits von $X bleiben unverändert

ORML $X,YZ $X=$X|(YZ<<16)Bitwise or with medium low wyde: Bitweise ODER-Verknüpfung von Bit 16…32; die restlichen Bits von $X bleiben unverändert

ORL $X,YZ $X=$X|YZBitwise or with low wyde: Bitweise ODER- Verknüpfung von Bit 0…15; die restlichen Bits von $X bleiben unverändert

Bitwise and not medium high wyde: Bitweise UND-NICHT Verknüpfung von Bit 32…47; die restlichen Bits von $X bleiben unverändertBitwise and not high wyde: Bitweise UND-NICHT Verknüpfung von Bit 48…63; die restlichen Bits von $X bleiben unverändert

$X=$X&~(YZ<<32)

$X=$X&~(YZ<<48)

Bitwise and not low wyde: Bitweise UND-NICHT Verknüpfung von Bit 0…15; die restlichen Bits von $X bleiben unverändertBitwise and not medium low wyde: Bitweise UND-NICHT Verknüpfung von Bit 16…32; die restlichen Bits von $X bleiben unverändert

$X=$X&~YZ

$X=$X&~(YZ<<16)

ANDMH

ANDNH

$X,YZ

$X,YZ

$X,YZ

$X,YZ

NAND$X=~($Y&$Z) Bitwise not and:

Bitweise NICHT UND-Verknüpfung$X=~($Y&Z)

ORN Bitwise or-not: Bitweise ODER-NICHT-Verknüpfung

ANDN Bitwise and-not: Bitweise UND-NICHT-Verknüpfung

$X=$Y&~$Z$X=$Y&~Z

$X=$Y|~$Z$X=$Y|~Z

ANDNL

ANDNML

OR Bitwise or: Bitweise ODER-Verknüpfung$X=$Y|$Z$X=$Y|Z

AND Bitwise and: Bitweise UND-Verknüpfung


$X=$Y&$Z$X=$Y&Z

Bitwise not exclusive or: Bitweise NICHT exclusiv-ODER$X=~($Y^Z)

NOR$X=~($Y|$Z) Bitwise not or:

Bitweise NICHT ODER-Verknüpfung$X=~($Y|Z)

XOR Bitwise exclusive or: Bitweise exklusiv-ODER-Verknüpfung

$X=$Y^$Z$X=$Y^Z

MUX$X=($Y&rM)|($Z&~rM)

$X=($Y&rM)|(Z&~rM)

NXOR$X=~($Y^$Z)

3-18

3.5.6 Schiebe-Befehle

Befehl Operanden

$X,$Y,$Z Shift left: Schiebt $Y um $Z bzw. um Z $X,$Y,Z nach links. Auffüllen mit 0. Überlauf möglich.

$X,$Y,$Z

$X,$Y,Z

$X,$Y,$Z Shift right: Schiebt $Y um $Z bzw. um Z $X,$Y,Z nach rechts. Auffüllen mit MSB (VZ).$X,$Y,$Z$X,$Y,Z

SL$X=$Y<<$Z

SR

Wirkung

$X=($Y<<$Z) mod 264

$X=($Y<<Z) mod 264

Erläuterung

SRU$X=$Y>>$Z$X=$Y>>Z

SLU

$X=$Y>>$Z$X=$Y>>Z

$X=$Y<<Z

Shift left unsigned: Schiebt $Y um $Z bzw. Z nach links. Auffüllen mit 0. Kein Überlauf möglich.

Shift right unsigned: Schiebt $Y um $Z bzw. Z nach rechts. Auffüllen mit 0.

3.5.7 Vergleich von Zahlen

Befehl Operanden

$X,$Y,$Z

$X,$Y,Z

$X,$Y,$Z

$X,$Y,Z

FCMP $X,$Y,$ZFloating compare to: GK-Vergleich von $Y und $Z

FEQL $X,$Y,$ZFloating equal to: GK-Vergleich von $Y und $Z


$X=-1, wenn s($Y) < s($Z) $X=0, wenn s($Y) == s($Z) $X=1, wenn s($Y) > s($Z)$X=-1, wenn s($Y) < s(Z) $X=0, wenn s($Y) == s(Z) $X=1, wenn s($Y) > s(Z)

Compare: Vorzeichenbehafteter Vergleich von $Y und $Z bzw. $Y und Z

Floating equivalent (with respect to epsilon): GK-Vergleich von $Y und $Z, N*(u)={x||x-u|� *2Charakteristik}; * wird in rE abgelegt

CMPU

CMP

$X=-1, wenn $Y < $Z $X=0, wenn $Y == $Z $X=1, wenn $Y > $Z$X=-1, wenn $Y < Z $X=0, wenn $Y == Z $X=1, wenn $Y > Z

UND f($Z)+ N*(f($Y))

Compare unsigned: Vergleich von $Y und $Z bzw. $Y und Z

Floating compare (with respect to epsilon): GK-Vergleich von $Y und $Z, N*(u)={x||x-u|� *2Charakteristik}, * wird in rE abgelegt

$X=1, wenn f($Y)+ N*(f($Z))

ODER f($Z)+ N*(f($Y))FCMPE $X,$Y,$Z

UND N*(f($Y)) > f($Z)

FEQLE $X,$Y,$Z

0 sonst

$X=-1, wenn f($Y) < f($Z) $X=0, wenn f($Y) == f($Z) $X=1, wenn f($Y) > f($Z)

$X=1, wenn f($Y) == f($Z) $X=0, sonst

$X=0, wenn f($Y)+ N*(f($Z))

$X=1, wenn f($Y)>N*(f($Z))

$X=-1, wenn f($Y) <

N*(f($Y))<f($Z) < N*(f($Z)) UND

3-19

3.5.8 Bedingte Zuweisungen

Befehl Operanden

$X,$Y,$Z Conditional set if zero: Keine Änderung$X,$Y,Z von $X, wenn Bedingung nicht erfüllt.$X,$Y,$Z Conditional set if nonzero: Keine Änderung$X,$Y,Z von $X, wenn Bedingung nicht erfüllt.$X,$Y,$Z Conditional set if negative: Keine Änderung$X,$Y,Z von $X, wenn Bedingung nicht erfüllt.$X,$Y,$Z Conditional set if nonnegative: Keine Ände-$X,$Y,Z rung von $X, wenn Bedingung nicht erfüllt.$X,$Y,$Z Conditional set if positiv: Keine Änderung$X,$Y,Z von $X, wenn Bedingung nicht erfüllt.$X,$Y,$Z Conditional set if nonpositive: Keine Ände-$X,$Y,Z rung von $X, wenn Bedingung nicht erfüllt.$X,$Y,$Z Conditional set if even: Keine Änderung$X,$Y,Z von $X, wenn Bedingung nicht erfüllt.$X,$Y,$Z Conditional set if odd: Keine Änderung$X,$Y,Z von $X, wenn Bedingung nicht erfüllt.$X,$Y,$Z$X,$Y,Z$X,$Y,$Z$X,$Y,Z$X,$Y,$Z$X,$Y,Z$X,$Y,$Z$X,$Y,Z$X,$Y,$Z$X,$Y,Z$X,$Y,$Z$X,$Y,Z

Zero or set if odd

Zero or set if even

$X,$Y,$Z

$X,$Y,Z $Y mod 2 == 1 � $X=Z, sonst: $X=0

$Y mod 2 == 1 � $X=$Z, sonst: $X=0

Zero or set if positive

Zero or set if nonpositive

ZSEV$X,$Y,$Z $Y mod 2 == 0 � $X=$Z,

$X,$Y,Z $Y mod 2 == 0 � $X=Z, sonst: $X=0

sonst: $X=0

ZSP

Zero or set if zero

Zero or set if nonzero

Zero or set if negative

Zero or set if nonnegative

CSNZ

CSN

CSZ

$Y!=0 � $X=$Z$Y!=0 � $X=Z$Y<0 � $X=$Z$Y<0 � $X=Z


CSNP $Y�0 � $X=$Z$Y�0 � $X=Z

CSNN

$Y==0 � $X=$Z

$Y>0 � $X=$Z$Y<0 � $X=Z

$Y==0 � $X=Z

$Y�0 � $X=$Z$Y�0 � $X=Z

CSE$Y mod 2 == 0 � $X=$Z$Y mod 2 == 0 � $X=Z

CSP

CSO$Y mod 2 == 1 � $X=$Z$Y mod 2 == 1 � $X=Z

ZSNN $Y�0 � $X=$Z, sonst $X=0$Y�0 � $X=Z, sonst $X=0

ZSZ $Y==0 � $X=$Z, sonst $X=0$Y==0 � $X=Z, sonst $X=0

ZSNZ $Y!=0 � $X=$Z, sonst $X=0$Y!=0 � $X=Z, sonst $X=0

ZSN $Y<0 � $X=$Z, sonst $X=0$Y<0 � $X=Z, sonst $X=0

ZSOD

$Y>0 � $X=$Z, sonst $X=0$Y>0 � $X=Z, sonst $X=0

ZSNP $Y�0 � $X=$Z, sonst $X=0$Y�0 � $X=Z, sonst $X=0

3-20

3.5.9 Verzweigungen Bei den angegebenen Befehlen werden Rückwärtssprünge vom Assembler automatisch erkannt und in einen Opcode umgewandelt, der um den Wert 1 grösser ist als der Opcode des Vorwärts-Sprungbefehls Die Zieladresse bei Rückwärtssprüngen berechnet sich zu YZ – 216

Befehl Operanden

Branch if zero: Verzweigung, wenn $X==0 Verzweigung unwahrscheinlichProbable branch if zero: Verzweigung, wenn $X==0, Verzweigung wahrscheinlichBranch if nonzero: Verzweigung, wenn $X!=0, Verzweigung unwahrscheinlichProbable branch if nonzero: Verzweigung, wenn $X!=0, Verzweigung wahrsch.Branch if negative: Verzweigung, wenn $X<0, Verzweigung unwahrscheinlichProbable branch if negative: Verzweigung, wenn $X<0, Verzweigung wahrscheinlichBranch if nonnegative: Verzweigung, wenn $X�0, Verzweigung unwahrscheinlichProbable branch if nonnegative: Verzwei- gung, wenn $X�0, Verzw. wahrsch.Branch if positive: Verzweigung, wenn $X>0, Verzweigung unwahrscheinlichProbable branch if positive: Verzweigung, wenn $X>0, Verzweigung wahrscheinlichBranch if nonpositive: Verzweigung, wenn $X�0, Verzweigung unwahrscheinlichProbable branch if nonpositive: Verzweig., wenn $X�0, Verzweigung wahrsch.Branch if even: Verzweigung, wenn $X gerade, Verzw. unwahrscheinlichProbable branch if even: Verzweigung,wenn $X gerade, Verzw. wahrsch.Branch if odd: Verzweigung, wenn $X ungerade, Verzweigung unwahrsch.Probable branch if odd: Verzweigung, wenn $X ungerade, Verzw. wahrscheinlich

PBEV $X,YZ $X mod 2 == 0 � @=@+4YZ bzw. @=@+4(YZ-216)

BEV $X,YZ $X mod 2 == 0 � @=@+4YZ bzw. @=@+4(YZ-216)

PBOD $X,YZ $X mod 2 == 1 � @=@+4YZ bzw. @=@+4(YZ-216)

BOD $X,YZ $X mod 2 == 1 � @=@+4YZ bzw. @=@+4(YZ-216)

PBNP $X,YZ $X�0 � @=@+4YZ bzw. @=@+4(YZ-216)

BNP $X,YZ $X�0 � @=@+4YZ bzw. @=@+4(YZ-216)

PBP $X,YZ $X>0 � @=@+4YZ bzw. @=@+4(YZ-216)

BP $X,YZ $X>0 � @=@+4YZ bzw. @=@+4(YZ-216)

PBNN $X,YZ$X�0 � @=@+4YZ bzw. @=@+4(YZ-216)

$X!=0 � @=@+4YZ bzw. @=@+4(YZ-216)

BNN $X,YZ$X�0 � @=@+4YZ bzw. @=@+4(YZ-216)

$X,YZ$X<0 � @=@+4YZ bzw. @=@+4(YZ-216)

$X,YZ

BN


PBN $X,YZ $X<0 � @=@+4YZ bzw. @=@+4(YZ-216)

PBNZ

$X,YZ $X==0 � @=@+4YZ bzw. @=@+4(YZ-216)

PBZ

BNZ

BZ

$X,YZ $X==0 � @=@+4YZ bzw. @=@+4(YZ-216)

$X,YZ $X!=0 � @=@+4YZ bzw. @=@+4(YZ-216)

3-21

3.5.10 Sprünge und Funktionsaufrufe

Befehl Operanden

$X,$Y,$Z

$X,$Y,Z

Push register and go: Sichert die Register $0...$(X-1)auf den Registerstack, schreibtanschliessend die Anzahl der gesichertenRegister ebenfalls auf den Registerstack,benennt $(X+1),$(X+2),... in $0,$1,... um, speichert die Adressedes nächsten Befehls in Register rJ undspringt an die durch $Y und $Z bzw. $Y undZ angegebene Adresse.

$(rL+1),$(rL+2),... #

rJ=@+4 @=$Y+$ZX�rG: $0..$(rL-1) # Registerstack rL # Registerstack

X�rL � rL=X

X # Registerstack $(X+1),$(X+2),... #

X<rG:

$0..$(X-1) # Registerstack

X # Registerstack $(X+1),$(X+2),... #

rJ=@+4

X<rG: @=$Y+$Z

GO

$X,$Y,Z

rL # Registerstack

rL=0

@=$Y+ZX�rG: $0..$(rL-1) # Registerstack

$X,$Y,$Z

Go to location: Unbedingter Sprung an die angegebene absolute Adresse. Die Adresse des unmittelbar folgenden Befehls wird in $X abgespeichert.


$X=@+4, @=$Y+$Z

$X=@+4, @=$Y+Z

PUSHGO

# $0,$1,...

# $0,$1,...

# $0,$1,...

# $0,$1,... $(rL+1),$(rL+2)... #

rL=0

Bedingungsloser Sprung mit relativer Adressierung. Opcode Rückwärtssprung = Opcode Vorwärtssprung + 1 wird vom Assembler automatisch umgesetzt

JMP XYZ@=@+4*XYZ bei Vorwärtssprung

@=@+4*(XYZ-224) bei Rückwärtssprung

X�rL � rL=X

rJ=@+4 @=$Y+Z

rJ=@+4

$0..$(X-1) # Registerstack

3-22

Push register and jump:Sichert die Register $0...$(X-1)auf den Registerstack, schreibtanschliessend die Anzahl der gesichertenRegister ebenfalls auf den Registerstack,benennt $(X+1),$(X+2),... in $0,$1,... um, speichert die Adressedes nächsten Befehls in Register rJ undspringt bei einen Vorwärtssprung um4YZ Adressen nach vorne, bzw. bei einemRückwärtssprung |4YZ-252144| Adressen nach hinten.

POP X,YZMacht einen vorausgegangenen PUSHJ-Befehl wieder rückgängig

# $0,$1,...

$0..$(X-1) # Registerstack X # Registerstack

(PUSHJ)-1

PUSHJ $X,YZ

X<rG:

X�rL � rL=X

rJ=@+4

bzw. @=@+4YZ-262144 bei

$(X+1),$(X+2),... #

rJ=@+4

X�rG:

Rückwärtssprung

bzw. @=@+4YZ-262144 bei @=@+4YZ bei Vorwärtssprung

Rückwärtssprung

$0..$(rL-1) # Registerstack

# $0,$1,... $(rL+1),$(rL+2),... #

rL=0

rL # Registerstack

@=@+4YZ bei Vorwärtssprung

3.5.11 Interrupt-Befehle

Befehl Operanden Erläuterung

rW=@+4rX=(1<<63)|(0xFF X Y Z)

$255=rJ

Wirkung

rZ=virt. Speicheradressesonst:

$255=rT

rXX=(1<<63)|(0xFF X Y Z)rYY=YrZZ=Z

rB=$255$255=rJ

Unterbr. Befehl " Speicherbefehl: rY=zu speichernder Wert

rBB=$255rK=0

X,Y,ZTRIP Löst einen Trip aus. Im Anschluss wird der Trip-Handler ab Adresse 0x00 ausgeführt.

TRAP X,Y,Z

Löst einen Trap aus. Im Anschluss wird der Trap-Handler der Betriebssystemroutine, die ab der in rT angegebenen Adresse steht, ausgeführt.

rWW=@+4

rZ=Z rY=Y

3-23

Setzt ein Programm nach einem Interruptfort

@=rW

ZRESUME

(rXX&0xFFFFFFFF) als Be- ropcode==0x00 �

Z==0: Rückkehr aus Trip- Handler ropcode==0x00 � (rX&0xFFFFFFFF) als Be- fehl an Stelle rW-4 ausfüh- ren

Seitentabelleneintrag für die virtuelle Andresse in rYY angesehen wird

ropcode==0x01 � (rX&0xFFFFFFFF) als Be- fehl an Stelle rW-4 ausfüh- ren, Operanden jedoch aus rY und rZ nehmen ropcode==0x02 � (rX&0xFFFFFFFF) als Be-

ropcode==0x03 � (rXX&0xFFFFFFFF) als Be- fehl an Stelle rWW-4 ausfüh-

fehl an Stelle rWW-4 ausfüh- ren

Z==1: Rückkehr aus Trap-

rK=$255 $255=rBB

Handler

ren, wobei rZZ jedoch als

(rXX&0xFFFFFFFF) als Be- fehl an Stelle rWW-4 ausfüh- ren, Operand $X jedoch durch rZZ ersetzen

sonst: Auslösung des Interrupts "illegal instruction"

ropcode==0x01 � (rXX&0xFFFFFFFF) als Be- fehl an Stelle rWW-4 ausfüh- ren, Operanden jedoch aus rYY und rZZ nehmen ropcode==0x02 �

ropcode==0x80 � @=rWW

ropcode==0x80 �

fehl an Stelle rW-4 ausfüh- ren, Operand $X jedoch

virtuelle Andresse in rYY angesehen wird

durch rZ ersetzen ropcode==0x03 � (rX&0xFFFFFFFF) als Be- fehl an Stelle rW-4 ausfüh- ren, wobei rZZ jedoch als Seitentabelleneintrag für die

3-24

3.5.12 Gleitkomma-Konvertierung

Befehl Operanden

$X,$Z$X,Z$X,$Z$X,Z

$X,$Z

$X,Z

$X,$Z

$X,Z

SFLOTU

Convert fixed to short float unsigned: Wandelt eine ganze vorzeichenlose Zahl in eine 32-Bit-GK-Zahl um. Die Zahl wird zuerst in eine 32-Bit-Zwischengröße gewandelt, wobei Rundungsfehler auftreten können.

$X=f(t($Z))

$X=f(t(Z))

SFLOT

Convert fixed to short float: Wandelt eine ganze vorzeichenbehaftete Zahl in eine 32-Bit-GK-Zahl um. Die Zahl wird zuerst in eine 32-Bit-Zwischengröße gewandelt, wobei Rundungsfehler auftreten können.

$X=f(t(s($Z)))

$X=f(t(s(Z)))

FINT Floating integer: Runden einer GK-Zahl auf eine ganze Zahl; Ergebnis wieder GK-Zahl


$X,$Z $X=f(int(f($Z)))

FLOT$X=f(s($Z)) Convert fixed to floating: VZ-behaftete

Konvertierung Integer ĺ GK-Zahl$X=f(s(Z))

FLOTU$X=f(u($Z)) Convert fixed to floating unsigned: VZ-lose

Konvertierung Integer ĺ GK-Zahl$X=f(u(Z))

FIXU Convert floating to fixed unsigned: Konvertierung GK-Zahl ĺ VZ-loser Integer

FIX Convert floating to fixed: Konvertierung GK-Zahl ĺ VZ-behafteter Integer

$X,$Z

$X,$Z

$X=s(int(f($Z)))

$X=int(f($Z)) mod 264

3-25

3.5.13 Andere Operationen

Befehl Operanden

$X,$Y,$Z

$X,$Y,Z

X,$Z

X,Z

UNSAVE $Z

Restauriert den zuvor von einem SAVE-Befehl auf dem Registerstack abgelegten Kontext. $Z muß hierbei die Adresse sein, die von dem vorausgehenden SAVE-Befehl zurückgegeben wurde

SWYM X,Y,Z Sympathize with your machinery. Entspricht einem nop-Befehl.

FUN $X,$Y,$ZFloating unordered: Test, ob $Y und $Z echte Zahlen sind, NaN " Not a number

Multiple or: Octabyte als 8x8-Matrix; Matrixmultiplikation mit XOR und UND

$X=1, wenn $Y==NaN ODER $Z==NaN,

$X,$Y,$Z

$X,$Y,Z$Xij=($Y0j&Zi0)^ ... ...^($Y7j&Zi7)

$X,$Y,Z$Xij=($Y0j&Zi0)|...

Multiple or: Octabyte als 8x8-Matrix; Matrixmultiplikation mit ODER und UND

Speichert den aktuellen Kontext auf den Registerstack. In $X wird im Anschluss die oberste Stackadresse abgelegt, wobei $X ein globales Register sein muß.

(SAVE)-1

nop

$X=oberste Stackadresse

$X,0SAVErW,rX,rY,rZ # Registerstack(rG<<56)|(rA&0xFFFFFFFF) ĺ Registerstack

$0...$(rL-1),$G...$255,rB,rD,rE,rH,rJ,rM,rR,rP

L=0

PUTg[X]=$Z

g[X]=ZSchreibt einen Wert in ein Spezialregister

GETA

Get address: Lädt eine Adresse in das Register X, wobei relativ adressiert wird. Opcode Rückwärtsverweis = Opcode Vorwärtsverweis + 1

$X,Label$X=@+4*YZ bei Vorwärtsverweis

$X=@+4*YZ-216 bei Rückwärts-verweis

GET Lädt den Wert des Spezialregisters mit der laufenden Nummer Z in ein Allzweckregister

$X,Z $X=g[Z]

$X=0, sonst

SADD

$Xij=($Y0j&$Zi0)|...

MOR

$X,$Y,$Z

...^($Y7j&$Zi7)MXOR

...|($Y7j&$Zi7)

...|($Y7j&Zi7)$Xij=($Y0j&$Zi0)^ ...


Sideways add: zählt die Anzahl der Bit-Positionen, an denen $Y==1 und $Z==0 bzw. $Y==1 und Z==0

$X=Bitanzahl($Y&~$Z)

$X=Bitanzahl($Y&~Z)

FUNE $X,$Y,$Z$X=1, wenn $Y==NaN ODER $Z==NaN ODER rE==NaN $X=0, sonst

Floating unordered (with respect to epsilon): Test, ob $Y,$Z und rE echte Zahlen sind, NaN bedeutet: not a number

3-26

3.6 Befehlscodierung

3.6.1 Allgemein Befehl besteht aus den vier Feldern

! Marke ! Befehlscode ! Operanden ! Kommentar

Programmieren: Marken, Befehle, Operanden und Kommentar im Programmcode als Zeichenkette hinschreiben (für den Menschen gut lesbar). Befehlscodierung: Umwandlung der Zeichenketten in Zahlen (Nullen und Einsen).

! Zahlen für den Prozessor „gut lesbar“ ! wird vom Assembler während der Assemblierung durchgeführt

Es werden nur diejenigen Zeichenketten umgewandelt, die für die Ausführung des Programms not-wendig sind

! Marken werden in Adressen umgerechnet + wenn eine Marke als Sprungziel verwendet wurde, dann wird je nach Sprungbefehl entwe-

der die die Marke repräsentierende Adresse oder die Adress-Differenz zwischen dem Sprungbefehl und der Marke als Operand angegeben

+ wenn eine Marke als Variablenname verwendet wurde, dann wird bei der jeweiligen Refe-renzierung die zugehörige Adresse verwendet

! das Befehls-Feld (Mnemocode), also z.B. die Zeichenfolge ADD, wird gemäss nachfolgender

Tabelle in Zahlen (z.B. 0x20) übersetzt

! die Operanden werden gemäss ebenfalls in Zahlen übersetzt

! Kommentare werden weggelassen

Marke ADD $1,$2,$3 Kommentar

0x20 0x01 0x02 0x03

00000001 00000010 0000001100100000

1 Byte 1 Byte 1 Byte 1 Byte

übersetztesBefehlswort:

X Y ZOpcode

Abb. 104: Befehlscodierung

3-27

3.6.2 Codierung des Opcodes Das Befehls-Feld (Opcode, Mnemocode) wird gemäss nachfolgender Tabelle übersetzt.

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&

FMUL 4& FCMPE 4& FUNE & FEQLE 4& FDIV 40& FSQRT 40& FREM 4& FINT 4&

SETH & SETMH & SETML & SETL & INCH & INCHM & INCML & INCL &ORH & ORMH & ORML & ORL & ANDNH & ANDNMH & ANDNML & ANDNL &

POP 3& RESUME 5& SYNC & SWYM & GET & TRIP 5&0x..8 0x..9 0x..A 0x..B 0x..C 0x..D 0x..E 0x..F

SUB[I] &

CSNP[I] &ZSP[I] &

SUBU[I] &16ADDU[I] &NEGU[I] &SRU[I]&

BOD[B] &+,BEV[B] &+,PBOD[B] 3&-,

CMPU[I] &SLU[I] &BZ[B] &+,BNZ[B] &+,PBZ[B] 3&-,

CSNZ[I] &ZSZ[I] &

ADD[I] &

CSNN[I] &ZSN[I] &

ADDU[I] &4ADDU[I] &

PBNZ[B] 3&-,CSZ[I] &

0x0.. 0x0..FLOT[I] 4& FLOTU[I] 4& SFLOT[I] 4& SFLOTU[I] 4&

PUSHJ[B] & GETA[B] & PUT[I] &[UN]SAVE 20µ+&

XOR[I] &NXOR[I] &ODIF[I] &MXOR[I] &

STWU[I] µ+&STOU[I] µ+&STUNC[I] µ+&PUSHGO[I] 3&

LDWU[I] µ+&LDOU[I] µ+&LDUNC[I] µ+&GO[I] 3&

CSOD[I] &PBEV[B] 3&-,

ZSEV[I] &

CSEV[I] &ZSOD[I] &

NAND[I] &TDIF[I] &MOR[I] &

STO[I] µ+&STCO[I] µ+&SYNCID[I] &NOR[I] &

LDO[I] µ+&CSWAP[I] 2µ+2&PREGO[I] &STW[I] µ+&

PBNP[B] 3&-,CSP[I] &

ZSNP[I] &LDW[I] µ+&

BNP[B] &+,PBP[B] 3&-,

8ADDU[I] &NEG[I] &SR[I] &BP[B] &+,

ORN[I] &ANDN[I] &WDIF[I] &SADD[I] &

STBU[I] µ+&STTU[I] µ+&STHT[I] µ+&PREST[I] &

LDBU[I] µ+&LDTU[I] µ+&LDHT[I] µ+&PRELD[I] &

ZSNZ[I] &

BDIF[I] &MUX[I] &

JMP[B] &

STSF[I] µ+&SYNCD[I] &OR[I] &AND[I] &

LDSF[I] µ+&LDVTS[I] &STB[I] µ+&STT[I] µ+&

BNN[B] &+,PBN[B] 3&-,PBNN[B] 3&-,CSN[I] &

ZSNN[I] &LDB[I] µ+&LDT[I] µ+&

2ADDU[I] &CMP[I] &SL[I] &BN[B] &+,

0xC..

0xD..

0xE..

0xF..

0x8..

0x9..

0xA..

0xB..

0xD..

0xE..

0xF..

0x1..

0x2..

0x3..

0x4..

0x5..

0x6..

0x7..

0x9..

0xA..

0xB..

0xC..

0x5..

0x6..

0x7..

0x8..

0x1..

0x2..

0x3..

0x4..

MUL[I] 10& MULU[I] 10& DIV[I] 60& DIVU[I] 60&

Das erste Nibble (4 Bit-Wert) des Opcodes entspricht der Doppelzeile (0 bis 15), in der sich der Be-fehlscode befindet. Das zweite Nibble des Opcodes ergibt sich wie folgt:

! MSB (Bit Nr. 3) des zweiten Nibbles + 0, wenn sich der Befehl im oberen Teil der Doppelzeile befindet + 1, wenn sich der Befehl im unteren Teil der Doppelzeile befindet

! Bits 2, 1 und 0 des zweiten Nibbles entsprechen der Spalte (0 bis 7), in dem sich der Befehls-

code befindet [I] bedeutet: Immediate-Variante des Befehls

! immediate " Direktoperand ! ADD $1,$2,$3: nicht immediate, da der 3. Operand ein Register ist und keine Zahl ! ADD $1,$2,3: immediate, da als 3. Operand eine Zahl angegeben ist und kein Register ! der Opcode der immediate-Variante eines Befehls ist immer um 1 höher als die nicht-

immediate-Variante des Befehls (steht in der Doppelspalte also rechts) ! eine immediate-Variante des Befehls wird vom Assembler automatisch anhand des fehlenden

Dollar-Zeichens ($) erkannt, weshalb im Programm nicht explizit ADDI geschrieben werden muss

3-28

[B] bedeutet: Backward-Variante des Befehls � Rückwärtssprung

! wird bei Sprüngen rückwärts gesprungen, wird der Sprungbefehl durch einen um 1 höheren Opcode als beim Vorwärtssprung codiert

! Rückwärtssprung " rechter Teil einer Doppelspalte & gibt an, wieviele Takte der betreffende Befehl zur Ausführung benötigt

! & " Befehl benötigt einen Takt ! steht vor dem Zeichen & noch eine Zahl x, so werden zur Ausführung des Befehls vom MMIX-

Prozessor x Takte benötigt µ gibt an, wieviele Speicher-Zeiteinheiten der betreffende Befehl für einen Speicherzugriff benötigt, wobei beim Praktikums-Simulator mmix eine Speicher-Zeiteinheit 232 Takte, also 232

& beträgt , bedeutet: 2&, wenn gesprungen wird, sonst 0&; der Befehl BZ benötigt also & + , = & + 2& = 3&, wenn gesprungen wird und & + , = & + 0& = &, wenn nicht gesprungen wird Beispiel: Befehl ADD $1,$2,$3

! ADD steht in der Doppelzeile Nr. 2 � erstes Nibble des Opcodes ist 2 � 0x2… ! ADD steht in der ersten Doppelspalte im oberen Teil der Doppelzeile 2 � zweites Nibble ist ent-

weder 0 oder 1, gesamter Opcode ist also entweder 0x20 oder 0x21 ! 3. Operand ($3) ist Register � nicht immediate, also im linken Teil der Doppelspalte � Opcode

ist 0x20 ! in der Tabellenzelle steht zusätzlich noch & � der ADD-Befehl benötigt zur Ausführung genau

einen Takt und keinen Speicherzugriff (µ kommt nicht vor) 3.6.3 Codierung der Operanden

! Register $0 … $255 werden zu 0x00 … 0xFF übersetzt (es wird also einfach die Register-nummer als vorzeichenlose 8 Bit-Zahl dargestellt)

! Vorzeichenbehaftete immediate-Operanden -128 … 127 werden im 2er-Komplement darge-

stellt + Prozessor erkennt die Codierung vorzeichenloser/vorzeichenbehafteter Zahlen anhand des

Opcodes • ADDI = 0x21 � 3. Operand ist vorzeichenbehaftete Zahl • ADDIU = 0x23 � 3. Operand ist vorzeichenlose Zahl (U steht hier für unsigned)

! Vorzeichenlose immediate-Operanden 0 … 255 werden ebenfalls zu 0x00 … 0xFF übersetzt

(die Zahl wird also einfach als vorzeichenlose 8 Bit-Zahl dargestellt)

3-29

3.7 Programmierung

3.7.1 Funktionsaufrufe • Motivation

! Modularität: Zerlegung eines (grossen) Problems in mehrere kleinere Probleme, die dann unab-hängig von einander gelöst werden können

+ Funktion löst ein kleines Teilproblem + Programm ruft mehrere Funktionen auf und löst damit das (grosse) Problem

! Strukturierung von Programmen

+ Programme werden wesentlich einfacher lesbar

! verteilte Entwicklung durch definierte Schnittstellen + Funktionen können unabhängig voneinander entwickelt werden + Einsatz mehrerer Programmierer � kürzere Projektzeit + definierte Schnittstellen � jeder Programmierer weiß genau, welche Daten er als Eingabe-

Parameter bekommt und welche er als Rückgabewert zurückliefern muss

! separate Übersetzung + es muss nicht immer bei Änderung einer einzigen Funktion das gesamte Programm über-

setzt werden + � Zeitersparnis bei grossen Programmen

! Verwendung von Programmbibliotheken

+ bereits implementierte Lösungen können wiederverwendet werden • Ablauf der Verwendung einer Funktion (allgemein)

! der Funktionsaufrufer bringt die der Funktion zu übergebenden Parameter in den Zugriffsbe-reich der Funktion

! Funktionsaufruf

+ der Funktionsaufrufer übergibt die Kontrolle an die Funktion, indem er den Befehlszähler28 auf die Einsprungadresse der Funktion setzt

+ die Rücksprungadresse wird entweder explizit durch den Funktionsaufrufer/die Funktion o-der implizit durch den verwendeten Sprung-Befehl gerettet

! die Funktion alloziert Speicher für ihre Ausführung ! die Funktion liest die ihr übergebenen Parameter ein ! die Funktion berechnet aus den übergebenen Parametern ein Ergebnis ! die Funktion bringt das Ergebnis in den Zugriffsbereich des Aufrufers ! die Funktion lädt die Rücksprungadresse in den Befehlszähler, wodurch zum Funktionsaufrufer

zurück gesprungen wird ! der Funktionsaufrufer liest das von der Funktion bereitgestellt Ergebnis aus

28 Der Befehlszähler ist ein Register (Datenspeicher), der die Adresse des nächsten auszuführenden Befehls beinhaltet und wird im Rahmen der Betrachtungen des Datenpfads (Kap. 7 und 10) näher erläutert. Der Aufbau des Befehlszählers ist in Kapi-tel 1.4.7 dargestellt.

3-30

• Parameterübergabe in Registern In diesem Abschnitt wird lediglich auf die Parameterübergabe eingegangen. Das Sichern bzw. Restau-rieren des Befehlszählers, Allozieren von Speicher etc. wird hier nicht betrachtet.

! Parameterübergabe mittels direkter Wertangabe (call by value)

+ die Daten, die der Funktion übergeben werden sollen, stehen ursprünglich entweder in Re-gistern oder im Arbeitsspeicher

+ zur Übergabe an die Funktion werden die zu übergebenden Daten in zuvor vereinbarte Re-gister geladen (es wird also eine Kopie der Daten in den vereinbarten Registern abgelegt) und von der Funktion dann dort abgeholt

+ Nachteile

• bei grossen Datenmengen reichen die Register nicht aus • kopieren grosser Datenmengen zeitaufwendig • die Funktion hat keinen Zugriff auf die Original-Daten, sondern nur auf die Kopie, kann

also die Originaldaten nicht verändern

+ � lediglich dann sinnvoll, wenn nur wenige Parameter übergeben werden sollen

+ Ablauf (vgl. nachfolgende Abbildung) • der Funktionsaufrufer legt die zu übergebenden Daten in zuvor vereinbarte Register ab

(1) • der Funktionsaufrufer ruft die Funktion auf (2) • die Funktion holt sich die Daten aus den zuvor vereinbarten Registern (3)

+ Rückgabe eines Ergebnisses von der Funktion zum Aufrufer funktioniert analog

Wert des zweiten Datums

Register

Wert des ersten Datums$0$1$2

$n

Wert des er-

sten DatumsWert des er-sten Datums

Aufruf

Aufrufer Funktion

1

2

3

Wert des zwei-

ten DatumsWert des zwei-

ten Datums

Abb. 105: Parameterübergabe mittels direkter Wertangabe

! Parameterübergabe mittels Referenz (call by reference)

+ es werden nicht die Daten selbst, sondern lediglich Zeiger auf die Daten im Arbeitsspeicher (also Adressen) übergeben

+ Vorteile

• selbst bei grossen Datenmengen müssen maximal ein paar Zeiger kopiert werden

3-31

• obwohl wieder nur eine Kopie des Zeigers an die Funktion übergeben wird, kann die Funktion die Daten jetzt auch verändern, da ihr ja über den Zeiger die Adresse der Ori-ginal-Daten mitgeteilt wird

+ � vor allem bei grossen Datensätzen (z.B. Matrix mit 1000 x 1000 Einträgen) sinnvoll

+ Ablauf (vgl. nachfolgende Abbildung)

• der Funktionsaufrufer legt die Parameter im Speicher ab (ist in der Regel überflüssig, da die Parameter sich im Allgemeinen bereits im Speicher befinden) (1)

• der Funktionsaufrufer legt Zeiger auf die Parameter (in nachfolgender Abbildung als Ad-resse 0x… geschrieben) in zuvor vereinbarte Register ab (2)

• der Funktionsaufrufer ruft die Funktion auf (3) • die Funktion holt sich die Adressen der Parameter aus den zuvor vereinbarten Regis-

tern (4) • die Funktion greift mittels der aus den Registern geholten Adressen auf den Arbeits-

speicher zu (5) und holt sich die Parameter vom Speicher ab (6)

+ Rückgabe eines Ergebnisses von der Funktion zum Aufrufer funktioniert analog

Register

0x...$0$1$2

$n

Speicher

ƎLDV\0Ǝ

0x000x080x10

0x...

Aufrufer Funktion

Aufruf

Adressen holen

0x...

ƎLDV\0Ǝ

0x...

0x...

1

3

24

5

6ƎLDV\0Ǝ

2004

$3

0x...

0x...2004

0x...

0x...

0x...

2004

Abb. 106: Parameterübergabe als Referenz

! Probleme + Register, in denen die Parameter bzw. die Zeiger auf die Parameter stehen, müssen vorher

vereinbart worden sein + was passiert, wenn mehr Parameter übergeben werden sollen, als der Prozessor Register

zur Verfügung hat? + was passiert, wenn in den Registern bereits Parameter aus einem vorhergegangenen Funk-

tionsaufruf stehen, die noch gebraucht werden (z.B. bei rekursiv aufgerufenen Funktionen)?

! Lösung + Bei der „Parameterübergabe mittels direkter Wertangabe“ (call by value) werden die Para-

meter im Arbeitsspeicher (auf dem Stack, vgl. nachfolgendes Kapitel) übergeben + Bei der „Parameterübergabe mittels Referenz“ (call by reference) werden sowohl die Para-

meter, als auch die Adressen auf die Parameter im Arbeitsspeicher (auf dem Stack, vgl. nachfolgendes Kapitel) übergeben

3-32

• Parameterübergabe auf dem Stack

! Stack + Speicher, der von hohen Adressen zu niedrigen Adressen hin wächst + Der konstante Zeiger „Bottom Of Stack“ (BOS) zeigt auf den Stack-Boden, entspricht also

der Adresse des leeren Stacks + Zugriff auf Daten erfolgt nicht über die Angabe absoluter Adressen, sondern stets relativ

zum sog. Stackpointer (SP) + der Stackpointer (SP)

• zeigt stets auf das zuletzt auf dem Stack abgelegte Datum (ist also variabel) • ist eine Adresse, die in einem globalen Register steht

+ Beispiel: Am Ende des Datensegments beginnender Stack beim MMIX-Prozessor

0x20000000000000000x20000000000000080x2000000000000010

0x3FFFFFFFFFFFFFF80x4000000000000000

0x3FFFFFFFFFFFFFF00x3FFFFFFFFFFFFFE80x3FFFFFFFFFFFFFE00x3FFFFFFFFFFFFFD8

BOS

SP

Abb. 107: Stack beim MMIX-Prozessor

! Schreiben eines Datums auf den Stack (push) + erhöhen des Stackpointers (1) 29 + Abspeichern des Datums an der Adresse, die dem (neuen) Stackpointer entspricht (2)

SP1 DatumSP

2

Abb. 108: Schreiben eines Datums auf den Stack

! Lesen eines Datums vom Stack (pop)

+ Auslesen des Datums, auf das der Stackpointer zeigt (1) + Stackpointer dekrementieren (2) 30

DatumSP2

DatumSP

1

Abb. 109: Lesen eines Datums vom Stack

29 Das Erhöhen bezieht sich hier auf die grafische Darstellung, in der der Stackpointer „nach oben“ wandert. Die Adresse, die der Stackpointer repräsentiert, wird hierbei verringert. 30 Das Verringern bezieht sich hier auf die grafische Darstellung, in der der Stackpointer „nach unten“ wandert. Die Adresse, die der Stackpointer repräsentiert, wird hierbei erhöht.

3-33

! Vereinbarungen zur Verwendung des Stacks für Funktionsaufrufe + eine Funktion soll ihr Ergebnis immer an diejenige Stelle im Stack schreiben, an der ihr zu-

vor der Funktionsparameter übergeben wurde + wurden mehrere Parameter übergeben, soll die Stelle mit der höchsten Adresse verwendet + Beim Rücksprung aus der Funktion soll der Stackpointer immer auf das Ergebnis zeigen, so

dass die aufrufende Funktion nach dem Auslesen des Parameters und dem Anpassen des Stackpointers den Stack wieder in dem Zustand vorfindet, in dem er sich vor dem Funkti-onsaufruf befand

+ der Inhalt von Register $0 • darf bei einem Funktionsaufruf verloren gehen • muss beim Rücksprung aus einer Funktion nicht wiederhergestellt werden • kann also zur Aufnahme der Rücksprungadresse verwendet werden

! Beispiel zum Ablaufs eines Funktionsaufrufs mit Hilfe des Stacks beim MMIX-Prozessor31

+ Initialisierung des Stack-Bodens (BOS) und des Stackpointers (SP) BOS GREG #4000000000000000

SP GREG #4000000000000000

0x4000000000000000 (BOS)SP

Abb. 110: Leerer Stack nach der Initialisierung

+ der Funktionsaufrufer legt die Parameter auf dem Stack ab SUB SP,SP,3*8 alternativ32: SUB SP,SP,8

STO a,SP,0 STO c,SP,0 STO b,SP,1*8 SUB SP,SP,8 STO c,SP,2*8 STO b,SP,0 SUB SP,SP,8 STO a,SP,0

0x4000000000000000 (BOS)

SP

c

b

a

Abb. 111: Ablegen der Parameter auf den Stack

+ der Funktionsaufrufer übergibt die Kontrolle an die Funktion fkt

• gemäß voriger Vereinbarungen wird die Rücksprungadresse im Register $0 abgelegt (vgl. erster Parameter des GO-Befehls)

• der Inhalt des Stacks bleibt unverändert

GO $0,fkt 31 Das hier vorgestellte Verfahren benutzt einen selbstimplementierten Stack, d.h. der Programmierer (oder der Compiler) muss den Stack selbst verwalten. Bei dem im Anhang beschriebenen Register-Stack des MMIX-Prozessors wird die Stackverwaltung von der Hardware übernommen bzw. von der Hardware direkt unterstützt. 32 Es kann natürlich auch beim Schreiben jedes einzelnen Parameters auf den Stack der Stackpointer geändert werden, wofür jedoch deutlich mehr Befehle benötigt werden � zeitaufwendiger.

3-34

+ die Funktion fkt sichert die im Register $0 übergebene Rücksprungadresse auf den Stack

SUB SP,SP,8 STO $0,SP,0

0x4000000000000000 (BOS)

SP

c

b

a

$0

Abb. 112: Sicherung der Rücksprungadresse auf den Stack

+ die Funktion fkt sichert die von ihr verwendeten Register auf den Stack • beim Rücksprung zum Funktionsaufrufer können die von fkt überschriebenen Register

dann wieder hergestellt werden • der Funktionsaufrufer findet so nach dem Aufruf der Funktion fkt die von ihm verwen-

deten Register wieder so vor, wie sie vor dem Aufruf von fkt waren • vom Funktionsaufrufer in den Registern abgelegte Daten gehen durch den Funktions-

aufruf somit nicht verloren

SUB SP,SP,4*8 STO i,SP,0 STO j,SP,1*8 STO k,SP,2*8 STO l,SP,3*8

0x4000000000000000 (BOS)

SP

c

b

a

$0

k

j

i

l

Abb. 113: Sicherung der von der Funktion fkt verwendeten Register auf den Stack

+ die Funktion fkt lädt die ihr übergebenen Parameter vom Stack in die von ihr benutzten Register


LDO i,SP,5*8

LDO j,SP,6*8 LDO k,SP,7*8

+ die Funktion fkt verarbeitet die Parameter


3-35

+ die Funktion ruft evtl. eine weitere Funktion fkt2 auf

• die Funktion fkt legt die Parameter für die Funkion fkt2 auf dem Stack ab SUB SP,SP,2*8

STO l,SP,0 STO i,SP,1*8

0x4000000000000000 (BOS)

SP

c

b

a

$0

k

j

i

i

l

l

Abb. 114: Übergabe der Paramter für die Funktion fkt2 auf dem Stack

• die Funktion fkt übergibt die Kontrolle an die Funktion fkt2

! die Rücksprungadresse kann wieder im Register $0 abgelegt werden ! Überschreiben des Registers $0 ist kein Problem, da es zuvor direkt nach dem

Sprung in die Funktion fkt auf den Stack gesichert wurde ! der Inhalt des Stacks bleibt unverändert

GO $0,fkt2

• die Funktion fkt2 sichert die ihr im Register $0 übergebene Rücksprungadresse auf den Stack

SUB SP,SP,8

STO $0,SP,0

0x4000000000000000 (BOS)

SP

c

b

a

$0

k

j

i

i

l

$0

l

Abb. 115: Sicherung der Adresse zum Rücksprung in die Funktion fkt

3-36

• die Funktion fkt2 sichert nun wiederum die von ihr verwendeten Register auf den Stack, um diese nicht zu überschreiben, falls der Funktionsaufrufer (hier die Funktion fkt) Daten darin abgelegt hat

SUB SP,SP,3*8

STO p,SP,0 STO q,SP,1*8 STO r,SP,2*8

0x4000000000000000 (BOS)

SP

c

b

a

$0

k

j

i

i

l

$0

r

q

p

l

Abb. 116: Die Funktion fkt2 sichert die von ihr verwendeten Register

• die Funktion fkt2 lädt die ihr übergebenen Parameter vom Stack in die von ihr ver-wendeten Register

! der Inhalt des Stacks bleibt unverändert

LDO p,SP,4*8

LDO q,SP,5*8

• die Funktion fkt2 verarbeitet die Parameter

• an dieser Stelle könnte die Funktion fkt2 eine weitere Funktion aufrufen (wird hier nicht durchgeführt)

• die Funktion fkt2 hat nun ihr Ergebnis berechnet und will wieder zum Aufrufer (hier: Funktion fkt) zurückspringen

3-37

• die Funktion fkt2 legt zuerst gemäß voriger Vereinbarung das Ergebnis auf dem Stack ab

! Ergebnis befindet sich in einem Register, muss also von einem Register auf den

Stack gespeichert werden ! der Funktionsaufrufer (hier: fkt) kann dann nach dem Rücksprung aus fkt2 das

Ergebnis vom Stack einlesen

STO r,SP,5*8

0x4000000000000000 (BOS)c

b

a

$0

k

j

i

r

l

$0

r

SP

q

p

l

Abb. 117: Die Funktion fkt2 legt ihr Ergebnis auf dem Stack ab

• die Funktion fkt2 stellt nun zunächst die von ihr verwendeten Register wieder her

! die Funktion fkt2 lädt die zu Beginn von fkt2 auf den Stack gesicherten Inhalte der von ihr verwendeten Register p, q und r wieder in die Register p, q und r zu-rück

! für den Aufrufer von fkt2 (hier also für fkt) erscheint es deshalb so, als hätte die Funktion fkt2 die Register gar nicht geändert


LDO p,SP,0 LDO q,SP,1*8 LDO r,SP,2*8

• die Funktion fkt2 liest die Rücksprungadresse vom Stack und legt sie in Register $0 ab


LDO $0,SP,3*8

3-38

• die Funktion fkt2 passt nun den Stackpointer so an, dass er auf den Rückgabewert zeigt

! die auf dem Stack abgelegten Daten, die sich in der nachfolgenden Abbildung „o-

berhalb des Stackpointers“ befinden, werden dabei nicht gelöscht!

ADD SP,SP,5*8

0x4000000000000000 (BOS)c

b

a

$0

k

j

i

r

l

$0

r

SP

q

p

l

Abb. 118: Die Funktion fkt2 passt den Stackpointer an

• die Funktion fkt2 springt zum Funktionsaufrufer (hier fkt) zurück

! Sprungziel steht in Register $0 (� zweiter Operand des GO-Befehls ist $0; dritter

Operand des GO-Befehls ist 0, da zum zweiten Operanden nichts dazugezählt wer-den soll)

! die Adresse für einen theoretischen Rücksprung in die Funktion fkt2 (der natürlich nie durchgeführt wird), wird wieder in Register $0 abgelegt (vgl. erster Operand des GO-Befehls)


GO $0,$0,0

+ die Funktion fkt liest nun das Ergebnis der Funktion fkt2 vom Stack aus und passt den Stackpointer so an, dass er sich wieder in dem Zustand befindet, in dem er vor dem Aufruf der Funktion fkt2 war

LDO k,SP,0

ADD SP,SP,8

0x4000000000000000 (BOS)c

b

a

$0

k

j

i

r

l

$0

r

SP

q

p

l

Abb. 119: Stack nach dem Auslesen des Ergebnisses von fkt2

3-39

+ die Funktion fkt führt weitere Berechnungen durch und ruft hierzu evtl. weitere Funktionen

auf

+ die Funktion fkt hat nun ihr Ergebnis berechnet und will wieder zum Aufrufer zurücksprin-gen

+ die Funktion fkt legt zuerst ihr Ergebnis auf dem Stack ab

STO j,SP,7*8

0x4000000000000000 (BOS)j

b

a

$0

k

j

i

r

l

$0

r

SP

q

p

l

Abb. 120: Die Funktion fkt legt ihr Ergebnis auf dem Stack ab

+ die Funktion fkt stellt nun zunächst die von ihr verwendeten Register wieder her

• keine Änderung des Stack-Inhalts

LDO i,SP,0 LDO j,SP,1*8 LDO k,SP,2*8 LDO l,SP,3*8

+ die Funktion fkt liest die Rücksprungadresse vom Stack und legt sie in Register $0 ab


LDO $0,SP,4*8

3-40

+ die Funktion fkt passt nun den Stackpointer so an, dass er auf den Rückgabewert zeigt

• die auf dem Stack abgelegten Daten, die sich in der nachfolgenden Abbildung „oberhalb des Stackpointers“ befinden, werden dabei nicht gelöscht!

ADD SP,SP,7*8

0x4000000000000000 (BOS)j

b

a

$0

k

j

i

r

l

$0

r

SP

q

p

l

Abb. 121: Die Funktion fkt passt den Stackpointer an

+ die Funktion fkt springt zum Funktionsaufrufer zurück


GO $0,$0,0

+ der Funktionsaufrufer liest nun das Ergebnis der Funktion fkt vom Stack aus und passt den Stackpointer wieder an, so dass er dann wieder in dem Zustand ist, in dem er vor dem Aufruf von fkt war

LDO $1,SP,0 ADD SP,SP,8

0x4000000000000000 (BOS)j

b

a

$0

k

j

i

r

l

$0

r

SP

q

p

l

Abb. 122: Stack nach dem Auslesen des Ergebnisses von fkt

3-41

! Vorteile der Parameterübergabe auf dem Stack + einheitliche Übergabe der Parameter + Rekursion möglich, da Parameter bei rekursivem Aufruf nicht überschrieben werden

! Nachteil der Parameterübergabe auf dem Stack + viele Zugriffe auf den Arbeitsspeicher � langsam + bei einem Fehler in der Stackverwaltung wird als Rücksprungadresse evtl. irgendein Da-

tum/Parameter etc. verwendet � Programm springt plötzlich unkontrolliert irgendwo hin • Programm stürzt ab • Programm überschreibt evtl. wichtige Daten

Ein besseres Konzept zur Parameterübergabe auf dem Stack stellt der sog. Register-Stack dar, der im Anhang besprochen wird

3-42

3.7.2 Erzeugung von Namensräumen • Motivation

! wird in einem Programm der Name eines Registers bzw. einer Marke mehrfach definiert, weiß der Assembler nicht, welche Definition bei der Verwendung der Marke gemeint ist � Fehler-meldung

! in der Programmiersprache C:

+ Variable und Marken in unterschiedlichen Funktionen können die selben Namen haben

! woher kann eine Funktion wissen, welche Namen für Register und Marken bereits von anderen Funktionen bzw. vom Hauptprogramm verwendet wurden?

! Lösung

+ jedem Namen wird der Name der Funktion vorangestellt, in der er definiert wurde + wird in den beiden Funktionen fkt1 und fkt2 dann derselbe Name name definiert, wird

vom Assembler der in der Funktion fkt1 verwendete Name als fkt1name und der in der Funktion fkt2 verwendete Name als fkt2name bearbeitet

+ zur besseren Trennung zwischen Funktionsname und Name der Marke/des Registers kön-nen noch Trennzeichen wie beispielsweise ein Doppelpunkt (:) verwendet werden (� fkt1:name bzw. fkt2:name)

• Die Anweisung PREFIX

! PREFIX ausdruck stellt jedem nachfolgenden Namen den Ausdruck ausdruck voran, wenn dieser nicht mit einem Doppelpunkt (:) beginnt

! globale Namen, denen kein Ausdruck vorangestellt werden soll, können

+ ausserhalb einer PREFIX-Anweisung deklariert werden (z.B. globale Register [Stackpoin-ter], globale Speicherstellen)

+ innerhalb einer PREFIX-Anweisung deklariert werden, indem ihnen ein Doppelpunkt vor-angestellt wird (z.B. Einsprungs-Punkte in Funktionen)

! PREFIX-Anweisungen lassen sich verschachteln

! die Anweisung PREFIX : beendet die Wirkung einer vorausgegangenen PREFIX-Anweisung

+ PREFIX : kann als Standard-Einstellung angesehen werden, d.h. solange keine PREFIX-Anweisung vorkommt, gilt PREFIX :

• Beispiel

! MMIX-Assembler-Code LOC #2000000000000000 Bedeutung Zeile GREG @ ---------------------------- var_a OCTA 1 var_a bzw. :var_a 03 reg_a IS $1 reg_a bzw. reg_a 04 // 05 // 06 PREFIX fkt: 07 LOC #2000000000000008 08 var_a OCTA 2 09 reg_a IS $2 10 LOC #100 11 GREG @ 12 :fkt LDO :reg_a,:var_a LDO $1,#2000000000000000 13 LDO reg_a,var_a LDO $2,#2000000000000008 14 GO $0,$0,0 Rücksprung 15 // 16

3-43

PREFIX nochmal: 17 LOC #2000000000000010 18 var_a OCTA 3 19 reg_a IS $3 20 LDO :reg_a,:var_a LDO $1,#2000000000000000 21 LDO :fkt:reg_a,fkt:var_a LDO $2,#2000000000000008 22 LDO reg_a,var_a LDO $3,#2000000000000010 23 // 24 PREFIX : 25 // 26 // 27 PREFIX main: 28 LOC #2000000000000018 29 var_a OCTA 4 main:var_a 30 reg_a IS $4 main:reg_a 31 // 32 LOC #110 33 :Main LDO :reg_a,:var_a LDO $1,#2000000000000000 34 LDO :fkt:reg_a,:fkt:var_a LDO $2,#2000000000000008 35 LDO :fkt:nochmal:reg_a,:fkt:nochmal:var_a 36 // LDO $3,#2000000000000010 37 LDO reg_a,var_a LDO $4,#2000000000000018 38 // 39 GO $0,:fkt Funktion fkt aufrufen 40 TRAP 0,:Halt,0 41 // 42 PREFIX : 43

! die zugehörige Symboltabelle

+ zeigt an, in welchen Wert die in der Assembler-Code-Datei (*.mms) verwendeten Symbole bei der Assemblierung übersetzt werden

+ allgemein wird die Symboltabelle vom Assembler während der Übersetzung einer Assemb-

ler-Code-Datei (beim MMIX: *.mms) in eine Objektdatei (beim MMIX: *.mmo) erzeugt

+ die Symboltabelle wird in der Objektdatei abgelegt, so dass aus anderen Dateien auf die verwendeten Daten/Funktionen zugegriffen werden kann (für das Linken mehrerer Dateien notwendig)

Symbol Wert

fkt 0x100

Main 0x110

var_a 0x2000000000000000

fkt:var_a 0x2000000000000008

fkt:nochmal:var_a 0x2000000000000010

main:var_a 0x2000000000000018

reg_a $1

fkt:reg_a $2

fkt:nochmal:reg_a $3

main:reg_a $4

Abb. 123: Symboltabelle

3-44

3.7.3 Beispiel: skalprodfkt.mms In nachfolgendem Assembler-Code (skalprodfkt.mms) wird unter Verwendung der Funktion Skal-prod das Skalarprodukt zweier Vektoren berechnet. Die Parameter (die Anfangsadressen der Vekto-ren a und b sowie die Vektordimension) werden der Funktion auf dem Stack übergeben. Sowohl die Funktion als auch das Hauptprogramm verfügen über einen eigenen Namensraum LOC Data_Segment GREG @ BOS GREG #4000000000000000 Bottom of Stack SP GREG 0 Stackpointer 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 LOC #100 GREG @ PREFIX Skalprod: Start Prefix Skalprodfkt: 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 :Skalprod SUB :SP,:SP,7*8 push STO $0,:SP,6*8 Rücksprungadresse sichern STO u,:SP,5*8 Register 1 sichern STO v,:SP,4*8 Register 2 sichern STO w,:SP,3*8 Register 3 sichern STO x,:SP,2*8 Register 4 sichern STO y,:SP,8 Register 5 sichern STO z,:SP,0 Register 6 sichern LDO u,:SP,(9*8) Parameter 1 nach u laden LDO v,:SP,(8*8) Parameter 2 nach v laden LDO w,:SP,(7*8) Parameter 3 nach w laden SETL x,0 Initialisierung 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 = LDO z,v,w z = <v + w> MUL y,y,z y = * <v + w> ADD x,x,y x = x + * <v + w> JMP Start Ende STO x,:SP,9*8 Rückgabewert -> Stack LDO u,:SP,5*8 Restore von Register 1 LDO v,:SP,4*8 Restore von Register 2 LDO w,:SP,3*8 Restore von Register 3 LDO x,:SP,2*8 Restore von Register 4 LDO y,:SP,8 Restore von Register 5 LDO z,:SP,0 Restore von Register 6 LDO $0,:SP,6*8 Rücksprungadresse laden ADD :SP,:SP,9*8 Zeige auf Speicherzelle

3-45

* über Aufrufer-Stack, in * der der Rückgabewert * steht GO $0,$0,0 Rücksprung PREFIX : Ende Prefix Skalprod: PREFIX Main: Start Prefix Main: x IS $1 :Main SET :SP,:BOS Stackpointer initialisieren SUB :SP,:SP,3*8 push LDA x,:ADR_A1 Referenz auf a1 laden ... STO x,:SP,2*8 ... und auf den Stack legen LDA x,:ADR_B1 Referenz auf b1 laden ... STO x,:SP,8 ... und auf den Stack legen LDO x,:N Vektordimension laden ... STO x,:SP,0 ... und auf den Stack legen GO $0,:Skalprod Funktion aufrufen LDO x,:SP,0 Rückgabewert vom Stack lesen ADD :SP,:SP,8 pop, SP zeigt wieder auf BOS TRAP 0,:Halt,0 Ende PREFIX :

3-46

3.7.4 Lokale Marken • Motivation

! oft sind bereits in kurzen Programmabschnitten viele Marken vorhanden ! Marken müssen manchmal an Stellen gesetzt werden, für die es keinen sinnvollen Namen gibt ! � Idee: lokale Marken

• Setzen von lokalen Marken

! eine lokale Marke setzt sich zusammen aus einer Ziffer 0 … 9 und dem Buchstaben ‚H’ für „he-re“

! in einem Programmabschnitt kann eine lokale Marke öfter vorkommen • Verwendung lokaler Marken als Sprungziel

! Angabe der Marke, zu der gesprungen werden soll, durch eine Ziffer 0 … 9 gefolgt von dem Buchstaben ‚B’ (backward) bzw. ‚F’ (forward)

! Beispiel

+ JMP 4F springt in Vorwärts-Richtung zum nächsten Auftreten der Marke 4H + JMP 3B springt in Rückwärts-Richtung zum letzten Auftreten der Marke 3H

! � lokale Marken werden immer in Abhängigkeit von der aktuellen Position angesprungen

! Code-Beispiel

LOC #100 Main JMP unten 2H SET $0,100 SET $1,5 5H SUB $0,$0,$1 BNZ $0,5B JMP 4F 3H JMP 1F 4H TRAP 0,Halt,0 1H JMP 2B 1H JMP 1B unten JMP 1B

Probieren Sie das Programm im Simulator aus, wenn Sie sich nicht sicher sind, wie es funktioniert!

4-1

4 Mikroarchitektur-Ebene Im letzten Kapitel haben wir die Assembler- und Befehlssatz-Ebene am Beispiel MMIX untersucht. Wir haben den Befehlssatz kennengelernt und ein paar kleine Programme geschrieben. In diesem Kapitel werden wir den kennengelernten MMIX-Prozessor als Hardware aufbauen. Der Aufbau wird dabei auf Mikroarchitektur-Ebene stattfinden, d.h. wir werden die Hardware in Funktions-einheiten (wie z.B. Befehlszähler, Rechenwerk etc.) abstrahieren und diese Funktionseinheiten dann zusammenschalten. Die Abstraktion in Funktionseinheiten dient dazu, die wesentlichen Komponenten des MMIX-Prozessors darzulegen und den Überblick zu bewahren. Im nächsten Kapitel werden wir diese Funktionseinheiten als Logik-Schaltungen implementieren.

4.1 Funktionseinheiten

In diesem Kapitel untersuchen wir, aus welchen Funktionseinheiten ein MMIX-Prozessor aufgebaut sein muss, damit MMIX-Befehle von ihm ausgeführt werden können. 4.1.1 Befehlsspeicher MMIX-Programme bestehen aus Befehlen, die in einem Speicher abgelegt sein müssen und aus die-sem leicht auslesbar sein müssen. Dieser Speicher wird „Befehlsspeicher“ genannt. Folgende Abbil-dung zeigt als Beispiel einen Auszug des Befehlsspeichers für das im Kapitel 3 abgebildete Programm skalprodfkt.mms:

0x25FCFC38

0xAD00FC30

0xAD01FC28

0xAD02FC20

0x0000000000000100

0x0000000000000104

0x0000000000000108

0x000000000000010C

0xAD03FC180x0000000000000110

Abb. 124: Programm "skalprodfkt.mms" im Befehlsspeicher (Auszug)

Im Folgenden wird untersucht, welche Eigenschaften der MMIX-Befehlsspeicher haben muss. Da MMIX-Programme aus mehreren Befehlen bestehen, muss der Befehlsspeicher neben einem Ausgang auch über einen Eingang verfügen.

! Am Ausgang wird der gewünschte Befehl ausgegeben. Da MMIX-Befehle 32 Bit breit sind, muss auch der Ausgang 32 Bit breit sein.

! Über den Eingang wird dem Befehlsspeicher mitgeteilt, welchen Befehl er ausgeben soll. Da

Befehle sowohl im Textsegment als auch in dem für das Betriebssystem reservierten Bereich stehen können, wird zur Angabe des Orts, an dem der gewünschte Befehl steht, ein 64 Bit brei-tes Datenwort benötigt. Der Eingang des Befehlsspeichers muss also 64 Bit breite Adressen aufnehmen können.

4-2

Der Befehlsspeicher kann auf Mikroarchitektur-Ebene also wie folgt dargestellt werden:

Befehls-Speicher

32

64Adresse

Daten

Abb. 125: Befehlsspeicher

Der Befehlsspeicher funktioniert folgendermaßen:

! Am Eingang „Adresse“ wird ein 64 Bit breites Datenwort angelegt.

! Das angelegte Datenwort wird vom Speicher als Adresse interpretiert.

! Da stets 32 Bit breite Datenworte adressiert werden sollen, werden im Inneren des Befehlsspei-chers die beiden niederwertigsten Adress-Bits stets als „auf Null gesetzt“ angesehen, so dass nur auf durch 4 teilbare Adressen zugegriffen wird.

! Am Ausgang „Daten“ wird dann dasjenige 32 Bit breite Datenwort ausgegeben, das an der

durch die Adresse ausgewählten Speicherstelle steht. Die Grösse des Befehlsspeichers kann man wie folgt ermitteln:

! Textsegment: + Adresse 0x0000000000000000 bis 0x1FFFFFFFFFFFFFFF + � 0x2000000000000000 Byte " 261 Byte " 2.097.152 Terabyte

! Für das Betriebssystem reserviertes Segment:

+ Adresse 0x8000000000000000 bis 0xFFFFFFFFFFFFFFFF + 4 $ 261 Byte " 8.388.608 Terabyte

! Insgesamt: 10.485.760 Terabyte.

Ein so grosser Speicher kann zur Zeit unmöglich implementiert werden. Wie man einen so grossen Adressbereich auch mit weniger Speicher implementieren kann, werden wir in einem späteren Kapitel (# Paging) zeigen; bis nehmen wir der Einfachheit halber an, dass der Speicher in der angegebenen Grösse implementiert ist. 4.1.2 Datenspeicher Daten können beim MMIX nicht nur in Registern, sondern auch im Datenspeicher abgelegt werden.

! Vom Loader, also vor der Programmausführung; mit den Anweisungen OCTA, TETRA, WYDE und BYTE kann man dem Loader mitteilen, welche Wortbreite ein anzulegendes Datum haben soll und wie es zu initialisieren ist.

! Während der Programmausführung mit den Befehlen STO, STT, STW und STB. Zum Auslesen der Daten aus dem Datenspeicher können die Befehle LDO, LDT, LDW und LDB ver-wendet werden.

4-3

Wie muss der Datenspeicher auf Mikroarchitektur-Ebene aussehen, damit die oben angegebenen Speicherzugriffe möglich sind?

! Die im Datenspeicher abgelegten Daten können sich sowohl im Text-, im Pool-, als auch im Stacksegment befinden.

! Der Datenspeicher muss also über einen 64 Bit breiten Adresseingang verfügen, über dem ihm mitgeteilt werden kann, auf welches Datenwort zugegriffen werden soll.

! Zugriffe auf den Datenspeicher erfolgen mit einer maximalen Wortbreite von 64 Bit. ! es müssen also maximal 64 Bit gleichzeitig in den Speicher geschrieben bzw. aus dem Spei-

cher gelesen werden + für Schreibzugriffe wird somit ein 64 Bit breiter Datenbus benötigt, über den die Daten in

den Speicher transportiert werden können + für Lesezugriffe wird ebenfalls ein 64 Bit breiter Datenbus benötigt, über den die Daten aus

dem Speicher geladen werden können33

! da Zugriffe beim MMIX sowohl byte-, wyde-, tetra- als auch octaweise erfolgen können, sind zwei Steuerleitungen zur Bestimmung des Zugriffstyps notwendig

! es wird folgende Codierung verwendet:

Zugriffsart Codierung

Byte 00

Wyde 01

Tetra 10

Octa 11

! um dem Speicher mitzuteilen, wenn er am Dateneingang anliegende Daten überneh-

men/abspeichern soll, ist ein Takteingang (Leitung „Schreiben“) notwendig

! beim Anlegen einer positiven Flanke an den Takteingang wird das am Eingang „Schreibdaten“ anliegende Datum im Speicher an der durch den Eingang „Adresse“ adressierten Speicherstelle abgelegt

Schaltbild des Datenspeichers:

Daten-Speicher

Adresse

Schreib-Daten

Zugriffs-Art

Lese-Daten

Schrei-ben

6464

64

2

Abb. 126: Datenspeicher

33 Für Lese- und Schreibzugriffe werden bei realen Speichern in der Regel die selben Adress- und Datenleitungen verwendet; um Zugriffe auf den Datenspeicher möglichst einfach zu gestalten, verfügt der hier verwendete Datenspeicher über getrennte Datenleitungen zum Lesen und Schreiben.

4-4

Funktionsweise des Datenspeichers:

! Lesen + zum Lesen eines Datums aus dem Datenspeicher wird die Adresse des auszulesenden Da-

tums an den Eingang „Adresse“ angelegt + zusätzlich wird an den Eingang „Zugriffsart“ diejenige Codierung angelegt, die dem ge-

wünschten Zugriff entspricht (z.B. „00“ für byteweisen Zugriff) + am Ausgang „Lesedaten“ wird dann automatisch das gewünschte Datenwort ausgegeben

! Schreiben

+ das zu schreibende Datum wird an den Eingang „Schreibdaten“ angelegt + an den Eingang „Adresse“ wird diejenige Adresse angelegt, an der das Datum im Speicher

abgelegt werden soll + an den Eingang „Zugriffsart“ wird die Codierung angelegt, die der Zugriffsart entspricht; soll

beispielsweise ein Byte geschrieben werden, wird „00“ angelegt

+ sind an alle Eingänge die gewünschten Pegel angelegt worden, kann mit einer positiven Flanke am Takteingang „Schreiben“ das am Eingang „Schreibdaten“ anliegende Datum in der durch den Eingang „Zugriffsart“ gekennzeichneten Weise an die durch den Eingang „Adresse“ angegebene Adresse geschrieben werden

4.1.3 Registerblock Aus der Dokumentation des MMIX-Prozessors ist ersichtlich, dass der MMIX-Prozessor über 256 All-zweckregister verfügt. Da fast jeder MMIX-Befehl Register verwendet, wird als nächstes der Register-block, in dem die 256 Allzweckregister untergebracht sind, auf Mikroarchitekturebene dargestellt. Untersucht man den Befehlssatz des MMIX-Prozessors, gelangt man zu folgender Erkenntnis:

! Auf Register $X kann sowohl lesend als auch schreibend zugegriffen werden. ! Auf Register $Y und $Z wird ausschließlich lesend zugegriffen.

Zur Realisierung der Schreibzugriffe auf $X sind drei Eingänge notwendig:

! Ein 64 Bit breiter Daten-Eingang (Schreibdaten $X), an den das zu speichernde Datenwort an-gelegt wird.

! Ein 8 Bit breiter Adress-Eingang (Schreiben/Lesen $X), mit dem das Register ($0…$255) aus-gewählt wird, in das das am Dateneingang anliegende Datenwort geschrieben werden soll.

! Ein Takteingang (Schreiben $X), mit dem dem Registerblock mitgeteilt werden kann, dass es das am Dateneingang anliegende Datenwort in das durch den Adress-Eingang adressierte Re-gister ablegen soll.

Zur Realisierung der Lesezugriffe auf $X, $Y und $Z wird jeweils ein Ein- und ein Ausgang benötigt:

! Die Eingänge (Schreiben/Lesen $X, Lesen $Y bzw. Lesen $Z) dienen zur Auswahl der Regis-ter, die ausgelesen werden sollen; da 256 Register zur Verfügung stehen, müssen die Adress-Eingänge jeweils 8 Bit breit sein.

! Die Ausgänge (Lesedaten $X, Lesedaten $Y und Lesedaten $Z) dienen zur Ausgabe des Da-tenworts und müssen deshalb jeweils 64 Bit breit sein.

4-5

Damit stellt sich der Registerblock auf Mikroarchitektur-Ebene wie folgt dar:

Lesen $Y

Schreiben/Lesen $X

Schreib-Daten $X

Lese-Daten $Z

Lese-Daten $Y

Registerblock

64

64

Lese-Daten $X

64

Lesen $Z

8

8

8

64

Schreiben $X

Abb. 127: Registerblock

Funktionsweise des Registerblocks:

! Lesen von Register $X + Zum Lesen von Register $X wird an den Eingang „Lesen/Schreiben $X“ die 8 Bit breite Ad-

resse (eine Zahl zwischen 0 und 255) des Registers $X angelegt, von dem gelesen werden soll.

+ Als Folge wird am Ausgang „Lese-Daten $X“ das 64 Bit breite Datenwort ausgegeben, das sich im adressierten Register $X befindet.

! Schreiben in Register $X

+ Zum Schreiben in das Register $X wird zunächst am Eingang „Schreib-Daten $X“ das 64 Bit breite Datenwort angelegt, das in Register $X geschrieben werden soll.

+ Desweiteren wird am Eingang „Schreiben/Lesen $X“ die 8 Bit breite Adresse des Registers $X angelegt, in das die am Eingang „Schreib-Daten $X“ anliegenden Daten geschrieben werden sollen.

+ Um dem Registerblock mitzuteilen, dass er das am Eingang „Schreib-Daten $X“ anliegende Datum in das durch den Eingang „Schreiben/Lesen $X“ adressierte Register übernehmen soll, muss am Takteingang „Schreiben $X“ eine steigende Flanke angelegt werden.

+ Beim Auftreten der steigenden Flanke wird das anliegende Datum dann in das entspre-chende Register $X übernommen.

! Lesen von Register $Y

+ Zum Lesen von Register $Y wird an den Eingang „Lesen $Y“ die Adresse (ein Wert zwi-schen 0 und 255) des Registers $Y angelegt, von dem gelesen werden soll.

+ Als Folge wird am Ausgang „Lese-Daten $Y“ das 64 Bit breite Datenwort ausgegeben, das sich im adressierten Register $Y befindet.

! Lesen von Register $Z

+ Zum Lesen von Register $Z wird an den Eingang „Lesen $Z“ die Adresse (ein Wert zwi-schen 0 und 255) des Registers $Z angelegt, von dem gelesen werden soll.

+ Als Folge wird am Ausgang „Lese-Daten $Y“ das 64 Bit breite Datenwort ausgegeben, das sich im adressierten Register $Z befindet.

4-6

4.1.4 Register Die im Registerblock untergebrachten 256 Allzweckregister lassen sich einzeln wie folgt darstellen:

D Q64 64

Clk

D0D1

D63

Q0Q1

Q63

Clk

Abb. 128: 64 Bit breites Register

Die gezeigten Darstellungsarten unterscheiden sich lediglich darin, dass die Datenleitungen entweder einzeln gezeichnet (links) oder zu einem Bus zusammengefasst sind (rechts). Nachfolgende Abbildung zeigt, wie ein Register verwendet wird:

Clk

D0D1

D63

Q0Q1

Q63

10

1

10

1

2

301

014

5

Abb. 129: Schreiben in ein Register

! Zuerst werden Daten (Logikpegel) an die Eingangsleitungen D0…D63 angelegt (1).

! Bei einer steigenden Flanke am Takteingang Clk (2) werden die am Eingang anliegenden Da-

ten in das Register übernommen und dort abgespeichert.

! Am Ausgang liegen die abgespeicherten Daten sofort an (3).

! Auch wenn sich die Daten am Eingang jetzt ändern (4), bleibt das im Register abgespeicherte Datenwort am Ausgang erhalten (5).

! Erst bei einer erneuten steigenden Flanke wird das am Eingang anliegende Datenwort in das

Register übernommen und am Ausgang ausgegeben. • D-Register

! D-Register " ganz normales Register, das ein Datenwort (deswegen „D“) abspeichern kann ! Register sind Speicherelemente, die genau ein Wort aufnehmen können ! allgemein kann die Wortbreite von Registern variieren; beim MMIX ist sie aufgrund des 64 bit

breiten Daten- und Adressbusses in der Regel 64 Bit breit

! Register verfügen über einen Dateneingang (D), einen Datenausgang (Q) und einem Taktein-gang (Clk, manchmal auch einfach nur C genannt)

! bei einer positiven Flanke am Takteingang werden die am Dateneingang anliegenden Daten in das Register übernommen, dort abgespeichert und am Ausgang zur Verfügung gestellt

! da die Daten am Dateneingang ausschliesslich bei positiven Flanken der Taktleitung übernom-men werden, kann sich bei konstantem Takteingang bzw. bei fallenden Flanken am Taktein-gang das Datenwort am Dateneingang beliebig ändern, ohne vom Register übernommen zu werden

4-7

D0

Clk

D1D2

D63

Q0Q1Q2

Q63

Clk

D Q64 64

D Clk Q

neues Datenwort neues Datenwort

neues Datenwort sonst altes Datenwort

Abb. 130: Register mit 64 Bit Wortbreite

• Schieberegister

! Schieberegister verhalten sich wie Register, können jedoch zusätzlich das abgespeicherte Wort um eine Stelle nach links (Links-Schiebe-Register) oder nach rechts (Rechts-Schiebe-Register) schieben

! Beispiel für ein 128 Bit breites Rechts-Schiebe-Register

D0

Init/>>1

D1D2

D126

Q0Q1Q2

Q126Q127D127

Clk

D

Init/>>1

Q

Clk

128 128

D Init/>>1 Clk Q

neues Datenwort 0 neues Datenwort

neues Datenwort 0 sonst altes Datenwort

X 1 altes Datenwort >> 1

X 1 sonst altes Datenwort

! hat die Auswahlleitung Init/>>1 low-Pegel (0), ist die Init-Funktion ausgewählt + bei steigender Flanke am Takteingang Clk werden die am Eingang D anliegenden Daten

übernommen + bei einer negativen Flanke oder bei konstantem Pegal an Clk ergibt sich keine Änderung

! hat die Auswahlleitung Init/>>1 high-Pegel (1), ist die Schiebe-Funktion ausgewählt

+ bei steigender Flanke am Takteingang Clk wird das im Schieberegister gespeicherte Wort um eine Stelle nach rechts geschoben

+ bei einer negativen Flanke oder bei konstantem Pegel an Clk ergibt sich keine Änderung 4.1.5 Rechenwerk (ALU) Wenn wir den Befehlssatz des MMIX-Prozessors betrachten, stellen wir fest, dass bei fast allen Befeh-len irgendetwas berechnet werden muss. So muss beispielsweise bei Lade- und Speicher-Befehlen der Prozessor aus $Y und $Z die Zugriffsadresse und bei Verzweigungen die Zieladresse berechnen. Bei Arithmetischen Befehlen muss z.B. addiert oder multipliziert werden und bei booleschen Verknüp-fungen müssen bitweise Operatoren auf Datenworte angewandt werden. Alle diese Berechnungen führt der Prozessor im sog. Rechenwerk aus, das auch kurz ALU (Arithmetic Logic Unit) genannt wird.

4-8

Nachfolgende Abbildung zeigt das Rechenwerk auf Mikroarchitektur-Ebene.

ALU

64

64

64

Operand 1

Operand 2

Funktionsauswahl

Ergebnis

Statusinformationen

8

10

64

Divisionsrest/Produktüberhang

Abb. 131: ALU

! Funktionsweise der ALU auf Mikroarchitektur-Ebene

+ an die beiden Eingangsleitungen „Operand 1“ und „Operand 2“ werden die Operanden an-gelegt

+ über die 8 Eingangsleitungen „Funktionsauswahl“ wird die Funktion der ALU ausgewählt, ihr also mitgeteilt, ob sie eine Addition, eine Subtraktion, eine Multiplikation etc. ausführen soll

+ nach der Ausführung der gewünschten Operation gibt die ALU am Ausgang „Ergebnis“ das Ergebnis der Operation aus, bei der Addition also die Summe der Operanden, bei der Multi-plikation das Produkt der Operanden etc.

+ bestimmte bei der Berechnung auftretende Ereignisse wie z.B. ein Überlauf werden von der ALU am Ausgang „Statusinformationen“ angezeigt

+ der Rest einer Division bzw. die beim Produkt zweier 64 Bit breiten Zahlen auftretenden Bits 64 … 127 werden am Ausgang „Divisionsrest/Produktüberhang“ ausgegeben

4.1.6 Steuerung # FAQs zur Übung „Divisionswerk und Steuerung“ 4.1.7 Multiplexer Multiplexer sind Auswahl-Schalter, die einen von mehreren Eingängen auf einen Ausgang schalten der Datenfluss beschränkt sich auf logische Signale (0 oder 1). Der Datenfluss ist dabei nur vom Ein-gang zum Ausgang möglich; soll ein Eingang auf mehrere Ausgänge geschaltet werden können, muss ein sogl Demultiplexer verwendet werden. Die Auswahl des Eingangs, der auf den Ausgang geschal-tet werden soll, wird über den Steuerungsbus festgelegt. Hat der Multiplexer 2n Eingänge, muss der Steuerungsbus n Leitungen haben, um alle Eingänge adressieren zu können.

Eingang 0 0

Ausgang

Steuerungsbus

2

Eingang 1

Eingang 2

Eingang 3

1

2

3

Steuerungsbus Ausgang

00 Logikpegel des Eingangs 001 Logikpegel des Eingangs 110 Logikpegel des Eingangs 211 Logikpegel des Eingangs 3

Abb. 132: Multiplexer

4-9

Sollen Signale, die mehr als ein Bit umfassen, vom Eingang auf den Ausgang geschaltet werden kön-nen, muss ein sog. Bus-Multiplexer verwendet werden

4

4

4

4

2

4

0

1

2

3

Steuerungsbus Ausgang

00 Wort am Eingang 001 Wort am Eingang 110 Wort am Eingang 211 Wort am Eingang 3

Abb. 133: Bus-Multiplexer für die Wortbreite n = 4 Bit

4.1.8 Demultiplexer Die Umkehrung eines Multiplexers ist der sog. Demultiplexer. Nachfolgende Abbildung zeigt einen 1 Bit- und einen 4 Bit-Demultiplexer.

0

Eingang

Steuerungsbus2

1

2

3

Ausgang 0

Ausgang 1

Ausgang 2

Ausgang 3

0

Eingang

Steuerungsbus2

1

2

3

Ausgang 0

Ausgang 1

Ausgang 2

Ausgang 3

4

4

4

4

4

Abb. 134: 1 Bit- (links) und 4 Bit- (rechts) Demultiplexer

Demultiplexer können einen Eingang auf einen von mehreren Ausgängen legen. Die restlichen Aus-gänge werden dabei auf logisch 0 gesetzt. Dabei beschränkt sich der Datenfluss auf logische Signale (0 oder 1), es können also keine analogen Spannungswerte übertragen werden.

Steuerungsbus Ausgang 0 Ausgang 1 Ausgang 2 Ausgang 3

00 Eingangspegel 0 0 001 0 Eingangspegel 0 010 0 0 Eingangspegel 011 0 0 0 Eingangspegel

Abb. 135: Wertetabelle Demultiplexers

Die Auswahl des Ausgangs, auf den der Eingang gelegt werden soll, geschieht wie beim Multiplexer über einen Steuerungsbus. Hat der Demultiplexer 2n Ausgänge, muss der Steuerungsbus n Leitungen haben, um alle Ausgänge adressieren zu können.

4-10

4.1.9 Decoder Nachfolgende Abbildung zeigt einen Decoder.

0

Steuerungsbus

2

1

2

3

Ausgang 0

Ausgang 1

Ausgang 2

Ausgang 3

Abb. 136: Symbol und Aufbau eines Decoders

Decoder dienen zur Auswahl einer von mehreren Möglichkeiten:

! wird am Steuerungsbus eine binäre Zahl angelegt, so wird der der binären Zahl entsprechende Ausgang auf 1 gesetzt

! alle anderen Ausgänge werden hierbei auf Low-Pegel gehalten

Steuerungsbus Ausgang 0 Ausgang 1 Ausgang 2 Ausgang 3

00 1 0 0 001 0 1 0 010 0 0 1 011 0 0 0 1

Abb. 137: Wertetabelle Decoder

Ein Decoder entspricht somit einem Demultiplexer, dessen Eingang permanent auf 1 liegt. 4.1.10 Leitungen und Busse Leitungen und Busse dienen dazu, die soeben kennengelernten Funktionseinheiten miteinander zu verbinden.

! Leitungen kann man sich als einadrige Kabel bzw. Verbindungen vorstellen ! Leitungen werden immer als dünne Linien gezeichnet ! sich kreuzende Leitungen, die mit einem Punkt auf der Kreuzung gekennzeichnet sind, gelten

als an diesem Punkt miteinander verbunden ! sich kreuzende Leitungen ohne Punkt gelten als nicht miteinander verbunden

Verbindungkeine Verbindung

dünne Linie, also kein Bus

Abb. 138: Verbundene und nicht verbundene Leitungen

4-11

! ein Bus ist eine Verbindung, die aus mehreren (parallelen) Leitungen besteht ! ein Bus wird immer als dicke Linie gezeichnet ! ist ein Bus mit einer diagonal kreuzenden Linie versehen, dann kennzeichnet die Zahl neben

der diagonalen Linie die Anzahl der Busleitungen ! Zahlenbereiche (z.B. 0...15) kennzeichnen die Leitungen, aus denen ein Bus besteht ! sich kreuzende Busse, die mit einem Punkt auf der Kreuzung gekennzeichnet sind, gelten als

leitungsweise miteinander verbunden ! sich kreuzende Busse ohne Punkt gelten als nicht miteinander verbunden ! Abzweigungen aus einem Bus, die mit Zahlen (z.B. 3, 14 etc.) bzw. Zahlenbereichen (z.B. 0...2,

4...16 etc.) versehen sind, kennzeichnen die Herausführung der entsprechenden Leitungen aus dem Bus

! Zusammenführungen von Leitungen/Bussen werden ebenfalls durch Zahlen bzw. Zahlenberei-che gekennzeichnet

! � die Unterscheidung zwischen der Aufteilung eines breiten Busses in schmälere Busse und der Zusammenführung schmälerer Busse zu einem breiten Bus muss anhand der Ein- und Ausgänge der an den Bus angeschlossenen Geräte getroffen werden

Verbindungkeine Verbindung

dicke Linie, also Bus

16

Bus besteht aus 16 Busleitungen

16

0..3die Busleitungen 0..3 werden ausdem Bus herausgeführt

0..15

4 16

0..7 8..15

8 8

der Bus wird ein zwei kleinereBusse aufgeteilt oder zwei kleineBusse werden zu einem grossenBus zusammengeführt(muss dem Anschluss an Ein- undAusgänge entnommen werden)

Abb. 139: Busse

4-12

4.2 Zusammensetzen des Datenpfads

Nachdem jetzt alle Bauelemente bekannt sind, die zum Aufbau des Datenpfads benötigt werden, kann der Datenpfad zusammengesetzt werden. 4.2.1 Holen eines Befehls aus dem Befehlsspeicher

! um einen Befehl aus dem Befehlsspeicher zu laden, muss am Eingang „Adresse“ des Befehls-speichers die Adresse des auszulesenden Befehls angelgt werden

! da die Adresse während der gesamten Abarbeitung des Befehls am Datenspeicher anliegen soll, ist es zweckmäßig, sie in einem Register abzulegen

! das zu diesem Zweck verwendete Register hat den Namen Befehlszähler (abgekürzt BZ), engl. program counter (PC)

Befehls-Speicher

32Daten

BZ

Adresse

64

32

BZ übernehmenAdresse des nächsten Befehls

! während die im Befehlszähler stehende Adresse den Befehlsspeicher adressiert und dafür sorgt, dass am Ausgang „Daten“ des Befehlsspeichers das aktuelle Befehlswort erscheint, kann an den Dateneingang des Befehlszählers bereits die Adresse des nächsten Befehls angelegt werden

! soll die am Eingang des Befehlszählers anliegende Adresse in den Befehlszähler übernommen und damit an den Befehlsspeicher angelegt werden, muss dann nur noch am Takteingang des Befehlszählers eine positive Flanke angelegt werden

4.2.2 Auswahl des nächsten Befehls

! werden stets aufeinanderfolgende Befehle ausgeführt, so muss der Befehlszähler immer um 4 erhöht werden, da ein MMIX-Befehl 4 Byte umfasst und Speicher beim MMIX byteweise adres-siert wird

! für diesen Zweck kann ein Addierer verwendet werden, der zum aktuellen Stand des Befehls-zählers stets die Konstante 4 addiert

Befehls-Speicher

32Daten

Adresse

64

64

644

64Add

BZ

! bei einer positiven Flanke am Befehlszähler wird jetzt also immer das nächste Befehlswort am Datenausgang des Befehlsspeichers ausgegeben

4-13

4.2.3 Dekodieren des Befehls

! Anhand des Befehlsworts, das aus dem Befehlsspeicher kommt, wird nun analysiert + um welchen Befehl es sich handelt + welche Operanden (welche Register) für die Ausführung des Befehls benötigt werden

! gemäß dem Beispiel in Abb. 104 (vgl. S. 3-26), das nachfolgend als Abb. 140 noch einmal auf-

gegriffen ist, werden MMIX-Befehle wie folgt codiert:

Marke ADD $1,$2,$3 Kommentar

0x20 0x01 0x02 0x03

00000001 00000010 0000001100100000

1 Byte 1 Byte 1 Byte 1 Byte

übersetztesBefehlswort:

X Y ZOpcode

31 24 23 16 15 8 7 7

Abb. 140: Befehlscodierung

! aus diesem Codierungs-Beispiel ist ersichtlich, dass + der Opcode, also die Information darüber, um welchen Befehl es sich handelt, an den Bits

31…24 abgelesen werden kann + als Operand $X dasjenige Register verwendet wird, das der an den Bits 23...16 stehenden

8 Bit breiten Zahl entspricht + als Operand $Y dasjenige Register verwendet wird, das der an den Bits 15...8 stehenden 8

Bit breiten Zahl entspricht + als Operand $Z dasjenige Register verwendet wird, das der an den Bits 7...0 stehenden 8

Bit breiten Zahl entspricht

! darüberhinaus lässt sich aus Abb. 103 (vgl. S. 3-8) erkennen, dass der 8 Bit breite Direktope-rand Z diejenige Zahl ist, die an den Bits 7…0 steht34

! die Information, welcher Befehl gerade aus dem Befehlsspeicher geladen wurde bzw. welche

Operanden (welche Register bzw. welcher Direktoperand) von diesem Befehl verwendet wer-den, kann dann wie folgt ermittelt werden:

32Daten

Adresse

64

64

644

64Add

31…24

23…16

15…8

7…0

BZ

Opcode des Befehls(z.B.0x20 für ADD)

Nummer von $X(Registeradresse, z.B. 0x01)

Nummer von $Y(Registeradresse, z.B. 0x02)

Nummer von $Z (Registeradresse, z.B. 0x03)bzw. Direktoperand Z (z.B. 0x03)

Befehls-Speicher

34 Die 16 und 24 Bit breiten Direktoperanden YZ bzw. XYZ werden hier nicht verwendet.

4-14

4.2.4 Bereitstellen der Operanden

! die auf diese Weise zur Verfügung stehenden Registeradressen können wie folgt direkt zur An-steuerung des Registerblocks verwendet werden

Befehls-Speicher

32Daten

Adresse

64

64

644

64Add

31…24

23…16

15…8

7…0

Lesen $Y

Schreiben/Lesen $X

Schreib-Daten $X

Lese-Daten $Z

Lese-Daten $Y

Registerblock

Lese-Daten $X

Lesen $Z

64Schreiben $X

64

64

64

8

560

BZ


Datenwort, dass in Register $Xsteht, z.B. 0x1111111111111111

auf 64 Bit erweiterter 8 BitDirektoperand Z, z.B.0x0000000000000003

Datenwort, dass in Register $Ysteht, z.B. 0x2222222222222222

Datenwort, dass in Register $Zsteht, z.B. 0x3333333333333333

64

! die Operandenbereitstellung35 funktioniert wie folgt:

+ der 8 Bit breite Direktoperand Z kann den Bits 7…0 des Befehlsworts entnommen werden, muss jedoch noch auf 64 Bit erweitert werden, indem die Bits 63…8 hinzugefügt und auf Null gesetzt werden

+ an den Adresseingängen „Schreiben/Lesen $X“, „Lesen $Y“ und „Lesen $Z“ wird jeweils

die Nummer (Zahl zwischen 0…255) des Registers angelegt, das ausgelesen werden soll

+ an den Ausgängen „Lesedaten $X“, „Lesedaten $Y“ und „Lesedaten $Z“ werden vom Re-gisterblock dann automatisch die 64 Bit breiten Datenworte ausgegeben, die in den adres-sierten Registern stehen

+ in obiger Abbildung sind die bereitgestellten Operanden für das Beispiel ADD $1,$2,$3

angegeben, wenn • im Register $1 der Wert 0x1111111111111111 steht • im Register $2 der Wert 0x2222222222222222 steht • im Register $3 der Wert 0x3333333333333333 steht

4.2.5 Ausführen des Befehls/Berechnung von Daten

! wenn die Operanden zur Verfügung stehen, können sie in das Rechenwerk/die ALU geleitet werden, wo dann die entsprechende Operation ausgeführt wird, im Falle des oben angegebe-nen Beispiels ADD $1,$2,$3 also die aus dem Registerblock ausgelesenen Werte 0x2222222222222222 und 0x3333333333333333 addiert werden

! da der zweite Quelloperand auch ein Direktoperand sein kann (also Z statt $Z) muss mit Hilfe

eines Multiplexers zwischen dem aus dem Registerblock ausgelesenen Wert $Z und dem Di-rektoperanden Z ausgewählt werden können

35 Im Rahmen der Erstellung des Datenpfads werden die Direktoperanden Y, YZ und XYZ hier nicht berücksichtigt. Es wird nur die Unterstützung für den Direktoperanden Z implementiert, da dieser am häufigsten verwendet wird.

4-15

Befehls-Speicher

32Daten

Adresse

64

64

644

64Add

31…24

23…16

15…8

7…0

Lesen $Y

Schreiben/Lesen $X

Schreib-Daten $X

Lese-Daten $Z

Lese-Daten $Y

Registerblock

Lese-Daten $X

Lesen $Z

64Schreiben $X

64

64

64 ALU0

1

64

8

560

64

BZ

Ergebnis

Auswahl derALU-FunktionAuswahl

$Z oder Z


64

4.2.6 Steuerung der Auswahl der ALU-Funktion und des Direktoperanden

! damit die ALU weiß, welche Operation sie durchführen soll, wird eine Steuerung benötigt, die anhand des Befehls-Opcodes (z.B. 0x20 bei ADD $X,$Y,$Z) die entsprechende ALU-Funktion auswählt

! die Auswahl zwischen dem aus dem Register ausgelesenen Parameter $Z und dem Direktope-

randen Z in Abhängigkeit des Befehls-Opcodes (z.B. 0x20 bei ADD $X,$Y,$Z aber 0x21 bei ADD $X,$Y,Z) kann dann auch von der Steuerung übernommen werden

! desweiteren kann auch die Taktung des Befehlszählers, also die Übernahme eines neuen Be-

fehls durch die Steuerung geschehen

Befehls-Speicher

32Daten

Adresse

64

64

644

64Add

31…24

23…16

15…8

7…0

Lesen $Y

Schreiben/Lesen $X

Schreib-Daten $X

Lese-Daten $Z

Lese-Daten $Y

Registerblock

Lese-Daten $X

Lesen $Z

64Schreiben $X

64

64

64 ALU0

1

64

8

560

64

Steuerung

BZ

Ergebnis

64

4-16

4.2.7 Ergebnis in den Registerblock schreiben

! das von der ALU berechnete Ergebnis muss in den Registerblock zurückgeschrieben werden können, also an den Eingang „Schreibdaten $X“ des Registerblocks angelegt werden

! das so angelegte Ergebnis wird dann bei einer positiven Flanke am Takteingang „Schreiben $X“ des Registerblocks in diesen übernommen

! die positive Flanke am Takteingang „Schreiben $X“ kann wieder von der Steuerung generiert

werden

! in welches der 256 Register das Ergebnis übernommen werden soll, wird dabei durch die am Eingang „Schreiben/Lesen $X“ anliegende Registeradresse (Zahl zwischen 0 und 255, in unse-rem Beispiel ADD $1,$2,$3 die Zahl 0x01) bestimmt

Befehls-Speicher

32Daten

BZ

Adresse

64

64

644

64Add

31…24

23…16

15…8

7…0

Lesen $Y

Schreiben/Lesen $X

Schreib-Daten $X

Lese-Daten $Z

Lese-Daten $Y

Registerblock

Lese-Daten $X

Lesen $Z

64Schreiben $X

64

64

64 ALU0

1

64

8

560

64

Steuerung

64

4-17

4.2.8 Ergebnis als Sprungziel verwenden

! bei Funktionsaufrufen mittels GO $X,$Y,$Z bzw. GO $X,$Y,Z werden die Operanden $Y und $Z bzw. $Y und Z addiert; das Ergebnis wird dann als Sprungziel verwendet

! diese Addition kann mit dem bisher aufgebauten Datenpfad bereits durchgeführt werden

! es muss also lediglich alternativ zu „aktueller Befehl + 4“ auch ein Additions-Ergebnis als neuer Wert für den Befehlszähler übernommen werden können

! die Auswahl zwischen den Alternativen kann mit einem Multiplexer implementiert werden

+ da die Steuerung den Befehl, der gerade ausgeführt wird, genau kennt, weiß sie auch, ob gerade ein Sprungbefehl ausgeführt wird oder nicht

+ die Steuerung kann also auch den Multiplexer steuern, der zur Auswahl des neuen Werts für den Befehlszähler verwendet wird

Befehls-Speicher

32Daten

BZ

Adresse

64

64

644

64Add

0 1 31…24

23…16

15…8

7…0

Lesen $Y

Schreiben/Lesen $X

Schreib-Daten $X

Lese-Daten $Z

Lese-Daten $Y

Registerblock

Lese-Daten $X

Lesen $Z

64Schreiben $X

64

64

64 ALU0

1

64

8

560

64

Steuerung

64

4.2.9 Lesezugriffe auf den Datenspeicher

! Auch bei Lesezugriffen auf den Datenspeicher (MMIX-Befehle LDB, LDW, LDT oder LDO) wer-den die Operanden $Y und $Z bzw. $Y und Z zunächst addiert, was mit dem bisher implemen-tierten Datenpfad bereits ausgeführt werden kann

! gemäß der Beschreibung der Ladebefehle (vgl. Kapitel 3.5.2) muss das Ergebnis der Addition dann als Adresse interpretiert werden

! das Ergebnis muss also an den Adresseingang des Datenspeichers angelegt werden ! am Ausgang des Datenspeichers erscheint dann der Wert, der im Datenspeicher an der am Ad-

resseingang angegebenen Adresse abgespeichert ist

! um dem Datenspeicher mitzuteilen, ob er einen 8 Bit Wert (Byte), einen 16 Bit Wert (Wyde), ei-nen 32 Bit Wert (Tetra) oder einen 64 Bit Wert (Octa) auslesen soll, müssen die zwei Eingangs-bits „Zugriffsart“ des Datenspeichers von der Steuerung in Abhängigkeit des Opcodes noch wie folgt gesetzt werden (vgl. Kapitel 0):

+ 00 zum Zugriff auf 8 Bit breite Werte (Byte) + 01 zum Zugriff auf 16 Bit breite Werte (Wyde) + 10 zum Zugriff auf 32 Bit breite Werte (Tetra) + 11 zum Zugriff auf 64 Bit breite Werte (Octa)

4-18

Befehls-Speicher

32Daten

BZ

Adresse

64

64

644

64Add

0 1 31…24

23…16

15…8

7…0

Lesen $Y

Schreiben/Lesen $X

Schreib-Daten $X

Lese-Daten $Z

Lese-Daten $Y

Registerblock

Lese-Daten $X

Lesen $Z

64Schreiben $X

64

64

64 ALU0

1

64

8

560

Daten-Speicher

Adresse

Schreib-Daten

Zugriffs-Art

Lese-Daten

Schrei-ben

2

64 64

Steuerung

64

! da das ausgelesene Datum bei den Ladebefehlen LDx $X,$Y,$Z|Z36 in das durch $X ad-ressierte Register übernommen werden soll, muss der zuvor eingezeichnete Pfad zum Ablegen eines Ergebnisses in den Speicher noch um die Alternative „Rückschreibewert kommt aus dem Datenspeicher“ ergänzt werden

! die Auswahl einer der beiden Möglichkeiten „Rückschreibewert kommt von der ALU“ und „Rückschreibewert kommt aus dem Datenspeicher“ kann wie zuvor bei der Auswahl des neuen Werts für den Befehlszähler mit einem Multiplexer realisiert werden

! die Steuerung des Multiplexers erfolgt wieder durch die Steuerung

Befehls-Speicher

32Daten

BZ

Adresse

64

64

644

64Add

0 1 31…24

23…16

15…8

7…0

Lesen $Y

Schreiben/Lesen $X

Schreib-Daten $X

Lese-Daten $Z

Lese-Daten $Y

Registerblock

Lese-Daten $X

Lesen $Z

64Schreiben $X

64

64

64 ALU0

1

64

8

560

Steuerung

Daten-Speicher

Adresse

Schreib-Daten

Zugriffs-Art

Lese-Daten

Schrei-ben

2

64 640

164

64

36 Der Buchstabe x in LDx steht hier für B, W, T bzw. O. Es sind also die Befehle LDB, LDW, LDT und LDO gemeint. Der Strich in $Z|Z bedeutet „oder“. Es sind also sowohl die Befehle LDx $X,$Y,$Z als auch die Befehle LDx $X,$Y,Z gemeint.

4-19

4.2.10 Schreibzugriffe auf den Datenspeicher

! die Adressierung des Datenspeichers beim Abspeichern eines Datenworts funktioniert genauso wie beim Laden eines Datenworts, muss also nicht extra implementiert werden

! gleiches gilt für die Auswahl der Zugriffsart

! beim Schreiben eines Werts in den Datenspeicher muss dieser am Eingang „Schreibdaten“ an-gelegt werden

! gemäss Kapitel 0 wird bei einer positiven Flanke am Takteingang „Schreiben“ das am Eingang

„Schreibdaten“ anliegende Datum im Datenspeicher an der Adresse abgespeichert, die am Ein-gang „Adresse“ anliegt

! die positive Flanke kann wieder von der Steuerung erzeugt werden

Befehls-Speicher

32Daten

BZ

Adresse

64

64

644

64Add

0 1 31…24

23…16

15…8

7…0

Lesen $Y

Schreiben/Lesen $X

Schreib-Daten $X

Lese-Daten $Z

Lese-Daten $Y

Registerblock

Lese-Daten $X

Lesen $Z

64Schreiben $X

64

64

64 ALU0

1

64

8

560

Steuerung

Daten-Speicher

Adresse

Schreib-Daten

Zugriffs-Art

Lese-Daten

Schrei-ben

2

64 640

164

64

Abb. 141: Single-Cycle-Datenpfad

4.3 Performance des Single-Cycle-Datenpfads

Im Kapitel 3 haben wir gesehen, dass die MMIX-Befehle zur Ausführung eine bestimmte Zeit benöti-gen, die sog. Ausführungszeit. Diese ergibt sich daraus, dass die einzelnen Signale sich durch den Datenpfad hindurch ausbreiten müssen und die einzelnen Komponenten wie z.B. Registerblock, Spei-cher und ALU eine bestimmte Zeit benötigen, bis sie ihre Arbeit verrichtet haben. Die Funktionseinhei-ten des Datenpfades benötigen also eine gewisse Durchlaufzeit. In Kapitel 5 werden wir sehen, dass sich diese Durchlaufzeit aus der Aufsummierung sog. Gatterlaufzeiten ergibt.

4-20

4.4 Aufbau der Funktionseinheiten auf Mikroarchitektur-Ebene

4.4.1 Speicher ! Zeilendekoder ! Spaltendekoder ! Speichermatrix

# Vorlesungsfolien

4.4.2 Registerblock

! Aufbau aus 256 Registern, 3 Multiplexern und einem Demultiplexer

D0

C

D1D2

D63

Q0Q1Q2

Q63

D0

C

D1D2

D63

Q0Q1Q2

Q63

D0

C

D1D2

D63

Q0Q1Q2

Q63

D0

C

D1D2

D63

Q0Q1Q2

Q63

012

63

012

63

012

63

012

63

012255

012

63

12

63

12

63

012

63

012

255

64

64

64

64

64

64

8

8

Lesen $Z

Lesen $Y

Schreiben/Lesen $X

Schreib-Daten $X

Lese-Daten $X

Lese-Daten $Z

64

8

8

8

64

64

012

255

8

012

255

•

8

64

Lese-Daten $Y

64

Schreiben

Abb. 142: Aufbau des Registerblocks aus Registern, Multiplexern und einem Demultiplexer

4-21

4.4.3 Register ! Aufbau aus Flipflops

D

Q

Q

C

D

Q

Q

C

D

Q

Q

C

D0

D1

D63

Q0

Q1

Q63

Abb. 143: Realisierung eines 64 Bit-Registers aus 64 einzelnen flankengesteuerten Flipflops

! Flipflop

# Vorlesungsfolien

4-22

• Schieberegister ! Schieberegister, deren Inhalt nur um eine Stelle verschoben werden kann, können sehr leicht

mit einem Multiplexer realisiert werden

0

Init/>>1

1

0

Dateneingangfür die Initiali-sierung

Daten-ausgang

128

128

Clk

D0

Init/>>1

D1D2

D126

Q0Q1Q2

Q126Q127D127

Clk

" D0D1D2

D126

Q0Q1Q2

Q126Q127D127

Clk

Abb.: Symbol und Aufbau des Produkt-Schieberegisters

! wird am Takteingang des verwendeten Registers37 eine positive Flanke angelegt, so übernimmt

das Register den vom Multiplexer bereitgestellten Wert ! zur Initialisierung, also zur Vorbelegung mit einem Startwert, kann der Multiplexer einen extern

Dateneingang verwenden (die Steuerleitung zur Initialisierung hat dann den Wert 0); der Quer-strich über dem Wort „Init“ meint hierbei negative Logik; liegt an der Eingangsleitung Init/>>1 al-so eine Null an, wird die Funktion „Init“, also die Initialisierung des Schieberegisters ausgewählt; liegt jedoch eine Eins an, so wird die Funktion „>>1“, also das Rechtsschieben des Register-Inhalts, aktiviert

! wurde der Startwert durch Anlegen einer positiven Flanke am Takteingang des Registers über-nommen, kann die Steuerleitung des Multiplexers auf 1 gelegt werden, damit am Ausgang des Multiplexers immer der um eins nach rechts geschobene Registerinhalt angelegt wird

! bei jeder positiven Flanke am Takteingang des Registers wird nun stets der Register-Wert um eins nach rechts geschoben und liegt dann am Datenausgang an

! bei jedem „nach rechts Schieben“ werden von links Nullen nachgezogen ! soll das Schieberegister rotieren können, muss an das MSB des Eingangs 1 des Multiplexers

anstelle der Null der Register-Ausgang Q0 angeschlossen werden

37 Mit Register ist hier stets das innerhalb des Schieberegisters verwendete Register gemeint.

4-23

4.4.4 Rechenwerk

64

64

64

0

1

2

3

64 64

k ÜArt

E A<<>>

8

Funktionsauswahl

10

Statusinformationen

CLA-Addierer/Subtrahie-rer

64MULU

128DIVU

64

64

64

4

564

64

64

64

0…5

0...63

64…127

0...63

64…127

64

64

2

6

Rest der Division bzw.Bit 64…127 des Produkts

64

01

$X

$Z|Z

$Y|Y

UND-Einheit

ODER-Einheit

OC

10

Status-Einheit

8 64

6

CMP-Erweiterung

64 64

10

a

bsub/add

Abb. 144: MMIX-Rechenwerk

! die Auswahl-Leitung dient zur Auswahl der gewünschten Funktion (Addieren, Schieben etc.) ! die Statusinformationen geben beispielsweise Auskunft darüber, ob ein Überlauf auftrat, ob das

Ergebnis Null ist, ob das Ergebnis negativ ist etc. ! neben dem Ausgang $X besitzt das Rechenwerk noch einen weiteren Datenausgang, der den

Rest der Division bzw. die oberen 64 Bits des Ergebnisses einer Multiplikation aufnimmt; im weiteren Verlauf wird dieser Ausgang jedoch ausser Acht gelassen

• Kombinatorischer Schieber (Shifter)

! logisches Schieben + sowohl beim Links- als auch beim Rechtsschieben werden Nullen nachgezogen

4-24

+ wird beim MMIX durch die Befehle SLU[I] und SRU[I] ausgeführt

! arithmetisches Schieben + beim Linksschieben werden Nullen nachgezogen + beim Rechtsschieben wird das Vorzeichen nachgezogen + wird beim MMIX durch die Befehle SL[I] und SR[I] ausgeführt

! Beispiel: Kombinatorischer Schieber für n = 8

0

3

Ausgang

k

3

2

0

1

2

2

3

33

Überlauf

2

1

0

00 SL[I]01 SLU[I]10 SR[I]11 SRU[I]

3

0

7

8

8

Eingang

0

7

8 8

k ÜArt

"E A<<>>

Abb. 145: Symbol und Realisierung eines kombinatorischen Schiebers

• Rechenwerk: Addition und Subtraktion

! wird auf Logik-Ebene durchgeführt (bottom up)

4-25

• Multiplikations-Werk Allgemein

! Nomenklatur: Produkt = Multiplikand $ Multiplikator ! bei Prozessoren ist die Wortbreite von Multiplikand und Multiplikator stets gleich ! Annahme: die Wortbreite der Operanden beträgt n Bit �

+ Wertebereich der Operanden maximal 0 … 2n – 1 + � Ergebnis hat maximal -ª º .« »

n nld[(2 1) (2 1)] 2n- - Stellen � kein Überlauf möglich

+ größtmögliches Ergebnis: N!

�n 1mal n mal

11...100...01

! Zahl im 2er-Komplement wird zunächst in die Darstellung „Vorzeichen und Betrag“ umgewan-delt

+ es werden nur vorzeichenlose Zahlen multipliziert + das Vorzeichen wird separat betrachtet (Vorzeichen Produkt = Vorzeichen Multiplikand

XOR Vorzeichen Multiplikator) Erstes Multiplikationsverfahren

! wie in der Schule ! da hier jedoch Basis 2, hat das zur gerade betrachteten Multiplikator-Stelle gehörige Teil-

Produkt entweder den Wert Null oder den Wert des Multiplikanden

! Beispiel (n = 4 Bit)

Multiplikand Multiplikator

Produkt:

Übertrag 111

max. 2n Stellen

1

1 0 1 1 · 1 1 0 1

1 0 1 1 0 0 0 0

1 0 1 1 1 0 1 1

1 0 0 0 1 1 1 1

Teilprodukte

! Hardware-Aufbau

Multiplikand (2n Bit)

Multiplikator (n Bit)

Produkt (2n Bit)

links schieben

Steuerung

übernehmen

LSB

rechts schieben

2n-Bit Addierer2n Bit

2n Bit

2n Bit

links schieben

rechts schieben

Abb. 146: Prinzip-Darstellung des Multiplizierers nach dem ersten Verfahren

4-26

! das Produkt befindet sich in einem 2n Bit breiten Register ! der Multiplikand und der Multiplikator befinden sich in sog. Schieberegistern ! Schieberegister sind Register, deren Inhalt nach links oder rechts geschoben werden kann

Nachfolgende Abbildung beschreibt das Verfahren, mit dem die oben angegebene Hardware-Prinzip-Schaltung eine Multiplikation ausführen kann. Hierbei meint

! Multiplikator[0] das LSB (least significant bit) des Multiplikators, also das Bit ganz rechts im Mul-tiplikator-Register

! Multiplikand = Multiplikand << 1, dass der im Schieberegister Multiplikand stehende Wert um eins nach links geschoben wird

! Multiplikator = Multiplikator >> 1, dass der im Schieberegister Multiplikator stehende Wert um eins nach rechts geschoben wird

Multiplikand im Multiplikand-Register ablegen

Multiplikator im Multiplikator-Registers ablegen

Multiplikator[0]

n Runden?

Multiplikator[0] == 0

Ende

ja

Start

Produkt-Register mit 0 initialisieren

nein


Produkt = Produkt + Multiplikand

Multiplikand = Multiplikand << 1

Multiplikator = Multiplikator >> 1

Abb. 147: Erstes Multiplikationsverfahren

4-27

! Beispiel: 3 $ 4 = 12 (Wortbreite n = 4)

Multiplikand

0 0 0 0 0 0 1 10 0 0 0 0 1 1 00 0 0 0 1 1 0 00 0 0 1 1 0 0 00 0 1 1 0 0 0 0

Produkt

0 0 0 0 0 0 0 00 0 0 0 1 1 0 0

Addierer

0 1 0 00 0 1 00 0 0 10 0 0 00 0 0 0

Multiplikator

Produkt = Multiplikand $ Multiplikator

3. RundeInitialisierung

1. Runde

2. Runde

3. Runde4. Runde

Initialisierung

Initialisierung1. Runde

2. Runde

3. Runde

4. Runde

Abb. 148: Beispiel zur Multiplikation nach dem ersten Verfahren

! Zweites Multiplikationsverfahren

+ das zweite Multiplikationsverfahren basiert auf dem ersten Multiplikationsverfahren + anstatt den Multiplikanden nach links zu schieben, wird jetzt das Produkt nach rechts ge-

schoben + Vorteile

• das Multiplikand-Register muss nur noch n Bit breit sein und nicht mehr 2n Bit, wodurch Hardware eingespart wird

• der Addierer muss nur noch n Bit breit sein und nicht mehr 2n Bit, wodurch nicht nur Hardware eingespart wird, sondern die Addition (und damit dann auch die Multiplikation) auch noch schneller durchgeführt werden kann (vgl. Kap. 4.4.3 und 4.4.4)

4-28

Multiplikand (n Bit)

Multiplikator (n Bit)

Produkt (2n Bit) Steuerung

übernehmen

LSB

rechts schieben

n-Bit Addierer

n Bit

n Bit

n Bit

Produkt links Produkt rechts

rechts schieben

rechts schieben

rechts schieben

Abb. 149: Prinzip-Darstellung des Multiplizierers nach dem zweiten Verfahren

! Das Produktregister muss hier nach rechts geschoben werden können, also als Schieberegister

ausgeführt sein


Multiplikator im Multiplikator-Registers ablegen

Multiplikator[0]

n Runden?


Ende

ja

Start

Produkt-Register mit 0 initialisieren

nein


Produkt links = Produkt links + Multiplikand

Produkt = Produkt >> 1

Multiplikator = Multiplikator >> 1

Abb. 150: Zweites Multiplikationsverfahren

4-29

! Drittes Multiplikationsverfahren

+ das dritte Multiplikationsverfahren basiert auf dem zweiten Multiplikationsverfahren + der Multiplikator wird hier jedoch im rechten Teil des Produkt-Registers abgelegt, wodurch

das Multiplikator-Register entfallen kann � Einsparung von Hardware

Multiplikand (n Bit)

Produkt (2n Bit) Steuerung

LSB

n-Bit Addierern Bit

n Bit

n Bit

Produkt links(mit 0 initialisiert)

Produkt rechts(mit Multiplikator initialisiert)

rechts schieben

rechts schieben

übernehmen

Abb. 151: Prinzip-Darstellung des Multiplizierers nach dem dritten Verfahren

4-30


Multiplikator im rechten Teil des Produkt-Registers ablegen

Produkt[0]

n Runden?

Produkt[0] == 0

Ende

ja

Start

Linken Teil des Produkt-Registers mit 0 initialisieren

nein

Produkt[0] == 1

Produkt links = Produkt links + Multiplikand

Produkt = Produkt >> 1

Abb. 152: Drittes Multiplikationsverfahren

4-31

! Hardware-Multiplizierer nach dem 3. Verfahren Nachdem nun die Verfahren zur Multiplikation dargestellt wurden, wird das 3. Multiplikationsverfahren als Schaltung implementiert.

Clk

nn

n BitAdd

n

Clk

nProdukt

Multipli-kand

Steuerung

2nMULU

n

n

2n "n

0 1

n..2n-1

0

n..2n-1

n

0

1

0..n-1

Init/>>1

>>1

0..n-12n

n

0

Multiplikator

Multiplikand

Produkt

Abb. 153: Symbol und Aufbau des Multiplizierers nach dem 3. Verfahren

4-32

• Divisions-Werk Allgemein:

! Nomenklatur: Dividend / Divisor = Quotient + Rest ! Kein Überlauf möglich ! Zahl im 2er-Komplement wird zunächst in die Darstellung „Vorzeichen und Betrag“ umgewan-

delt + es werden nur vorzeichenlose Zahlen dividiert + das Vorzeichen wird separat betrachtet

• das Vorzeichen des Quotienten entspricht der XOR-Verknüpfung von Dividend und Di-visor

• das Vorzeichen des Rests entspricht dem Vorzeichen des Dividenden Erstes Divisionsverfahren:

! wie in der Schule ! Beispiel zur Division in der Basis 10: 9876 / 54 = 182 Rest 48

9 8 7 6 : 0 0 5 4 =

Dividend Divisor

1. Teildividend = 9

Passt 54 in 9? Nein � nächsten Teildividenden probieren

9 8 7 6 : 0 0 5 4 = 1

Dividend Divisor

2. Teildividend = 98

Passt 54 in 98? Ja � Wie oft? # 98 – 54 = 44 (1 mal) 44 – 54 = –10 (negativ � bleibt bei 1 mal)

4 4 7 6 : 0 0 5 4 = 1 8

Dividend Divisor


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 = –39 (negativ � bleibt bei 8 mal)

0 1 5 6 : 0 0 5 4 = 1 8 2 Rest 48

Dividend Divisor


Passt 54 in 156? Ja � Wie oft? # 156 – 54 = 102 (1 mal)102 – 54 = 048 (2 mal)048 – 54 = –6 (negativ � bleibt bei 2 mal)

4-33

! selbes Prinzip bei Division in der Basis 2, Divisor kann hier jedoch maximal einmal in den Teil-dividenden reinpassen

! Test, ob Divisor in den Teildividenden reinpasst durch Subtraktion: Rest = Teildividend – Divisor + MSB von Rest == 1 " Rest negativ � Divisor hat nicht in den Teildividenden gepasst + MSB von Rest == 0 " Rest positiv � Divisor hat genau einmal in den Teildividenden ge-

passt

! Hardware-Aufbau

Divisor (2n Bit)

Quotient (n Bit)

Rest (2n Bit)

rechts schieben

Steuerung

übernehmen

LSB

links schieben

2n Bit-ALU2n Bit

2n Bit

2n Bit

rechts schieben

links schieben

MSB

Abb. 154: Prinzip-Darstellung des Dividierers nach dem ersten Verfahren

! Verfahren

Dividend im Rest-Register ablegen

Divisor in linker Hälfte desDivisor-Registers ablegen

Rest = Rest - Divisor

Rest

Quotient = Quotient | 1 Rest = Rest + Divisor

n Runden?

Rest ( 0 Rest < 0

Ende

ja

Start

nein

Divisor = Divisor >> 1

Quotient = Quotient << 1

Abb. 155: Erstes Divisionsverfahren

4-34

! Quotient = Quotient | 1 meint hier die logische ODER-Verknüpfung der Zahl Eins mit dem Wert in Register Quotient und die anschliessende Abspeicherung des Ergebnisses im Register Quo-tient, also das Setzen des niederwertigsten Bits im Register Quotient

! da bei der Division nicht nur addiert, sondern auch subtrahiert werden muss, ist hier die Ver-

wendung einer ALU (Arithmetic Logic Unit) notwendig, die sowohl addieren als auch subtrahie-ren kann; ein Addierer alleine wie bei der Multiplikation ist hier nicht mehr ausreichend

! die Steuerleitung, die von der Steuerung zur ALU geht dient hierbei zur Auswahl der arithmeti-schen Funktion, teilt der ALU also mit, ob sie addieren oder subtrahieren soll

! Beispiel zur Basis 2: 7 / 3 = 2 Rest 1 (Wortbreite n = 4)

+ aufeinanderfolgende Runden sind jeweils durch eine andere Farbe dargestellt + das Ergebnis steht am Schluss im Quotienten-Register, der Rest im Rest-Register + die Bildung des 1er-Komplements des Divisors dient lediglich zur Bildung des 2er-

Komplements des Divisors + die Bildung des 2er-Komplements dient zur Subtraktion des Divisors vom Rest (deswegen

ist in nachfolgender Grafik nur ein Addierer und kein Subtrahierer abgebildet) + nachdem der Divisor vom Rest subtrahiert wurde, kann anhand des MSBs das Vorzeichen

festgestellt werden und im oben angegebenen Ablaufdiagramm dann entsprechend ver-zweigt werden

1er-Kompl. des DivisorsDivisor

0 0 1 1 0 0 0 00 0 0 1 1 0 0 00 0 0 0 1 1 0 00 0 0 0 0 1 1 00 0 0 0 0 0 1 1

1 1 1 0 0 1 1 11 1 1 1 0 0 1 11 1 1 1 1 0 0 11 1 1 1 1 1 0 0

Rest

2er-Kompl. des Divisors

1 1 1 0 1 0 0 01 1 1 1 0 1 0 01 1 1 1 1 0 1 01 1 1 1 1 1 0 1

0 0 0 0 0 1 1 11 1 1 0 1 1 1 10 0 0 0 0 1 1 11 1 1 1 1 0 1 10 0 0 0 0 1 1 10 0 0 0 0 0 0 11 1 1 1 1 1 1 00 0 0 0 0 0 0 1

Addierer

X X X XX X X 0X X 0 0X 0 0 10 0 1 0

Quotient

Quotient = Dividend : Divisor

1. Runde

2. Runde

3. Runde

4. Runde

Initialisierung1. Runde

2. Runde

3. Runde4. Runde

1. Runde

2. Runde

3. Runde4. Runde

Init.

negativ

positiv

negativ

Abb. 156: Beispiel zur Division nach dem ersten Verfahren

4-35

Zweites Divisionsverfahren:

! das zweite Divisionsverfahren basiert auf dem ersten Divisionsverfahren ! anstatt den Divisor nach rechts zu schieben, wird hier jetzt der Rest nach links geschoben

! Vorteile

+ das Divisor-Register muss nur noch n Bit breit sein und nicht mehr 2n Bit, wodurch Hard-ware eingespart wird

+ die ALU muss nur noch n Bit breit sein und nicht mehr 2n Bit, wodurch nicht nur Hardware eingespart wird, sondern die Addition/Subtraktion (und damit dann auch die Division) auch noch schneller durchgeführt werden kann (vgl. Kap. 4.4.3 und 4.4.4)

! der prinzipielle Hardware-Aufbau des Dividierers nach dem zweiten Verfahren ergibt sich also

wie folgt:

Divisor (n Bit)

Quotient (n Bit)

Steuerung

LSB

links schieben

n Bit-ALUn Bit

n Bit

n Bit

Rest links Rest rechts

links schieben

links schieben

Rest links übernehmenRest (2n Bit)

MSB

links schieben

Abb. 157: Prinzip-Darstellung des Dividierers nach dem zweiten Verfahren

! das zur Hardware gehörige Verfahren ist in nachfolgender Abbildung angegeben

4-36


Divisor im Divisor-Register ablegen


Rest

Quotient = Quotient | 1 Rest = Rest + Divisor

n Runden?

Rest ( 0 Rest < 0

Ende

ja

Start

nein

Rest = Rest << 1

Quotient = Quotient << 1

Abb. 158: Zweites Divisionsverfahren

4-37

Drittes Divisionsverfahren

! da das Rest-Register genauso wie das Quotienten-Register nach links geschoben wird, ist es sinnvoll, im Rest-Register nicht von rechts Nullen nachzuziehen, sondern den Quotienten auf-zubauen

! Vorteil: Das Quotientenregister kann eingespart werden

Divisor (n Bit)

Steuerung

n Bit-ALUn Bit

n Bit

n Bit

Rest links Rest rechts

links schieben

Rest links übernehmenRest (2n Bit)

MSB

links schiebenLSB

Abb. 159: Prinzip-Darstellung für das dritte Divisions-Verfahren




Rest

Rest = Rest | 1 Rest = Rest + Divisor

n Runden?

Rest ( 0 Rest < 0

Ende

ja

Start

nein

Rest = Rest << 1

Abb. 160: Drittes Divisionsverfahren

4-38

Hardware-Dividierer nach dem 3. Verfahren

! nachfolgende Abbildung zeigt das Symbol und den Aufbau eines Dividierers, der nach dem 3. Verfahren arbeitet

Clk

n

n

n BitSub

n

Clkn

Rest

Divisor

Steuerung

2n1 0n..2n-1

0

n..2n-1

n

0 0..n-1

Init/<<1

<<10..n-1

2n1

n

n

Dividend

Divisor

Rest undQuotient

ab

11..n-1

0 0

n

Multiplexer neg

DIVU

n

n

2n "

Abb. 161: Symbol und Aufbau des Dividierers nach dem 3. Verfahren

! bei dieser Realisierung wird ein kleiner Trick angewendet + am Subtrahierer liegt permanent der Divisor und das obere Halbwort des Rest-Registers an + da unmittelbar nach dem Links-Schieben des Rest-Registers auch das aktualisierte obere

Halbwort des Rest-Registers am Subtrahierer anliegt, berechnet dieser automatisch Rest – Divisor und zeigt an der Ausgangsleitung neg an, ob das Ergebnis negativ ist oder nicht

+ ist das Ergebnis negativ, wird es einfach ignoriert, also nicht in das Rest-Register übertra-

gen, wodurch das Wiederherstellen des zuvor im Rest-Register abgespeicherten Werts durch Rest = Rest + Divisor entfällt; dies ist der Grund, warum in obiger Schaltung nur ein Subtrahierer eingebaut ist

+ ist das Ergebnis positiv, muss es ins Rest-Register übernommen werden + gleichzeitig kann dabei im unteren Halbwort das niederwertigste Bit gesetzt werden

! berücksichtigt man diesen Umstand, muss der dritte Divisionsalgorithmus leicht abgewandelt werden (vgl. nachfolgende Abbildung)

4-39



Ergebnis = Rest - Divisor

Rest

Rest = Rest | 1

n Runden?

Rest ( 0 Rest < 0

Ende

ja

Start

nein

Rest = Rest << 1

Rest = Ergebnis

Abb. 162: Auf die Hardware-Schaltung angepasster 3. Divisionsalgorithmus

4.4.5 Steuerung • Zustandsautomat • Mit Multiplexern • Mit PLA • Mit (P)ROM # FAQs

5-1

5 Ebene der Digitalen Logik

5.1 Logikgatter

5.1.1 UND-Verknüpfung (AND)

Eingang 1

Eingang 2

Ausgang

Eingang 1 Eingang 2 Ausgang

0 0 00 1 01 0 01 1 1

5.1.2 ODER-Verknüpfung (OR)

Eingang 1

Eingang 2

Ausgang


0 0 00 1 11 0 11 1 1

5.1.3 NICHT-Verknüpfung (NOT)

Eingang AusgangEingang Ausgang

0 11 0

5.1.4 NICHT-UND-Verknüpfung (NAND)

Eingang 1

Eingang 2

Ausgang


0 0 10 1 11 0 11 1 0

5-2

5.1.5 NICHT-ODER-Verknüpfung (NOR)

Eingang 1

Eingang 2

Ausgang


0 0 10 1 01 0 01 1 0

5.1.6 Exklusiv-ODER-Verknüpfung/Antivalenz (XOR)

Eingang 1

Eingang 2

Ausgang


0 0 00 1 11 0 11 1 0

Die Exklusiv-Oder-Verknüpfung lässt sich mit den bereits kennengelernten Gattern wie folgt imple-mentieren:

Eingang 1

Eingang 2

Ausgang

Eingang 1

Eingang 2

Ausgang

Abb. 163: Symbol und Aufbau eines XOR-Gatters

5.2 Performance auf Logik-Ebene: Gatterlaufzeiten

5.2.1 Ein- und Ausgangspegel bei Logikschaltungen

! wie aus den vorausgehenden Wertetabellen ersichtlich ist, benötigen die hier betrachteten Bau-elemente an ihren Eingängen digitale Logik-Pegel („0“ oder „1“ bzw. „low“ und „high“) und stel-len an ihren Ausgängen wiederum digitale Logik-Pegel bereit

! Strom und Spannung sind jedoch analoge Grössen ! In welcher Beziehung stehen Logik-Pegel zu analogen Signalen?

! Antwort: soll eine Spannung als digitaler Logik-Pegel interpretiert werden, erfolgt die Zuordnung

von analogen Spannungspegeln zu digitalen Signalen „0“ und „1“ bzw. „low“ und „high“ wie folgt:

+ ein Bauelement mit digitalem Eingang interpretiert eine Eingangsspannung genau dann als

low-Pegel, wenn diese zwischen GND (ground " Masse, also 0 V) und UeLmax (vgl. nachfol-gende Abbildung) liegt; UeLmax kann hierbei von Bauelement zu Bauelement verschieden sein und muss dem Datenblatt des Bauelements entnommen werden

5-3

+ ein Bauelement mit digitalem Eingang interpretiert eine Eingangsspannung genau dann als high-Pegel, wenn diese zwischen UeHmin und der Versorgungsspannung VCC (Voltage Col-lector to Collector) liegt

+ liegt an einem Bauelement mit digitalem Eingang eine Spannung aus dem Bereich UeLmax

bis UeHmin an, so ist nicht definiert, als welchen Logik-Pegel das Bauelement die Eingangs-spannung interpretiert

GND

VCCSH = oberer Stör-spannungsabstand

SL = unterer Stör-spannungsabstand

undefinierterBereich

Eingangsspannungen,die als low-Pegel er-kannt werden

UeHmin

UeLmaxUaLmax

UaHmin

Eingangsspannungen,die als high-Pegel er-kannt werden

Vom Hersteller garantierterAusgangs-Spannungs-Be-reich für high-Pegel

Vom Hersteller garantierterAusgangs-Spannungs-Be-reich für low-Pegel

U

Abb. 164: Spannungspegel an Ein- und Ausgängen von Gattern

! Damit Ausgänge von Logik-Bauelementen wieder an die Eingänge anderer Bauelemente ge-

schaltet werden können – ohne Gefahr zu laufen, Eingangspegel im undefinierten Bereich zu liefern – liegt die maximale Ausgangsspannung UaLmax für einen Low-Pegel deutlich unter dem-jenigen Eingangspegel UeLmax, der gerade noch als low-Pegel erkannt wird

! Ebenso liegt die von einem Logik-Bauelement im Falle eines high-Pegels gelieferte Spannung

im Bereich zwischen UaHmin und VCC, also deutlich über der von Bauelementen gerade noch als high-Pegel erkannten Eingangsspannung UeHmin

! werden an einen Gatter-Ausgang mehrere Gatter-Eingänge angeschlossen, so wird der Aus-

gang im Vergleich zum Anschluss nur eines Gatters stärker belastet, was zu einem Absinken der Ausgangsspannung des Gatter-Ausgangs führt

! die maximale Anzahl der (Standard-) Gatter-Eingänge, die an einen Gatter-Ausgang ange-

schlossen werden darf, ohne die Ausgangsspannung durch die Belastung in den undefinierten Bereich zu bringen, wird Fan-Out genannt

! Im Gegensatz dazu gibt der Fan-In an, wieviel mal grösser der Eingangsstrom eines bestimm-

ten Gatters grösser ist als der typische Eingangsstrom eines Standard-Gatters

! sollen also an einen Gatterausgang mit einem bestimmten Fan-Out mehrere Eingangsgatter angeschlossen werden, so darf die Summe der Fan-Ins der Eingangsgatter den Fan-Out des Ausgangs-Gatters nicht überschreiten

! müssen an einen Gatterausgang trotzdem mehr Gatter angeschlossen werden, als der Fan-Out

zulässt, muß die Last auf mehrere Treiberbausteine verteilt werden

5-4

Ausgangsgattermit bestimmtem

Fan-Out

Treiberbausteine, diesich die Last teilen

mehrere Ein-gangs-Gatter

Abb. 165: Verteilung grosser Lasten auf mehrere Treiberbausteine

Durch das Einfügen zusätzlicher Treiberbausteine verlängert sich die Zeit, die ein Signal vom Eingang bis zum Ausgang einer Schaltung benötigt. Man sagt auch „die Anzahl der von der Schaltung benötig-ten Gatterlaufzeiten wird grösser“. Was Gatterlaufzeiten genau sind und wie sie entstehen, behandelt der nächste Abschnitt.

5-5

5.2.2 Entstehung von Gatterlaufzeiten

! in nachfolgender Abbildung ist ein Beispiel für einen idealen Spannungsverlauf eines digitalen Signals dargestellt, der durch unendlich steile Flanken zu den Zeitpunkten t0 (Wechsel von low auf high) und t1 (Wechsel von high auf low) gekennzeichnet ist

t0

t

VCC

t1

GND

U

Abb. 166: Idealer Spannungsverlauf an einem Gattereingang

! aufgrund parasitärer Kapazitäten an/in den Transistoren, mit denen Logik-Bauelemente reali-

siert werden, ergeben sich an den Ein- und Ausgängen von Logik-Bauelementen bei einem Wechsel des Logik-Pegels jedoch keine unendlich steilen Flanken, sondern Flanken mit expo-nentiellem An- bzw. Abklingen (vgl. Lade- bzw. Entladekennlinie eines Kondensators), wie in nachfolgender Abbildung angedeutet

t0

t

VCC

t1

GND

U

Abb. 167: Realer Spannungsverlauf an einem Gattereingang

! zeichnet man in den realen Spannungsverlauf die für high- und low-Pegel erlaubten Span-nungsbereiche ein, so ergeben sich nach den Zeitpunkten t0 und t1 Zeitverzögerungen

5-6

t0

t

VCC

t1

GND

U

high

low

unde-finiert

unde-finiert

Logik-Pegel

Zeitverzögerung Zeitverzögerung

UeHmin

UeLmax

Abb. 168: Zeitverzögerungen durch parasitäre Kapazitäten

! diese Zeitverzögerungen führen dazu, dass Logik-Bauelemente über sogenannte Gatterlaufzei-ten (propagation delay time) verfügen, im Folgenden auch Glz abgekürzt

! allgemein beschreibt die Gatterlaufzeit die Verzögerung, die zwischen einem Eingangssignal

und seiner Wirkung am Ausgang des betrachteten Bauelements liegt

LogikpegelEingang

1 Glz 1 Glz

t

t

LogikpegelAusgang

high

low

high

low

Abb. 169: Gatterlaufzeit

! ergeben sich für low-high- und high-low-Übergänge unterschiedliche Verzögerungen, so wird

die Gatterlaufzeit als Mittelwert der Verzögerungszeiten der beiden Übergänge definiert

5-7

LogikpegelEingang

/1

t

t

LogikpegelAusgang

high

low

high

low

/2

= / + /1 211 Glz ( )2

Abb. 170: Ungleiche Verzögerungen für fallende und steigende Flanken

5-8

5.2.3 Kritischer Pfad

! bei Logik-Schaltungen spielt oft die Durchlaufzeit der Eingangssignale durch die Schaltung eine grosse Rolle, da sie die Ausführungszeit der von der Schaltung implementierten Funktion38 be-stimmt

! die Ausführungszeit ergibt sich hierbei als die Summe der Gatterlaufzeiten entlang des Wegs,

der vom Eingang zum Ausgang durchlaufen die meisten Gatterlaufzeiten verursacht

! dieser Weg wird kritischer Pfad oder auch längster Pfad genannt

! betrachtet man beispielsweise nachfolgende Zusammenschaltung elementarer Logik-Bausteine, deren Verzögerung je eine Gatterlaufzeit beträgt, so ergibt sich der kritische Pfad wie folgt:

kritischer Pfad

Ausgang

Eingang 1Eingang 2

5 Glz

Abb. 171: kritischer Pfad

! die Ausführungszeit der Schaltung ergibt sich zu 5 Glz, da auf dem kritischen Pfad 5 Gatter lie-gen und jedes Gatter (nach obiger Annahme) genau 1 Glz benötigt

! der Begriff „Ausführungszeit“ bedeutet hierbei: 5 Glz, nachdem die Eingangssignale an die

Schaltung angelegt wurden, liegt am Ausgang das gültige Ergebnis an

! zur Analyse einer aus mehreren Teilschaltungen zusammengesetzten Schaltung kann es sinn-voll sein, zunächst die Gatterlaufzeiten der Teilschaltungen zu bestimmen

! hierzu ist die Bestimmung des kritischen Pfads jedes Eingangs notwendig, also die maximale

Gatterlaufzeit zwischen Ausgang und jedem einzelnen Eingang

kritischer Pfad „nach Eingang 1“

kritischer Pfad „nach Eingang 2“

Ausgang

Eingang 1Eingang 2

4 Glz nach Eingang 15 Glz nach Eingang 2

Abb. 172: kritischer Pfad nach Eingängen differenziert

! der Ausdruck „x Glz nach Eingang y“ bedeutet hierbei: x Gatterlaufzeiten, nachdem am Eingang

y das Eingangssignal angelegt wurde, steht am Ausgang das Ausgangssignal bereit

! wird bspw. bei obigem Beispiel vor den Eingang 1 eine Schaltung plaziert, die 8 Glz benötigt, vor den Eingang 2 jedoch eine Schaltung, die nur 6 Glz benötigt, so kann die Durchlaufzeit durch die gesamte Schaltung sehr einfach zu max(8+4, 6+5) Glz = 12 Glz berechnet werden

38 Bei einer Logik-Schaltung, die beispielsweise zwei binär kodierte Zahlen addiert, meint der Ausdruck „von der Schaltung implementierte Funktion“ die Addition.

5-9

5.2.4 Verkürzung des kritischen Pfads durch Verwendung zusätzlicher Hardware

! durch zusätzliche Hardware kann die Ausführungszeit einer Schaltung zu einem bestimmten Grad verringert werden

! nachfolgende Abbildung zeigt zwei logisch äquivalente Möglichkeiten, Signale C1, C2 und C3 zu

berechnen und die zugehörige Schaltungsrealisierung

C0P0G0P1G1

C1

C2

P2G2

C3

C0P0G0P1G1P2G2

C1

C2

C3

C1 = G0 0 (P0 1 C0)C2 = G1 0 (P1 1 G0) 0 (P1 1 P0 1 C0)C3 = G2 0 (P2 1 G1) 0 (P2 1 P1 1 G0)

0 (P2 1 P1 1 P0 1 C0)

C1 = G0 0 (P0 1 C0)C2 = G1 0 (P1 1 C1)C3 = G2 0 (P2 1 C2)

Abb. 173: Unterschiedliche Möglichkeiten zur Berechnung der Signale C1, C2 und C3

! bestimmt man den kritischen Pfad beider Realisierungen, so ergibt sich für die

+ linke Realisierung: 6 Gatterlaufzeiten + rechte Realisierung: 2 Gatterlaufzeiten

! dass die Annahme von nur 1 Gatterlaufzeit zum Durchlaufen eines Gatters mit vielen Eingän-

gen gerechtfertigt ist, zeigt nachfolgende Open-Collector-Realisierung eines Mehrfach-ODER-Gatters

Abb. 174: Open-Collector-Realisierung eines Mehrfach-ODER-Gatters

5-10

! der oben angegebenen Open-Collector-Realisierung kann man entnehmen, dass die Anzahl der benötigten Transistoren direkt proportional zur Anzahl der Eingänge ist, weshalb im Folgen-den zur Abschätzung des Hardwareaufwands einer Gatterschaltung die Summe der Daten-Eingänge der Elementargatter mit der Anzahl der zur Realisierung benötigten Transistoren gleichgesetzt wird

! bestimmt man nun mit diesem Maß den Hardwareaufwand für die beiden in angegebenen Rea-

lisierungen, so ergibt sich näherungsweise für die + linke Realisierung: 12 Transistoren + rechte Realisierung: 25 Transistoren

Hardwareaufwand[Transistoren]

Ausführungszeit[Gatterlaufzeiten]

25

12

62

rechte Realisierung

linke Realisierung

Abb. 175: Hardwareaufwand und Ausführungszeit

! man erkennt leicht, das zur Reduzierung der Ausführungszeit auf ein Drittel nur knapp die dop-

pelte Menge an Transistoren notwendig war

! ein Maß dafür, wieviel mehr Hardware für einen bestimmten relativen Gewinn an Ausführungs-zeit aufgewendet werden muss, ist der Vergleich der beiden Rechtecksflächen, die das Produkt „Hardwareaufwand x Ausführungszeit“ darstellen

! in der Schaltungssynthese wird hierfür im Allgemeinen der Ausdruck AT verwendet, wobei AT für das Produkt aus Halbleiterfläche (Area) und Ausführungszeit (Time) steht

! Abschätzungen für die Beziehung Hardwareaufwand ļ Ausführungszeit haben im AT-Maß dort

oft die Form A = const, AT = const oder AT2 = const etc.

5-11

5.3 Aufbau der Kombinatorischen Funktionseinheiten

5.3.1 Kombinatorische Schaltungen Kombinatorische Schaltungen sind Schaltungen, deren Ausgangssignale sich ausschliesslich aus der logischen Verknüpfung der Eingangssignale ergeben. Im Gegensatz zu sequentiellen Schaltungen sind die Ausgangssignale kombinatorischer Schaltungen niemals auf Eingangssignale rückgekoppelt

fEingang 1

Eingang 2

Eingang n

Ausgang 1

Ausgang 2

Ausgang m

kombinatorischeSchaltung

Abb. 176: Kombinatorische Schaltung

Die Schaltfunktion f bildet die Eingänge auf die Ausgänge ab. Dabei gilt:

Ausgang i = f(Eingang 1, Eingang 2, … , Eingang n) 5.3.2 Rechenwerk: Logik-Einheiten • NICHT-Einheit (NOT unit)

64 64 64 64

0

1

63 63

1

0

Abb. 177: Symbol und Aufbau der NICHT-Einheit (NOT unit)

• ODER-Einheit (OR unit)

63

1

0

63

1

0

63

1

064

64

64

64

64

64

Abb. 178: Symbol und Aufbau der ODER-Einheit (OR unit)

5-12

• UND-Einheit (AND unit)

63

1

0

63

1

0

63

1

064

64

64

64

64

64

Abb. 179: Symbol und Aufbau der UND-Einheit (AND unit)

5.3.3 Rechenwerk: Addierer und Subtrahierer • 1-Bit Halbaddierer

! addiert zwei Eingangs-Bits (Operand 1 und Operand 2) ! liefert ein Ergebnis-Bit und ein Übertrags-Bit

Operand 1 Operand 2 Übertrag in nächste Stelle Ergebnis

0 0 0 00 1 0 11 0 0 11 1 1 0

Abb. 180: Wertetabelle 1-Bit Halbaddierer

! Übertrag entspricht UND-Verknüpfung der Operanden ! Ergebnis entspricht XOR-Verknüpfung der Operanden

2

Cout

HA

Operand 1Ergebnis

Übertrag(Carry Out)

Operand 2

1 Gatterlaufzeit

Abb. 181: Symbol und Realisierung eines Halbaddierers

! nimmt man an, dass das XOR-Gatter nicht wie in Kapitel 4.2.1 aus UND-, ODER- und NICHT-

Gattern aufgebaut wurde, sondern als „echtes“ Hardware-Gatter zur Verfügung steht, dann be-trägt die Durchlaufzeit durch den Halbaddierer genau 1 Gatterlaufzeit, da das UND- und das XOR-Gatter parallel durchlaufen werden

! sollen n 1-Bit-Addierer zu einem n-Bit-Addierer zusammengeschaltet werden, muss der Über-

trag aus der Stelle i zur Stelle i+1 dazuaddiert werden � Halbaddierer muss um einen weiteren Eingang erweitert werden, der noch zu den anderen Eingänge hinzuaddiert wird � Volladdierer

5-13

• 1-Bit Volladdierer

! addiert drei Eingangs-Bits (Operand1, Operand2 und Übertrag aus vorheriger Stelle) ! liefert ein Ergebnis-Bit und ein Übertrags-Bit

Übertrag aus

vorheriger Stelle Operand 1 Operand 2 Übertrag in nächste Stelle Ergebnis

0 0 0 0 00 0 1 0 10 1 0 0 10 1 1 1 01 0 0 0 11 0 1 1 01 1 0 1 01 1 1 1 1

Abb. 182: Wertetabelle 1-Bit Volladdierer

5-14

Im Folgenden wird untersucht, wie sich der Volladdierer implementieren lässt.

! für den Fall, dass der Übertrag aus der vorhergehenden Stelle Null ist, verhält sich der Vollad-dierer wie ein Halbaddierer (in nachfolgender Abbildung grau unterlegt)

Übertrag vorher-gehender Stelle

Operand 1 Operand 2 Übertrag in nächste Stelle

Ergebnis

0 0 0 0 00 0 1 0 10 1 0 0 10 1 1 1 01 0 0 0 11 0 1 1 01 1 0 1 01 1 1 1 1

Co 2HA

Operand 1 Operand 2 Übertrag ausvorhergehenderStelle (Carry In)

Ergebnis(Summe)

Übertrag in nächsteStelle (Carry Out)

! ist der Übertrag aus der vorhergehenden Stelle Eins, so sind die Werte des Ergebnisses im Ver-gleich zu den Werten des Ergebnisses für den Fall „Übertrag aus vorhergehender Stelle ist Null“ genau invertiert

! die Invertierung des Ergebnisses in Abhängigkeit des Eingangs „Übertrag aus vorhergehender Stelle“ lässt sich sehr einfach mit dem XOR-Gatter eines weiteren Halbaddierers erreichen

Übertrag vorhergehender Stelle


Ergebnis

0 0 0 0 00 0 1 0 10 1 0 0 10 1 1 1 01 0 0 0 11 0 1 1 01 1 0 1 01 1 1 1 1

1

Co 2HA

Co 2HA

Operand 2 Übertrag ausvorhergehenderStelle (Carry In)

Ergebnis(Summe)


Operand 1

5-15

! ist der Übertrag aus der vorhergehenden Stelle Null, leitet das XOR-Gatter den Ergebnis-Ausgang des ersten Halbaddierers einfach an den Ausgang des Volladdierers weiter (vgl. Wer-tetabelle für XOR)

! ist der Übertrag aus der vorhergehenden Stelle jedoch Eins, so invertiert das XOR-Gatter den Ergebnis-Ausgang des ersten Halbaddierers, bevor es ihn an den Ausgang des Volladdierers weiterleitet (vgl. Wertetabelle für XOR)

! ein Übertrag tritt beim Volladdierer genau dann auf, wenn + der erste Halbaddierer einen Übertrag generiert (1), ODER + Operand 1 und Operand 2 unterschiedliche Werte haben (2) UND ein Übertrag aus der vor-

herigen Stelle stattfand (3)

1

1

3

Übertrag vorhergehender Stelle


Ergebnis

0 0 0 0 00 0 1 0 10 1 0 0 10 1 1 1 01 0 0 0 11 0 1 1 01 1 0 1 01 1 1 1 1

2

2

! da Operand 1 und Operand 2 genau dann unterschiedliche Werte haben, wenn der Ergebnis-Ausgang des ersten Halbaddierers den Wert Eins hat (XOR-Verknüpfung), kann der Volladdie-rer unter Verwendung des noch freien UND-Gatters des zweiten Halbaddierers wie folgt imple-mentiert werden:

VA

Cout 2

CinCo 2

HA

Co 2HA 3 Glz (Gatter-

laufzeiten)

Operand 2 Übertrag ausvorhergehenderStelle (Carry In)

Ergebnis(Summe)


Operand 1

Abb. 183: Symbol und Realisierung eines Volladdierers

! da sowohl jeder Halbaddierer als auch die ODER-Verknüpfung genau eine Gatterlaufzeit benö-tigt, sind zur Berechnung einer 1-Bit-Addition mit Hilfe eines Volladdierers drei Gatterlaufzeiten notwendig

5-16

• 64-Bit Ripple-Carry Addierer ! bisher: nur 1 Bit addieren ! jetzt: Hintereinanderschalten von 64 1-Bit Addierern � 64-Bit Addierer

VACout 2

Cin

Summe0

a0 b0

VA2

Summe1

a1 b1

VA2

Summe2

a2 b2

VA2

Summen-2

an-2 bn-2

VA2

Summen-1

an-1 bn-1

CStatus-Register

CarryOut

CinCinCinCin

CoutCoutCoutCout

c1c2c3cn-2cn-1

c0

0

Abb. 184: Ripple-Carry-Addierer

! der Übertrag wird von VA-Stufe zu VA-Stufe weitergeleitet " „das Carry ‚rippelt’ sich durch die

VA-Stufen durch“ (engl. ripple " Welle � das Carry breitet sich wie eine Welle aus)

! tritt ein Überlauf auf, wird in einem Status-Register das Bit „Carry Out“ gesetzt

! da in der 2er-Komplement-Darstellung eine Zahl b von einer Zahl a subtrahiert werden kann, in-dem b zuerst negiert und anschliessend zu a addiert wird, lässt sich der Ripple-Carry Addierer sehr einfach um die Subtraktion erweitern

VACout 2

Cin

Summe0bzw. Differenz0

0 1

a0 b0

VA2

0 1

a1 b1

VA2

0 1

a2 b2

VA2

0 1

an-2 bn-2

VA2

0 1

an-1 bn-1

O CStatus-Register

OverflowDetection

Unit

CarryOutOverflow

CinCinCinCin

CoutCoutCoutCout

c1c2c3cn-2cn-1

c0

je 3 Glz

je 3 Glz(Gatter-laufzeiten)



Summen-2bzw. Differenzn-2



sub/add

Abb. 185: Addition und Subtraktion in Ripple-Carry-Technik

! Fall 1: Steuerleitung sub/add ist logisch „0“

+ die bi werden über den Eingang 0 der Multiplexer an den Multiplexer-Ausgang weitergeleitet und somit dem Volladdierer zugeführt

+ es gilt c0 = 0 + � Schaltung verhält sich wie zuvor der Addierer

! Fall 2: Steuerleitung sub/add ist logisch „1“

+ den Volladdierern werden die invertierten Signale ib zugeführt � Bildung des 1er-Komplements

+ c0 = 1 " Addition des Wertes 1 � umwandeln des 1er-Komplements in das 2er-Komplement

5-17

+ � Schaltung verhält sich wie ein Subtrahierer

! die sog. Overflow Detection Unit überprüft, ob sich bei einer vorzeichenbehafteten Interpretation der Operanden und des Ergebnisses ein Überlauf ergeben würde und zeigt diesen durch Set-zen des Bits O (Overflow) in einem Status-Register an

! einfach und flächengünstig, jedoch sehr lange Ausführungszeit

+ Summe: 6 + 2(n-2) + 1 Glz39 + Carry Out: 6 + 2(n-1) Glz40 + Overflow: 6 + 2(n-2) +3 Glz41

• 64-Bit Carry-Look-Ahead (CLA) Addierer42

! Idee: Berechnung der Überträge der einzelnen Volladdierer durch zusätzliche Logik � Verrin-gerung der Ausführungszeit dadurch, dass das „durchrippeln“ des Carrys aus der niedrigsten Stelle vermieden wird

! Carry wird im Voraus berechnet (engl. to look ahead " vorausschauen, die Zukunft planen) • Einstufiger Carry-Look-Ahead Addierer

! Rekursive Berechnung der Überträge ci (vgl. vorausgehende Abbildung): ci+1 = (ai 1 bi) 0 [(ai 0 bi) 1 ci] = gi 0 (pi 1 ci)

! gi = generate = ai 1 bi " Volladdierer i erzeugt einen Übertrag (engl. to generate " erzeugen) ! pi = propagate = ai 0 bi " Volladdierer i leitet den Wert an seinem Übertrags-Eingang (Cin) an

seinen Übertrags-Ausgang (Cout) weiter (engl. to propagate " weiterleiten)

! Wasserrohr-Analogie (vgl. [CO&D]) zu generate und propagate (vgl. nachfolgende Abbildung) + pi-1 = 0 � Wasser aller davor liegender Speicher (i-2, i-3, …) wird abgeblockt und hat somit

keinen Einfluss mehr auf den nachfolgenden Wasserstrom; Stufe i-1 leitet also kein Wasser aus vorhergehenden Stufen weiter

+ pi = 1 � Wasser aus davor liegenden Speichern wird weitergeleitet (propagiert); betrifft hier nur den Speicher i-1, da pi-1 = 0

+ gi-1 = 1 � Wasser aus dem Wasserspeicher i-1 kann von der Sammelleitung übernommen werden; aus Sicht der Sammelleitung generiert der Speicher i-1 Wasser

+ gi = 0 � Wasser aus dem Wasserspeicher i kann von der Sammelleitung nicht übernom-men werden; aus Sicht der Sammelleitung wird also an der Stelle i kein Wasser generiert

gi+1 = 1

pi+1 = 1

gi = 0

pi = 1

gi-1 = 1pi-1 = 0

Wasserspeicher i

Sammelleitung

Abb. 186: Wasserrohr-Analogie zu „generate“ und „propagate“

39 6 Glz für c1 + 2(n-2) Glz für c2 … cn-2 + 1 Glz für den zweiten Halbaddierer des letzten Volladdierers. 40 6 Glz für c1 + 2(n-1) Glz für c2 … cn-1 41 6 Glz für c1 + 2(n-2) Glz für c2 … cn-2 + 3 Glz für die Overflow Detection Unit 42 Die in diesem Kapitel betrachteten Carry-Look-Ahead Addierer können aufgrund der Invertierung der bi und aufgrund des Setzens von c0 auf den Wert eins natürlich auch subtrahieren. Der Einfachheit halber werden sie jedoch auch weiterhin einfach nur „CLA-Addierer“ genannt. Der Hinweis auf die ebenfalls mögliche Subtraktion entfällt somit.

5-18

! konkret ergibt sich für die Überträge ci des einstufigen CLA-Addierers durch Auswertung obiger rekursiver Formel

c1 = g0 0 (p0 1 c0) c2 = g1 0 (p1 1 c1) = g1 0 (p1 1 g0) 0 (p1 1 p0 1 c0) c3 = g2 0 (p2 1 c2) = g2 0 (p2 1 g1) 0 (p2 1 p1 1 g0) 0 (p2 1 p1 1 p0 1 c0) c4 = g3 0 (p3 1 c3) = g3 0 (p3 1 g2) 0 (p3 1 p2 1 g1) 0 (p3 1 p2 1 p1 1 g0) 0 (p3 1 p2 1 p1 1 p0 1 c0) c5 = … ….

0 1

a3 b3

VACout 2

Cin

Summe3

g2 p2

0 1

a2 b2

VACout 2

Cin

Summe2

g1 p1

0 1

a1 b1

VACout 2

Cin

Summe1

g0 p0

0 1

a0 b0

VACout 2

Cin

Summe0

g3 p3

c4 c3 c2 c1 c0

c0p0

g0p1

g1p2

g2p3

g3

sub/add

Abb. 187: Einstufige Carry-Look-Ahead Technik

! da der Hardwareaufwand mit zunehmender Wortbreite stark anwächst, liegt es nahe, anstelle eines einstufigen CLA-Addierers mit grosser Wortbreite mehrere einstufige CLA-Addierer mit kleinerer Wortbreite zu verwenden

! für die Menge der kleineren einstufigen CLA-Addierer werden dann wesentlich weniger Gatter benötigt als für einen entsprechend grossen einstufigen CLA-Addierer

! wenn die CLA-Addierer analog zu den einzelnen VA-Stufen über die Signale Carry-In, Generate

und Propagate verfügen, kann bei der Zusammensetzung des grossen CLA-Addierers aus den kleinen einstufigen CLA-Addierern der Übertrag wieder in Carry-Look-Ahead-Technik bestimmt werden

! fasst man beispielsweise immer vier Volladdierer-Stufen zu einem einstufigen CLA-Addierer zu-

sammen, so ergeben sich dessen Signale G und P wie folgt:

c4 = g3 0 (p3 1 g2) 0 (p3 1 p2 1 g1) 0 (p3 1 p2 1 p1 1 g0) 0 (p3 1 p2 1 p1 1 p0 1 c0)

G 0 ( P 1 c0)

! nachfolgende Abbildung zeigt das Symbol für einen solchen einstufigen CLA-Addierer mit der Wortbreite n = 4 Bit

5-19

einstufigCLA

4 4

4

Bi

C

G

P

a b

Abb. 188: Symbol eines einstufigen CLA Addierers

! die Steuerleitung Bi dient hier zur Auswahl der invertierten Eingänge 0b … 3b , C entspricht dem

Carry-In, also dem Übertrag aus der vorhergehenden Stelle

! der Aufbau eines einstufigen CLA-Addierers mit n = 4 ergibt sich wie nachstehend angegeben:

a3 b3

VACout 2

Cin

Summe3

g2 p2

a2 b2

VACout 2

Cin

Summe2

g1 p1

a1 b1

VACout 2

Cin

Summe1

g0 p0

a0 b0

VACout 2

Cin

Summe0

g3 p3

G c3 c2 c1 c0

c0p0

g0p1

g1p2

g2

P

C

Bi

4 4

4

0 1

a b

Abb. 189: Aufbau eines einstufigen Carry-Look-Ahead Addierers mit Wortbreite n = 4

5-20

! schaltet man nun mehrere einstufige CLA-Addierer zusammen, so ergeben sich für die einzel-nen Addierer die Signale P und G wie folgt

pi = ai 0 bi � je 1 Gatterlaufzeit nach ai bzw. bi

2 Glz

P0 = p3P1 = p7P2 = p11P3 = p15P4 = ……

1111

p2p6p10p14

1111

p1p5p9p13

p0p4p8p12

1111

pi = ai 0 bi bzw. gi = ai 1 bi � je 1 Gatterlaufzeit nach ai bzw. bi

2 Glz

3 Glz

2 Glz 2 Glz

G0 = G1 =G2 =G3 = G4 =…

g3g7g11g15…

0000

0000

0000

1111

(p3(p7(p11(p15

g2)g6)

g10)g14)

(p3(p7(p11(p15

p2p6p10p14

g1)g5)g9)

g13)

1111

1111

g0)g4)g8)

g12)

1111

(p3(p7(p11(p15

p2p6p10p14

p1p5p9p13

1111

1111

! als Ausführungszeit des einstufigen CLA-Addierers ergibt sich somit:

+ Summe: 6 Glz nach a, b bzw. 3 Glz nach C + G: 6 Glz nach a, b (3 Glz nach ai, bi + 3 Glz für Auswahl Addition/Subtraktion) + P: 5 Glz nach a, b (2 Glz nach ai, bi + 3 Glz für Auswahl Addition/Subtraktion)

5-21

• Zweistufiger Carry-Look-Ahead Addierer

! nachstehende Grafik zeigt, wie vier einzelne je vier Bit breite CLA-Addierer zu einem zwei-stufigen 16 Bit breiten CLA-Addierer zusammengeschaltet werden

einstufigCLA

4

44

Bi

G0

Carry-Look-Ahead-Einheit

P0 C0

3…0

3…0

3…0

einstufigCLA

4

44

Bi

G1 P1 C1

7…4

7…4

7…4

einstufigCLA

4

44

Bi

G2 P2 C2

11…8

11…8

11…8

einstufigCLA

4

44

Bi

G3 P3 C3

15…12

15…12

15…12

Operand 1

Operand 2

Bi (für Sub-traktion)

Summe bzw.Differenz

CC0PP0GG0

a b a b a b a b

Abb. 190: Zweistufiger Carry-Look-Ahead Addierer

! die Carry-Signale C1 bis C3 werden hierbei von der Carry-Look-Ahead-Einheit analog zu den

Signalen c1 bis c3 (s.o.) wie folgt bestimmt:

C1 = G0 0 (P0 1 C0)C2 = G1 0 (P1 1 G0) 0 (P1 1 P0 1 C0)C3 = G2 0 (P2 1 G1) 0 (P2 1 P1 1 G0) 0 (P2 1 P1 1 P0 1 C0)

5 Glznach a, b

6 Glznach a, b

7 Glz nach a, b

8 Glz nach a, b

! da der zweistufige CLA-Addierer im Folgenden nicht „alleine“ betrieben wird, sondern wieder ei-ne Menge zweistufiger CLA-Addierer zu einem dreistufigen CLA-Addierer zusammengeschaltet wird, ist die Berechnung des Übertrags C4 hier nicht notwendig

! bei Bedarf könnte C4 jedoch analog zu c4 wie folgt berechnet werden:

C4 = G 3 0 (P3 1 G2) 0 (P3 1 P2 1 G1) 0 (P3 1 P2 1 P1 1 G0) 0 (P3 1 P2 1 P1 1 P0 1 C0)

! die Eingänge CC0, G3 und P3 werden von der Carry-Look-Ahead-Einheit ohne Änderung auf die

Ausgänge C0, GG0 und PP0 weitergeleitet

! für die Ausführungszeit ergibt sich hier + Ci: 8 Glz nach a, b bzw. 2 Glz nach CC0 (s.o.) + Summe: 11 Glz nach a, b (3 Glz für Summe nach Ci + 8 Glz für Ci nach a, b) bzw. 5 Glz

nach CC0 (5 Glz für Summe nach Ci + 2 Glz für Ci nach CC0) + GG0: 6 Glz nach a, b (GG 3 G) + PP0: 5 Glz nach a, b (PP 3 P)

5-22

• Dreistufiger Carry-Look-Ahead Addierer

! zur Erweiterung des Addierers von 16 auf 64 Bit können vier zweistufige 16 Bit breiten CLA-Addierer zu einem dreistufigen 64 Bit breiten CLA-Addierer wie folgt verschaltet werden:

Carry-Look-Ahead-EinheitCarry-Look-Ahead-EinheitCarry-Look-Ahead-EinheitCarry-Look-Ahead-Einheit

Carry-Look-Ahead-Einheit

64

6464

OverflowDetection

Unit sub/add

Carryout

Over-flow

CC0CC1CC2CC3

CC4

PP0GG0PP1GG1PP2GG2PP3GG3

c63

a b

! die Überträge CC1 bis CC4 werden von der grossen CLA-Einheit analog zu C1 bis C4 bzw. c1 bis c4 erzeugt:

CC1 = GG0 0 (PP0 1 CC0)CC2 = GG1 0 (PP1 1 GG0) 0 (PP1 1 PP0 1 CC0)CC3 = GG2 0 (PP2 1 GG1) 0 (PP2 1 PP1 1 GG0) 0 (PP2 1 PP1 1 PP0 1 CC0)CC4 = GG3 0 (PP3 1 GG2) 0 (PP3 1 PP2 1 GG1) 0 (PP3 1 PP2 1 PP1 1 GG0)

0 (PP3 1 PP2 1 PP1 1 PP0 1 CC0)7 Glz nach a, b

6 Glz nach a, b 5 Glz nach a, b

7 Glz nach a, b

8 Glz nach a, b

! die Leitung „Carry out“ entspricht dem Übertrag CC4 und zeigt einen Überlauf bei der Addition vorzeichenloser Zahlen an

! die Leitung „Overflow“ zeigt einen Überlauf bei der Addition vorzeichenbehafteter Zahlen an

! die Leitung sub / add dient zur Auswahl von Addition und Subtraktion

+ der Strich über dem „add“ bedeutet, dass die Funktion „add“ genau dann freigeschaltet wird, wenn eine Null an der Leitung anliegt

+ add wird also in sog. negativer Logik angesprochen

! Ausführungszeit + Carry Out: 8 Glz nach a, b + Overflow: 15 Glz nach a, b (3 Glz für Overflow nach c63 + 2 Glz für c63 nach C15 + 2 Glz für

C15 nach CC3 + 8 Glz für CC3 nach a, b) + Summe: 13 Glz nach a, b (5 Glz für Summe nach CCi + 8 Glz für CCi nach a, b)

5-23

! Geschwindigkeitsvergleich beim Berechnen der Summe von 64 Bit breiten Zahlen + Ripple-Carry Addierer: 131 Glz + Zweistufiger Carry-Look-Ahead Addierer: 13 Glz

! Vergleich des Hardwareaufwands

+ Ripple-Carry Addierer: 1036 Transistoren + Dreistufiger CLA-Addierer: 2108 Transistoren

! Der CLA Addierer benötigt zwar doppelt so viele Transistoren wie der Ripple-Carry-Addierer, ist

dafür aber 10 mal schneller 5.3.4 Status-Einheit Die in Kap. 2.8.8 und 2.8.9 aufgeführten MMIX-Befehle führen bestimmte Operationen in Abhängigkeit bestimmter Eigenschaften von Zahlen aus. Diese Eigenschaften sind beispielsweise „Zahl ist Null“, Zahl ist negativ“ etc. Im Folgenden wird eine Status-Einheit angegeben, die eine 64 Bit breite Zahl auf diese Eigenschaften überprüft und das Ergebnis als Statusinformation am Ausgang bereitstellt

63

Z " Zero " Zahl == 0

NZ " Not Zero " Zahl � 0

N " Negative " Zahl < 0

NN " Not Negative " Zahl � 0

P " Positive " Zahl > 0

NP " Not Positive " Zahl � 0

0 EV " Even " Zahl mod 2 = 0

OD " Odd " Zahl mod 2 = 1

64Status-Einheit

64 8

"

Abb. 191: Symbol und Aufbau der Status-Einheit

5.3.5 Multiplexer Nachfolgende Abbildung zeigt den Aufbau eines 4:1 Multiplexers aus Logikgattern.

5-24

Eingang 0

Eingang 1

Eingang 2

Eingang 3

Steuerungsbus

Ausgang

2

Abb. 192: Aufbau eines Multiplexers

Im Folgenden wird am Beispiel der Wortbreite n = 4 gezeigt, wie sich ein Bus-Multiplexer aus mehre-ren parallelen 1-Bit Multiplexern zusammensetzen lässt:

0123

0123

0123

0123

Bus-Eingang 0

Bus-Eingang 1

Bus-Eingang 2

Bus-Eingang 3

Bus-Ausgang

Steuerung2

Abb. 193: Aufbau eines Bus-Multiplexers

5-25

5.3.6 Demultiplexer/Decoder

5.4 Aufbau der Sequentiellen Funktionseinheiten

5.4.1 Was bedeutet „sequentiell“? 5.4.2 Speicher 5.4.3 Register 5.4.4 Additions- und Subtraktions-Werk

5-26

5.4.5 Verwendung des Subtraktionswerks für Vergleichsoperationen Mit der Subtraktion lassen sich sehr einfach Zahlenvergleiche implementieren

! MMIX-Vergleichs-Befehl: CMP $X,$Y,$Z + liefert $X=-1, wenn s($Y)<s($Z) + liefert $X=0, wenn s($Y)==s($Z) + liefert $X=1, wenn s($Y)>s($Z)

! subtrahiert man $Z von $Y, so bekommt man bei

+ s($Y)<s($Z) ein negatives Ergebnis + s($Y)==s($Z) Null als Ergebnis + ($Y)>s($Z) ein positives Ergebnis

! zur Realisierung des CMP-Befehls unter Zuhilfenahme eines Subtrahierers muss man also

noch + jedes negative Ergebnis in -1 wandeln (-1 entspricht im 2er-Komplement 11…11) + die Null als Ergebnis lassen (0 entspricht 00…00) + jedes positive Ergebnis in 1 wandeln (1 entspricht 00…01)

! nachfolgend angegebene Schaltung führt diese Operationen durch:

CLA-Add/Sub

64

64

a

b

64

sub/add = 164

6321

0

0123

2012

002

112

002

0

1

01234

63

64

CMP-Erweiterung

64

hat high-Pegel, wenn dasErgebnis den Wert Null hat

hat high-Pegel,wenn das Ergeb-nis negativ ist

Abb. 194: Subtrahierer mit CMP-Erweiterung

! Bit 0 des Multiplexer-Ausgangs wird direkt an den Ausgang der CMP-Erweiterung weiterge-

reicht, Bit 1 wird zuvor auf die Bits 1…63 erweitert, so dass am 64 Bit breiten Ausgang der CMP-Erweiterung die Bits 1…63 alle dem Bit 1 des Multiplexer-Ausgangs entsprechen

! die NOR-Einheit überprüft hierbei, ob das Ergebnis Null war und schaltet in diesem Fall den

Multiplexer-Eingang 1 oder 3, also jedesmal den Wert 002, auf den Ausgang durch ! durch die Erweiterung von Bit 1 auf 1…63 liegt am Ausgang dann der Wert 00…002 (also 010)

an

! Leitung 63 entspricht dem Vorzeichen des Ergebnisses + hat das Vorzeichen den Wert 0 und ist das Ergebnis nicht 0, dann wird der Eingang 0 des

Multiplexers, also der Wert 012, an den Ausgang weitergeschaltet • Bit 0 wird direkt an den Ausgang gelegt � Bit 0 hat den Wert 1 • Bit 1 wird auf Bit 1…63 erweitert � Bit 1…63 haben den Wert 0 • am Ausgang der CMP-Erweiterung liegt also der Wert 00…012 (also 110) an

+ hat das Vorzeichen den Wert 1 (und ist das Ergebnis nicht 0), dann wird der Eingang 2 des Multiplexers, also der Wert 112, an den Ausgang weitergeleitet

• Bit 0 wird direkt an den Ausgang gelegt � Bit 0 hat den Wert 1 • Bit 1 wird auf Bit 1…63 erweitert � Bit 1…63 haben den Wert 1

am Ausgang der CMP-Erweiterung liegt also der Wert 11…1112 (also -110) an

6-1

6 Performance-Erhöhung auf Mikroarchitektur-Ebene 6.1 Multi-Cycle-Datenpfad

In einem vorangegangenen Kapitel wurde gezeigt, dass die Taktung des Befehlszählers durch die Steuerung erfolgt. Die Steuerung wiederum verwendet zur Erzeugung des benötigten Takts einen Taktgenerator.

Taktausgang

Abb. 195: Taktgenerator

Der in der Steuerung untergebrachte Taktgenerator erzeugt den sog. Prozessortakt.

! mit jeder positiven Flanke wird durch die Taktung des Befehlszählers ein neuer Befehl aus dem Befehlsspeicher geladen und dann vom Datenpfad ausgeführt

! da beim Single-Cycle-Datenpfad immer nur ein Befehl im Datenpfad verarbeitet werden kann,

darf jeder Befehl zur Ausführung maximal die Zeit zwischen zwei positiven Taktflanken, also maximal die Zeit eines Taktzyklusses benötigen

! das gilt sowohl für Befehle, die schnell ausgeführt werden können (z.B. eine ODER-

Verknüpfung), als auch für Befehle, die zur Ausführung viel Zeit benötigen (z.B. eine Division) Im Umkehrschluss muss die Taktzykluszeit also mindestens so lang sein, dass auch der längste Be-fehl vollständig abgearbeitet werden kann.

! die minimale Dauer eines Taktzyklus (und damit die Ausführungszeit jedes Befehls) ergibt sich damit aus der Ausführungszeit des längsten Befehls, ist also sehr lang

! die zur Taktung des Single-Cycle-Datenpfads max. erlaubte Taktfrequenz ist damit sehr niedrig

Die nachfolgende Abbildung zeigt, dass die Befehlsausführung (grau markiert) bei kurzen Befehlen folglich nur den Bruchteil eines Taktzyklus dauert, der Datenpfad für den Rest des Taktzyklus also ungenutzt bleibt:

Takt

Befehlsausführung

Datenpfad läuft „leer“

Abb. 196: „Leerlaufen“ des Datenpfads

6-2

Die Ausnutzung des Datenpfads ist gerade dann besonders schlecht, wenn es Befehle gibt, die sehr lange dauern, diese Befehle jedoch nur selten vorkommen und stattdessen wesentlich kürzere Befeh-le sehr häufig ausgeführt werden. Quantitative Untersuchungen zeigen, dass gerade dieser Fall sehr häufig vorkommt. Das trifft auch auf unsere bisher kennengelernten MMIX-Programme zu

! die am häufigsten auftretenden Befehle sind ADD, SUB, OR, AND, SL, SR etc., also Befehle, die sehr schnell (im MMIX-Simulator in 1 &, also in 1 Takt) ausgeführt werden können43

! der längste MMIX-Befehl, der DIV-Befehl, der beim MMIX-Simulator 60 Takte dauert, wird fast

nie verwendet, bremst jedoch aufgrund seiner Länge die anderen Befehle aus Da bei einem Single-Cycle-Datenpfad die Ausführungszeit jedes Befehls auf die Ausführungszeit des längsten Befehls „gestreckt“ wird, würde der MMIX-Simulator in Single-Cycle-Realisierung zur Ausfüh-rung unserer Programme (bei Vernachlässigung der Speicherzugriffe) bis zu 60 mal länger zur Aus-führung benötigen. Wie man diese stark erhöhte Ausführungszeit umgehen kann, wird im nächsten Kapitel beim Multi-Cycle-Datenpfad aufgezeigt.

43 Bei unseren Programmen kommen auch die Speicher- und Ladebefehle STO und LDO sehr häufig vor. Diese Befehle dauern aufgrund des Speicherzugriffs zwar sehr lange, die vom Prozessor auszuführende Arbeit beschränkt sich hier jedoch auf das Addieren der beiden Register $Y und $Z bzw. auf das Addieren von Register $Y zum Direktoperanden Z, was einer schnell ausführbaren Operation entspricht.

6-3

6.2 Pipelining

Gleichzeitige Nutzung der Ressourcen unterschiedlicher Multi-Cycle-Datenpfad-Stufen � Erhöhung des Befehls-Durchsatzes durch Parallelisierung 6.2.1 Implementierung

! Erweiterung des Multi-Cycle-Datenpfades um Pipeline-Register, welche die komplette Steuerin-formation für jede Stufe enthalten.

Befehls-Speicher

32 Lesen $Z

Lesen $Y

Schreiben/Lesen $X

Schreib-Daten $X

Lese-Daten $Z

Lese-Daten $Y

Registerblock

0..7

8..15Daten

ALU64

BZ64

Adresse

Add64

4

64

Schreiben

640

1

24..31

32

64BR

64

64

0

1

2

64

64

64

ES

ALU-Funktion

64

Daten-Speicher

Adr.

Lese-Daten $X

64 Schreib-Daten

SP

AFDirektoperand

ES

SP ES

2Zugriffs-Art

Zugriffs-Art

Lese-Daten

Ergebnisauswahl

16..23

Reg.-Schreiben

8 8

8

8

Sp.-Schreiben

Schrei-ben

0

1

32

64

Steuerung

8

8Clk1

Clk2Clk3

Clk4

Reg.-Puls

Sp.-Puls

X-A

usw

ahl

16..23 $X

$Y

$Z

DirOp.

X X X

ErgALU

$X

ErgALU

LeseDat.

648

056

6-4

! Funktion der Pipeline-Stufen

+ BH: Befehl holen • Auslesen des durch den Befehlszähler BZ adressierten Befehls aus dem Befehlsspei-

cher • Ablegen des ausgelesenen Befehls in das Befehlsregister BR • Inkrememtieren des Befehlszählers

+ BD: Befehl dekodieren und Operanden bereitstellen

• Interpretation des Opcodes des im Befehlsregister stehenden Befehls durch die Steue-rung

• Generierung der für die weiteren Pipeline-Stufen benötigten Steuersignale durch die Steuerung

• Ablegen der generierten Steuersignale im nächsten Pipelineregister • Auslesen der Operanden ($X, $Y und $Z) aus dem Registerblock • Ablegen der ausgelesenen Operanden im nächsten Pipelineregister • Abspeichern des Z-Operanden im nächsten Pipelineregister

+ AF: Befehl ausführen

• Weiterleitung des $X-Operanden ins nächste Pipeline-Register • ALU-Funktion aus Pipelineregister auslesen und der ALU zuführen • Operanden aus Pipelineregister mit ALU-Funktion verknüpfen • Ergebnis im nächsten Pipelineregister abspeichern

+ SP: Speicherzugriff

• Weiterleitung des Ergebnisses der vorhergehenden Stufe in das nächste Pipelineregis-ter

• Adressierung des Datenspeichers mit dem Ergebnis der vorangegangenen Pipeline-Stufe

• Im Falle eines Ladebefehls Auslesen des adressierten Wortes aus dem Datenspeicher und Ablegen des aus dem Datenspeicher ausgelesenen Wortes im nächsten Pipeline-register

• Im Falle eines Speicherbefehls Abspeichern des $X-Wertes im Datenspeicher

+ ES: Ergebnis (zurück-) schreiben • Adressierung des Zielregisters durch die im Pipelineregister stehende Adresse (X) • Abspeichern des Ergebnisses im adressierten Zielregister

6.2.2 Auswirkung auf die Ausführungszeit

! Maximal erreichbare Durchsatz-Erhöhung entspricht der Anzahl der Pipeline-Stufen

! Maximale Taktrate entspricht dem Kehrwert der Ausführungszeit der langsamsten Pipeline-Stufe

! Erhöhung der Ausführungszeit von Einzelbefehlen durch Anpassung der Ausführungszeit der

Pipeline-Stufen an die langsamste Pipeline-Stufe

! Minimierung der Erhöhung der Ausführungszeit der Einzelbefehle durch hardwareseitig zeitlich gleichlange Pipeline-Stufen

6-5

6.2.3 Pipeline-Stufen-Füll-Diagramm

! Befehlsfolge: LDO $1,P1 LDO $2,P2 ADD $4,$2,$1 OR $4,$4,#F0 STO $4,ERG1 ADD $4,$1,$1 STO $4,ERG2 ADD $4,$2,$2 STO $4,ERG3 SUB $5,$6,7 ... ...

! Pipelinefüllung (Idealfall ohne Pipeline-Konflikte)

BH BD AF SP ESLDO LDO LDO LDO LDO

LDO LDO LDO LDO LDO

ADD ADD ADD ADD ADD

OR OR OR OR OR

ADD ADD ADD ADD ADD

STO STO STO STO STO

BH BD AF SP ES

BH BD AF SP ES

BH BD AF SP ES

BH BD AF SP ES

STO STO STO STO

ADD ADD ADD

STO STO

SUB

BH BD AF SP ES

BH BD AF SP

BH BD AF

BH BD

BH

6-6

6.2.4 Pipeline-Konflikte (Hazards) • Daten-Konflikte (data hazards)

! Register wird als Quelle verwendet, ist aber von vorausgegangenem Befehl als Ziel verwendet worden, wobei das Zieldatum (das Ergebnis) noch nicht in den Registerblock zurückgeschrie-ben wurde

! Beispiel:

LDO $1,P1LDO $2,P2ADD $4,$2,$1

! Lösung

+ Forwarding-Pfade • Zusätzliche Datenleitungen im Datenpfad, die Ergebnis weiterleiten können • Vor ALU Quellauswahl durch Multiplexer

ALU640

1

64

64

0

1

64

Daten-Speicher

Adr.

Schreib-Daten

Zugriffs-Art

Lese-Daten

Schrei-ben

648

$X

$Y

$Z

DirOp.

ErgALU

$X

ErgALU

LeseDat.

AFBefehlsausführung

SPSpeicherzugriff

ESErgebnis(zurück-)schreiben

64

64

64

64012

012

Konflikt-Steuer-Einheit

64

6-7

+ Stalls: Einfügen von nop-Befehlen (nop = no operation), die ausser einer Zeitverzögerung keine Funktion haben, also nicht schreibend auf Register oder Speicher zugreifen


LDO LDO LDO LDO LDO

ADD ADD ADD ADD ADD

BH BD AF SP ES

BH BD AF SP ES

Forwarding-Pfad

Stall (eingefüg-ter NOP-Befehl)Stall Stall Stall StallStall

+ Alternative

Stall


LDO LDO LDO LDO LDO

ADD ADDStall

ADD ADD

OR OR OR OR

ADD ADD

STO STO STO

BH BD AF SP ES

BH BD AF SP

BH BD AF SP

BH BD AF

STO

ADD

BH BD

BH

ES

Stall

Stall

Stall

6-8

+ Befehlsumstellung (code movement)

• Umstellung der Befehlsreihenfolge

• Vorziehen von Befehlen, deren Quell-Operanden nicht durch vorhergehende Operatio-nen beeinflusst werden

• Sinnvolle Nutzung der Stall-Zeit (keine nops)

LDO $1,P1LDO $2,P2ADD $4,$2,$1OR $4,$4,#F0STO $4,ERG1ADD $4,$1,$1STO $4,ERG2ADD $4,$2,$2STO $4,ERG3SUB $5,$6,7... ...

LDO $1,P1LDO $2,P2

ADD $4,$2,$1OR $4,$4,#F0STO $4,ERG1ADD $4,$1,$1STO $4,ERG2ADD $4,$2,$2STO $4,ERG3SUB $5,$6,7... ...

LDO $1,P1LDO $2,P2SUB $5,$6,7ADD $4,$2,$1OR $4,$4,#F0STO $4,ERG1ADD $4,$1,$1STO $4,ERG2ADD $4,$2,$2STO $4,ERG3... ...

6-9

• Struktur-Konflikte (structural hazards)

! Gleichzeitiger Zugriff auf nur einmal verfügbare Ressourcen

! Beispiel


LDO LDO LDO LDO LDO

ADD ADD ADD ADD ADD

OR OR OR OR OR

ADD ADD ADD ADD ADD

STO STO STO STO STO

BH BD AF SP ES

BH BD AF SP ES

BH BD AF SP ES

BH BD AF SP ES

STO STO STO STO

ADD ADD ADD

STO STO

SUB

BH BD AF SP ES

BH BD AF SP

BH BD AF

BH BD

BH

LDO $1,P1LDO $2,P2ADD $4,$1,$2OR $4,$4,#F0STO $4,ERG1

! LDO-Befehl schreibt Ergebnis in Registerblock zurück und muss dafür $X adressieren

! STO-Befehl will $X auslesen und muss es dazu ebenfalls adressieren

! Lösung

+ Wenn möglich, Befehlsumstellung, so dass 3. Befehl nach LDO-Befehl wieder LDO-Befehl

+ Stalls

6-10

• Steuerungs-Konflikte (control hazards)

! Treffen von Entscheidungen, die auf Ergebnissen vorhergehender Befehle beruhen

! Beispiel: Bedingter Sprung in einer Schleife ... ... ... ... SETL $1,30 START ... ... ... ... ... ... ... ... SUB $1,$1,1 PBNZ $1,START ... ...

BH BD AF SP ES… … … … …

… … … … …

SUB SUB SUB SUB SUB

PBNZ PBNZ PBNZ PBNZ PBNZ

???

BH BD AF SP ES

BH BD AF SP ES

BH

Aussage über Sprung-durchführung frühestenshier möglich

AF SP ES

BH BD AF SP ES

Welchen Befehl holen?

tt1 t2 Problem: t1 < t2

BD

! Lösungen

+ Befehlsumstellung ... ... ... ... SETL $1,30 START SUB S1,S1,1 ... ... ... ... ... ... ... ... PBNZ $1,START ... ...

+ Stalls

+ Sprungvorhersage (branch prediction): es wird ein bestimmtes Sprungziel angenommen

6-11

• Konstante Vorhersage: Immer dasselbe Ergebnis vorhersagen � 50 % Trefferquote

• Kontextabhängige Vorhersage

! Wahrscheinliche Verzweigung do { ... } while(...)

! Unwahrscheinliche Verzweigung while(...) { ... }

! MMIX-Befehlssatz: + BZ für niedrige Sprungwahrscheinlichkeit + PBZ für hohe Sprungwahrscheinlichkeit

6-12

6.3 Cache

6.3.1 Problemstellung

! Leistungssteigerung Prozessoren >> Leistungssteigerung Speicherbausteine ! � Ständig steigende Leistungsdifferenz (performance gap)

t

Leistung

Speicher

Prozessor

performance gap

! Schnelle Speicher (z.B. SRAM) sehr teuer ! Billige Speicher (z.B. DRAM) sehr langsam

1Zugriffszeit

Kosten

! Kostenursache: Anzahl der Bauelemente pro Speicherzelle

N

P

N NN

P

UB

Adressleitung

Datenleitung Datenleitung

C

Adressleitung

Datenleitung

SRAM DRAM

6-13

6.3.2 Speicherhierarchie

! Ziel: Speichersystem mit dem PreisByte

-Verhältnis der billigsten Technologie mit der Zugriffszeit

der schnellsten Technologie

! Prinzip: + Zeitliche Lokalität: Verwendete Daten werden bald wieder verwendet + Örtliche Lokalität

• Sequentielle Befehlsfolge, Schleifen � Befehle in der Umgebung der verwendeten Be-fehle werden auch verwendet

• Analog bei Daten

! Realisierungsbeispiel

Prozessor Cache-Controller

Cache-Speicher

Arbeits-Speicher

1st level

2nd level

schnellkleinteuer

sehr schnellsehr kleinsehr teuer

langsamgroßbillig

Registersehr schnellsehr kleinsehr teuer

+ 1st level cache • Im Prozessor integriert • Mit Prozessortakt getaktet • SRAM • Sehr schnell • Hoher Verbrauch an Chipfläche, da viele Transistoren

+ 2nd level cache • Extern • Niedrigerer Takt als Prozessortakt • SRAM

+ Arbeitsspeicher • Niedriger Takt • DRAM

6-14

! Ebenenmodell + Je schneller die Technologie, desto näher am Prozessor + � Speicherzugriffszeit von der Hierarchie-Ebene des Datums abhängig + Datenaustausch nur zwischen benachbarten Ebenen (Austausch von Cache-Rahmen "

cache lines)

2nd level cache

Arbeitsspeicher

Register

1st level cache

Festplatte

! Fehlfall = Miss: Datum, auf das der Prozessor zugreifen will, ist nicht im Cache � Nachladen aus weiter weg liegender Ebene

! Regelfall = Treffer = Hit: Datum, auf das der Prozessor zugreifen will, ist im Cache vorrätig

! Hit time: Zugriffszeit für die oberste Hierarchie-Ebene bei einem Hit, inklusive des Tests auf Hit

oder Miss

! Miss-Penalty: Zugriffszeit für die oberste Hierarchie-Ebene bei einem Miss, inklusive des Tests auf Hit/Miss und dem Nachladen des Caches

! Trefferrate (hit rate): Prozentualer Anteil der Hits an den Gesamtzugriffen

! Fehlrate (miss rate): Prozentualer Anteil der Misses an den Gesamtzugriffen

! Trefferrate + Fehlrate = 1

4 16 64 256 1 k 4 k 16 k

50 %

100 %unterschiedlicheProgramme

Cachegrösse [Byte]

Fehlrate [%]

6-15

! Abhängigkeit der Treffer- bzw. Fehlrate + Cachegrösse + Art des Programms + Verdrängungsalgorithmus + Grösse der Nachladeeinheit + Cacheorganisation

6.3.3 Cacheorganisationen • Direktabgebildeter Cache (direct mapped cache)

Schlüssel ByAASP-Adresse

TagTag

Tag

0

ByteauswahlRahmen-Nr.

1234150123415

0123415

1414

14

4

vv

v

01

n-1

TagTag

01234150123415

1414

vv

TagTag

01234150123415

1414

vv

2345

Rahmen,cache line

Byte

! Tag-RAM beinhaltet den Schlüssel derjenigen ASP-Adresse, deren Daten im Cache liegen

! Valid-Bit zur Kennzeichnung gültiger Cache-Einträge

! Aufteilung der ASP-Adresse in + Byteauswahl: Dient bei Lesezugriffen der Auswahl der zu lesenden Byte + Rahmennummer: Wählt den zur ASP-Adresse gehörigen Rahmen aus + Schlüssel

• Wird beim Schreibzugriff im Tag-RAM abgelegt • Wird bei Lesezugriffen zur Hit-Erkennung verwendet

! Cachegrösse = (Rahmengrösse) · Anzahl der Rahmen

! Anzahl der Rahmen = 2 Anzahl der Bits für die Rahmennummer

! Rahmengrösse = 2 Anzahl der Bits für die Byteauswahl

! Anzahl der Bits für den Schlüssel = Anzahl der Tag-Bits

! Anzahl der Tag-Vergleicher entspricht der Schlüsselbreite

6-16

! Feste Abbildung der Arbeitsspeicher-Adressen auf einen Cache-Rahmen

! Jeder Rahmen ist für mehrere ASP-Adressen zuständig

ASP Cache

0x00...000x00...010x00...02

0xFF...FF

0x00...030x00...040x00...050x00...060x00...070x00...080x00...090x00...0A0x00...0B0x00...0C0x00...0D0x00...0E0x00...0F0x00...100x00...11

! Vorteile: Einfache Adressumsetzung, wenige Tag-Vergleicher

! Nachteil: Sehr frühe Verdrängung der Daten • Vollassoziativer Cache (fully associative cache)


0

Byteauswahl

1234150123415

0123415

1414

14

4

01234150123415

1414

01234150123415

1414

TagTag

Tag

vv

v

TagTag

vv

TagTag

vv

! Daten können unabhängig von der ASP-Adresse in jedem Rahmen abgelegt werden

! Vorteil: Flexibilität

! Nachteil: Anzahl der Tag-Vergleicher = Rahmenanzahl · Schlüsselbreite

6-17

• Set-Assoziativer Cache (set associative cache)


TagTag

0

ByteauswahlSet-Nr.

1234150123415

1414

4

vv0

TagTag

01234150123415

1414

vv

TagTag

01234150123415

1414

vv1

TagTag

01234150123415

1414

vv

TagTag

01234150123415

1414

vv

TagTag

01234150123415

1414

vv

n-2

n-1

Set

! Kompromiss zwischen direkt-abgebildetem und Set-assoziativem Cache

! Set-Nr. wählt Rahmenbereich aus, in dem der Rahmen abgelegt werden kann

! HW-Aufwand und Flexibilität skalierbar

! Anzahl der Tag-Vergleicher = Assoziativität · Schlüsselbreite

! Set-Grösse = Assoziativität · Rahmengrösse

! Assoziativität = Anzahl der Rahmen pro Set

! Anzahl der Rahmen = Assoziativität · Anzahl der Sets

! Anzahl der Sets = 2 Anzahl der Bits für die Set-Nr.

6-18

6.3.4 Schreibstrategien • Write-Through

! Bei einem Schreibzugriff auf den Cache wird das geschriebene Wort automatisch in den ASP geladen

! ASP und Cache stets konsistent # Vorteilhaft, wenn mehrere Prozessoren auf den selben ASP zugreifen

! Schreibpuffer (FIFO), um Prozessor bei vielen Schreibzugriffen nicht auszubremsen ! Datenstau, wenn Schreibpuffer hohe Schreibrate nicht mehr bewältigen können

• Write-Back

! Geschriebene Daten werden erst erst bei Verdrängung des Cache-Rahmens auf den ASP ge-schrieben

! ASP und Cache nach Schreibzugriffen inkonsistent ! Vorteilhaft bei hoher Schreibrate # Steigerung der Performance ! Komplexe Implementierung

6.3.5 Verdrängungsalgorithmen • LRU (least recently used)

! Verdrängung desjenigen Rahmens, der am längsten nicht mehr genutzt wurde ! Für die Praxis im Allgemeinen zu aufwändig

• Zyklische Verdrängung

! Rahmen werden unabhängig von Ihrer letzten Verwendung der Reihe nach verdrängt ! relativ einfache Implementierung ! Starke Verminderung der Performance, wenn in Schleifen immer gerade derjenige Eintrag ver-

drängt wird, der als nächstes benötigt wird • Zufällige Verdrängung

! Rahmen werden nach dem Zufalls-Prinzip verdrängt ! Insbesondere bei Schleifen (s.o.) nicht die schlechteste Wahl

6-19

6.3.6 Verfahren zur Verringerung der Transfer-Zeit

! Early Restart: Fortfahren mit der Befehlsausführung, sobald das gesuchte Datum in den Cache geladen wurde

! Requested word first/critical word first

+ Zuerst laden des gesuchten Wortes + Anschliessend Laden der dem gesuchten Wort nachfolgenden Worte + Zuletzt Laden der Worte vom Blockanfang bis zum zuvor gesuchten Wort

gesuchtCache-Block

Cache

gesucht

ASP

12

34

56

78

6.3.7 Prefetching

! Beim Laden des gesuchten Datums zusätzlich Laden nachfolgender Daten ! Grosser Vorteil beim Befehls-Cache, da hier oft sequentieller Zugriff auf konsekutive (aufeinan-

derfolgende) Adressen � nächster Befehl steht schon im Cache

6-20

6.3.8 Abhängigkeit der Miss-Rate von der Rahmengrösse

Miss-Rate

Rahmen-grösse

Bereich 1 Bereich 2

! Bereich 1: Miss-Rate sinkt mit steigender Rahmengrösse, da mit steigender Rahmengrösse auch die Anzahl der im Cache befindlichen Daten steigt

! Bereich 2: Miss-Rate steigt mit steigender Rahmengrösse

+ Rahmen werden nach dem Laden schnell verdrängt, wenn sie knapp werden + "Konkurrenzkampf" um die Rahmen

6-21

6.3.9 Metriken

! 1Performance ~Ausführungszeit

! Ausführungszeit = (CPU-Taktzyklen + Speicherzugriffs-Taktzyklen) · Taktzyklusdauer

! Speicherzugriffs-Taktzyklen = Schreib-Taktzyklen + Lese-Taktzyklen

! Schreib-Taktzyklen = Schreib-ZeitZyklusdauerª º« »« »

! Schreib-Zeit = Anzahl der Schreibzugriffe ·

[ (Schreib-Hit-Rate · Schreib-Hit-Time + Schreib-Miss-Rate · Schreib-Miss-Time)]

! Lese-Taktzyklen = Lese-ZeitZyklusdauerª º« »« »

! Lese-Zeit = Anzahl der Lesezugriffe ·

[ (Lese-Hit-Rate · Lese-Hit-Time + Lese-Miss-Rate · Lese-Miss-Time) ]

! Hit-Time: Zeit, die im Falle eines Hits für den Speicherzugriff benötigt wird (kurz)

! Miss-Time: Zeit, die im Falle eines Misses für den Speicherzugriff benötigt wird (lang)

! Miss-Penalty = Miss-Time – Hit-Time (Zeit, die im Falle eines Misses zusätzlich zur Hit-Time benötigt wird)

! Hit-Rate: Wahrscheinlichkeit, dass ein Zugriff auf das Speichersystem zu einem Hit führt (das gewünschte Datum befindet sich im Cache)

! Miss-Rate = 1 – Hit-Rate: Wahrscheinlichkeit, dass ein Zugriff auf das Speichersystem zu ei-

nem Miss führt (das gewünschte Datum befindet sich nicht im Cache)

! Speicherzugriffszeit = Anzahl der Hits · Hit-Time + Anzahl der Misses · Miss-Rate

! Anzahl der Hits = Hit-Rate · Anzahl der Speicherzugriffe

! Anzahl der Misses = Miss-Rate · Anzahl der Speicherzugriffe

! Durchschnittliche Speicherzugriffszeit AMAT (Average Memory Access Time): AMAT = Hit-Rate · Hit-Time + Miss-Rate · Miss-Time =

= Hit-Time + (Miss-Rate · Miss-Penalty)

6-22

A-1

A Komponenten eines Computers

B-1

B Bootvorgang eines Computers

C-1

C Zahldarstellung C.1 Allgemein

! B = Basis ! a: Koeffizienten zur Basis B

Zahl (a B a B a B a B a B )&!1 1 0 !1 !µ&!1 1 0 !1 !µ= ± + + + + + +" "

ganze Zahl echt gebrochene Zahl

gebrochen rationale Zahl

C.2 Integerzahlen

C.2.1 Vorzeichenlose Zahlen

! Darstellung zur Basis 2 ! Darstellbarer Wertebereich: 0 … 2n – 1

Zahl a 2 a 2 a 2 a 2&!1 &!2 1 0

&!1 &!2 1 0= $ + $ + + $ + $"

Speicherwort: a&!1 a&!2 a1 a0

C.2.2 Vorzeichenbehaftete Zahlen

! Darstellung als Vorzeichen und Betrag ! MSB entspricht dem Vorzeichen der Zahl ! Rest entspricht dem Betrag der Zahl ! Darstellbarer Wertebereich: – (2n-1 – 1) … – 0, 0, … +(2n-1 – 1)

! Vorteil: einfache Multipliplikation und Division

+ Vorzeichen kann einfach aus der XOR-Verknüpfung der MSBs bestimmt werden + Beträge können mit einfachen Algorithmen multipliziert/addiert werden

! Nachteil: schwierige Addition und Subtraktion

+ Wird im Bereich 00…0 bis 01…1 im Binärsystem 1 addiert, wird auch im Zehnersystem 1 addiert (so solls auch sein)

+ Wird im Bereich 10…0 bis 11…1 im Binärsystem 1 addiert, wird im Zehnersystem 1 subtra-hiert � Problem!

+ Doppelte Darstellung der Null + Da Addition/Subtraktion in Programmen wesentlich häufiger verwendet (z.B. Schleifenzähler

inkrementieren, Adressen berechnen etc.) wird als Multiplikation/Divison, wird diese Zahl-darstellung in Computersystemen nicht verwendet

C-2

! Beispiel mit Wortbreite n = 4

Bitmuster Wert0000 00001 10010 20011 30100 40101 50110 60111 71000 -01001 -11010 -21011 -31100 -41101 -51110 -61111 -7

! Darstellung im 1er-Komplement !

C.3 Gleitkommazahlen

NaN unendlich

D-1

D Spezialregister des MMIX-Prozessors

! rA = Arithmetic status register (für Trips) + Interrupt Enable Bits: Bit gesetzt " Interrupt freigeschaltet + Interrupt Event Bits: Bit wird beim Auftreten eines Interrupts durch die Hardware gesetzt und

signalisiert so den aufgetretenen Interrupt

R1 R0 D V W I O U Z X D V W I O U Z X00

GK-Zahl ungenau (z.B. 1.0/3.0)GK-Division durch 0GK-UnterlaufGK-ÜberlaufUngültige GK-Operation (z.B. )Überlauf bei GK-FK-WandlungInteger-ÜberlaufInteger-Division durch 0

00: nähester Wert (default)01: abrunden (gegen 0)10: aufrunden (gegen pos. unendl.)11: abrunden (gegen neg. unendl.)

GK-Rundungsmodus

Interrupt Enable Bits Interrupt Event Bits

nicht verwendet

1.0!

Abb. 197: Codierung des Spezialregisters rA

! rB = Bootstrap register (beim TRIP-Befehl): Puffert beim TRIP-Befehl das Register $255, da dieses mit rJ überschrieben wird.

! rC = Cycle counter: Enthält die Anzahl der bisher ausgeführten Taktzyklen. ! rD = Dividend register: Dient bei einer Integer-Division zur Aufnahme der oberen 64 Bit des Di-

videnden. ! rE = Epsilon register: Dient der Bereitstellung der bei GK-Vergleichen verwendeten *-

Umgebung. ! rF = Failure location register: Enthält im Falle eines Paritäts-Fehlers oder eines sonstigen Spei-

cher-Fehlers diejenige Speicheradresse, bei der der Fehler aufgetreten ist. ! rG = Global threshold register: Gibt die laufende Nummer des ersten globalen Registers an. ! rH = Himult register: Nimmt bei einer Integer-Multiplikation die oberen 64 Bit des Ergebnisses

auf. ! rI = Interval counter: Ermöglicht das automatische Anhalten des Programms nach einer be-

stimmten Anzahl vergangener Taktzyklen. Hierzu wird der Inhalt von rI bei jedem Taktzyklus um 1 verringert. Erreicht rI den Wert 0, so wird die Programmausführung gestoppt und rI der Wert 0xFFFFFFFFFFFFFFFF zugewiesen.

! rJ = Return-jump register: Enthält nach der Ausführung eines Registerstack-gestützten Sprungbefehls die Rücksprungadresse.

D-2

! rK = Interrupt mask register: Dient der Freischaltung einzelner Interrupts (dynamische Traps) + Bit = 0 " Interrupt freigeschaltet + Bit = 1 " Interrupt gesperrt + Handler vom Betriebssystem bereitgestellt + Handler beginnt an Adresse, die in rTT steht + Handler findet Interrupt-Ursache mit rQ 1 rK

w x n k b s pr

Befehl kommt von BS-SegmentBefehl verletzt Sicherheitsrichtlinien (Ausführenvon Befehlen an negativen Adressen, ohne dassalle Bits rwxnkbsp gesetzt sind) Befehl ist gegen die MMIX-RegelnPrivilegierter Befehl (Kernel-Modus)Befehl bezieht sich auf Adresse im BS-SegmentBefehl steht auf Seite ohne AusführungsrechtSchreiben auf Seite ohne SchreibrechtLesen von Seite ohne Leserecht

Programm-Bits Maschinen-Bits24 Bits E/A mit

niedriger Priorität24 Bits E/A mithoher Priorität

NeustartSpeicher nicht vorhanden

Speicher-ParitätsfehlerStromausfall

Abb. 198: Codierung der Spezialregister rK und rQ

! rL = Local threshold register: Legt die Anzahl der lokalen Register fest. ! rM = Multiplex mask register: Dient beim MUX-Befehl zur Bitauswahl zwischen Register $Y und $Z.

! rN = Serial number: Enthält die Seriennummer des Prozessors. Im Simulator wird die Serien-nummer bei der Assemblierung aus Datum und Uhrzeit generiert.

! rO = Register stack offset: Legt fest, an welcher Speicheradresse im Stack-Segment im Falle einer Verdrängung das erste sichtbare lokale Register abgespeichert wird.

! rP = Prediction register: Wird bei der Ausführung des CSWAP-Befehls verwendet. ! rQ = Interrupt request register

+ Signalisiert aufgetretene Hardware-Interrupts (dynamische Traps) + Bit-Codierung wie beim Register rK + Bit " 0: Interrupt nicht aufgetreten + Bit " 1: Interrupt aufgetreten

! rR = Remainder register: Nimmt bei einer Integer-Division den Rest auf. ! rS = Register stack pointer: Legt fest, an welcher Speicheradresse im Stack-Segment im Falle

einer Verdrängung das erste verborgene Register abgespeichert wird. ! rT = Trap address register: Beinhaltet beim Auftreten eines erzwungenen Traps die Anfangs-

adresse des Trap-Handlers. ! rU = Usage counter: Zählt, wie oft ein bestimmter Befehl ausgeführt wurde.

! rV = Virtual translation register: Ermöglicht Einstellungen zur Adressierung des virtuellen Spei-

chers.

D-3

function:0: Adr.-Umsetzung durch HW1: Adr.-Umsetzung durch SW (BS)sonst: Speicherzugriffsfehler

s r n fb4b3b2b1

4444 8 27 10 3

address space number:Gibt die Nummer des geradeaktuellen Adressraums an

root location

page size:Legt die Seitengöße zu 2s Byte fest

bi: Festlegung der Größe der einzelnenBereiche des Anwenderspeichers. Mitb0=0 gilt: Segment i hat höchstensSeiten.

i 1 ib b1024 + !

Abb. 199: Codierung des Spezialregisters rV

! rW = Where-interrupted register (bei TRIP): Bekommt beim Auftreten eines Trips die Adresse des dem unterbrochenen Befehl nachfolgenden Befehls zugewiesen.

! rX = Execution register (bei TRIP): Bekommt beim Auftreten eines Trips in den vier niederwer-tigen Byte den unterbrochenen Befehl zugewiesen (Opcode und Operanden). Die vier höher-wertigen Byte werden hierbei auf 0x80000000 gesetzt. Das höherwertigste Byte wird "ropco-de" genannt (vgl. RESUME).

! rY = Y-Operand (bei TRIP): Bekommt beim Auftreten eines Trips den Wert des Y-Operanden des Befehls, der den Trip verursacht hat, zugewiesen. Wurde ein Befehl zum Speichern von Daten unterbrochen, wird in rY der zu speichernde Wert abgelegt.

! rZ = Z-Operand (bei TRIP): Bekommt beim Auftreten eines Trips den Z-Operanden des Be-fehls, der den Trip verursacht hat, zugewiesen. Bei Befehlen zum Speichern von Daten wird in rZ die virtuelle Speicheradresse abgelegt.

! rBB = Bootstrap register (beim TRAP-Befehl): Puffert beim TRAP-Befehl das Register $255, da dieses mit rJ überschrieben wird.

! rTT = Dynamic trap address register: Beinhaltet beim Auftreten eines dynamischen Traps die Anfangsadresse des Trap-Handlers44.

! rWW = Where-interrupted register (bei TRAP): Bekommt beim Auftreten eines Traps die Adres-se des dem unterbrochenen Befehl nachfolgenden Befehls zugewiesen.

! rXX = Execution register (bei TRAP): Bekommt beim Auftreten eines Traps in den vier nieder-wertigen Byte den unterbrochenen Befehl zugewiesen (Opcode und Operanden). Die vier hö-herwertigen Byte werden hierbei auf 0x80000000 gesetzt. Das höherwertigste Byte wird "ropcode" genannt (vgl. RESUME).

! rYY = Y-Operand (bei TRAP): Bekommt beim Auftreten eines Traps den Y-Operanden des Be-fehls, der den Trap verursacht hat, zugewiesen. Wurde ein Befehl zum Speichern von Daten unterbrochen, wird in rYY der zu speichernde Wert abgelegt.

! rZZ = Z-Operand (bei TRAP): Bekommt beim Auftreten eines Traps den Z-Operanden des Be-fehls, der den Trap verursacht hat, zugewiesen. Bei Befehlen zum Speichern von Daten wird in rZZ die virtuelle Speicheradresse abgelegt.

44 Der Trap-Handler kann die Unterbrechungsursache mittles rQ 1 rK feststellen

E-1

E Weitere MMIX-Befehle In diesem Anhang sind die restlichen MMIX-Befehle beschrieben.

E.1 System-Befehle

Befehl Operanden

$Y+$Z + TCBefehl &&

$Y+Z + TCBefehl � $X=1

CSWAP

$X,$Y,Z

M8[$Y+Z]==rP � M8[$Y+Z]=$X $X=1

M8[$Y+Z]!=rP �

M8[$Y+$Z]!=rP � rP=M8[$Y+$Z]

$X,$Y,$Z

M8[$Y+$Z]==rP � M8[$Y+$Z]=$X $X=1

$X,$Y,Z

$Y+Z + TC �

$Y+Z + TCDaten � $X=2

&& $Y+Z + TCDaten � $X=3

LDVTS

Load virtual translation status: Befehl für Betriebssysteme. $Y und $Z bzw. Z werden als Schlüssel verwendet. Ist der Schlüssel im Translation Cache TC (im Translation Cache stehen die Adresszuordnungen der zuletzt verwendeten Seiten) enthalten, werden die letzten 3 Bits von $Y+$Z bzw. $Y+Z auf die letzten 3 Bits des alten TC-Eintrags gesetzt. Werden die letzten 3 Bits hierbei auf 0 gesetzt, wird der TC-Eintrag entfernt. Befand sich der Schlüssel in der TC-Tabelle für Befehle, wird $X auf 1 gesetzt. Befand sich der Schlüssel in der TC-Tabelle für Daten, wird $X auf 2 gesetzt. Befand sich der Schlüssel in beiden Tabellen, so wird $X auf 3 gesetzt. Befand sich der Schlüssel nicht in der Tabelle, so wird $X auf 0 gesetzt.

&& $Y+$Z + TCDaten � $X=3

$Y+Z + TCBefehl &&

(TC|$Y+Z)&=0xF...F000 (TC|$Y+Z)|=(($Y+Z)&0x07)

(($Y+Z)&0x07)==0 � (TC|$Y+Z) wird entfernt

$X,$Y,$Z

$Y+$Z + TC � (TC|$Y+$Z)&=0xF...F000

(TC|$Y+$Z) wird entfernt

$Y+$Z + TCDaten � $X=2 $Y+$Z + TCBefehl � $X=1

(TC|$Y+$Z)|=(($Y+$Z)&0x07)

(($Y+$Z)&0x07)==0 �

$Y+Z 4 TC � $X=0

$X=0

$Y+$Z 4 TC � $X=0

rP=M8[$Y+Z] $X=0


Compare and swap; vergleicht den Inhalt der Speicherzelle M8[$Y+$Z] mit dem Register rP. Bei Gleichheit wird $X in die Speicherzelle geschrieben und anschliessend auf 1 gesetzt. Bei Ungleichheit wird rP der Wert der Speicherzelle zugewiesen und $X auf 0 gesetzt.

E-2

SYNC Dient der Synchronisation paralleler Prozesse

XYZ>7 � Auslösen des Interrupts "ungültiger Befehl"

XYZ

tuellen SpeichersXYZ==7 � Befehls- und Datencache löschen

XYZ==4 � Prozessor geht in Stromspar- Modus

Schreibpuffer leeren und Daten-XYZ==5 �

Cache in den Speicher schreib- ben

schlossen

XYZ==6 �

Alle Load- oder Store-Anweisun- gen vor SYNC werden vor allen Load- oder Store-Anweisungen nach SYNC abgeschlossen

XYZ==2 � Alle Load-Anweisungen nach SYNC werden nach den Load- Anweisungen vor SYNC abge-

XYZ==0 � Pipeline leerenXYZ==1 � Alle Store-Anweisungen nach

Löschen der TC-Tabelle des vir-

SYNC werden nach den Store- Anweisungen vor SYNC abgeschlossen

XYZ==3 �

E-3

geschrieben und aus dem Cache gelöscht

Keine Auswirkung

Schreib-Puffer oder Write-Back Cache vorhanden � M[$Y+$Z],...,M[$Y+$Z+X] wird in den Speicher zurück-

Cache gelöschtSYNCD

Synchronisiert Daten im Bereich $Y+$Z bis X+$Y+$Z bzw. $Y+Z bis X+$Y+Z

Schreib-Puffer oder Write-Back Cache vorhanden � M[$Y+Z],...,M[$Y+Z+X] wird in den Speicher zurück-

Ausführungsadresse � 0x80...0 Kein Schreib-Puffer oder Write- back Datencache �

X,$Y,Z

Ausführungsadresse < 0x80...0 Kein Schreib-Puffer oder Write- back Datencache � Keine Auswirkung Schreib-Puffer oder Write-Back Cache vorhanden � M[$Y+Z],...,M[$Y+Z+X] wird in den Speicher zurück- geschrieben

Ausführungsadresse � 0x80...0 Kein Schreib-Puffer oder Write- back Datencache � Keine Auswirkung

Cache vorhanden � M[$Y+$Z],...,M[$Y+$Z+X] wird in den Speicher zurück- geschrieben

Kein Schreib-Puffer oder Write- back Datencache � Keine Auswirkung Schreib-Puffer oder Write-Back

Ausführungsadresse < 0x80...0

X,$Y,$Z

geschrieben und aus dem

E-4

Vom Datencache separater Be-

Befehlscache � Keine Auswirkung

Ausführungsadresse < 0x80...0 Kein vom Datencache separater

fehlscache vorhanden � Die Speicherzellen M[$Y+$Z],...,M[$Y+$Z+X] werden im Befehlscache aktu- alisiertAusführungsadresse � 0x80...0 Kein vom Datencache separater Befehlscache � Keine Auswirkung Vom Datencache separater Be- fehlscache vorhanden � Die Speicherzellen M[$Y+$Z],...,M[$Y+$Z+X] werden aus allen Caches ge- löscht, der zugehörige Arbeits- speicher wird hierbei nicht aktu-

alisiertAusführungsadresse < 0x80...0 Kein vom Datencache separater Befehlscache � Keine Auswirkung Vom Datencache separater Be- fehlscache vorhanden � Die Speicherzellen M[$Y+$Z],...,M[$Y+$Z+X] werden im Befehlscache aktu- alisiertAusführungsadresse � 0x80...0

SYNCID

X,$Y,$Z

fehlscache vorhanden � Die Speicherzellen M[$Y+Z],...,M[$Y+Z+X] werden aus allen Caches ge-

Kein vom Datencache separater Befehlscache � Keine Auswirkung Vom Datencache separater Be-

Synchronisiert Daten, die als Befehle interpretiert werden im Bereich $Y+$Z bis

$Y+$Z+X bzw. $Y+Z bis $Y+Z+X

X,$Y,Z

löscht, der zugehörige Arbeits- speicher wird hierbei nicht aktu-

alisiert

E-5

X,$Y,$Z

X,$Y,Z

X,$Y,$Z

X,$Y,Z

X,$Y,$Z

X,$Y,Z

PREGO

Informiert das System darüber, dass der Speicherinhalt von $Y+$Z bis X+$Y+$Z bzw. $Y+Z bis X+$Y+Z wahrscheinlich ausgeführt wird

PREST

Informiert das System darüber, dass der Speicherinhalt von $Y+$Z bis X+$Y+$Z bzw. $Y+Z bis X+$Y+Z auf jeden Fall neu geschrieben wird, bevor er das nächste Mal gelesen wird

PRELD

Informiert das System darüber, dass der Speicherinhalt von $Y+$Z bis X+$Y+$Z bzw. $Y+Z bis X+$Y+Z wahrscheinlich in Kürze geladen oder gespeichert wird

E.2 Byteweise Operationen

Befehl Operanden

$X,$Y,$Z$X,$Y,Z$X,$Y,$Z$X,$Y,Z$X,$Y,$Z$X,$Y,Z$X,$Y,$Z$X,$Y,Z $X=max(0,$Y-Z)

BDIFByte difference: Byteweise saturierte Differenz von der Register Y und Z


byteweise x=max(0,y-z)

ODIFOcta difference: Saturierte Differenz der Register Y und Z

WDIFWyde difference: Wydeweise saturierte Differenz von der Register Y und Z

$X=max(0,$Y-$Z)

TDIFTetra difference: Tetraweise saturierte Differenz von der Register Y und Z

wydeweise x=max(0,y-z)

tetraweise x=max(0,y-z)

F-1

F Aufbau der MMIX-Objektdatei

G-1

G Parameterübergabe auf dem Registerstack Motivation

! Zugriffe auf den Stack sind stets langsame Speicherzugriffe und nicht schnelle Registerzugriffe � zeitaufwendig

! wird bei Funktionen die Parameterübergabe auf dem Stack durchgeführt, muss die verwendete

Funktion stets die von ihr verwendeten Register selbst dann auf den Stack sichern, wenn sie vom Funktionsaufrufer gar nicht verwendet wurden!

! � nicht nur langsame, sondern auch noch unnötige Speicherzugriffe, die das Programm aus-

bremsen (Speicherzugriffe sind sehr zeitaufwendig) Ideen zur Verbesserung

! Vorteile der „Parameterübergabe in Registern“ mit den Vorteilen der „Parameterübergabe auf dem Stack“ kombinieren

! Register als Stack adressieren (also relativ zu einer Art Register-Stackpointer) und nicht absolut

+ zuvor: Bezeichner $0, $1, … gaben direkt das adressierte physikalische Register an + neue Idee: Bezeichner $0, $1, … sind nur als Offset zu einem Register-Stackpointer zu

sehen � Register werden relativ zum Register-Stackpointer adressiert + � durch Änderung des Register-Stackpointers können Register einfach umbenannt wer-

den, d.h. ein Register-Zugriff mittels des Bezeichners $0 aus dem Hauptprogramm kann physikalisch ein anderes Register ansprechen als ein Zugriff mittels des Bezeichners $0 aus einer Funktion heraus

! Parameterübergabe auf dem Register-Stack � Umbenennen von Registern beim Sprung in ei-

ne Funktion erspart das Sichern der von der Funktion verwendeten Register, da diese einfach ausgeblendet werden, von der Funktion also auch nicht überschrieben werden können

vom Funktions-aufrufer verwen-

dete Register

1. Parameter2. Parameter

von der Funktionverwendete

Register

$0

$1

$2

$3

$4

$5

$6

$7

$8

$9

$0

$1

$2

$3

$4

Bezeichner vordem Funktions-aufruf

Bezeichner nachdem Funktionsaufruf

Abb. 200: Umbenennen von Registern

! sind bspw. aufgrund vieler verschachtelter Funktionsaufrufe keine Register mehr übrig, können die ausgeblendeten Register auf den Arbeitsspeicher gesichert werden, um so wieder freie Re-gister zu bekommen

! da Zugriffe auf den Stack in der Regel immer in der Nähe des Stackpointers auftreten, ist es

unwahrscheinlich, dass auf gerade auf den Arbeitsspeicher ausgelagerte Daten sofort wieder zugegriffen wird, das Auslagern auf den Arbeitsspeicher also umsonst war

G-2

Realisierung beim MMIX mit Hilfe des Register-Rings

! der Register-Ring besteht aus verborgenen (s.u.), lokalen und marginalen Registern (vgl. Kap. 2.4.2)45

! ein Register kann hierbei als einzelnes Segment eines aus <rG> Segmenten zusammenge-

setzten Rings betrachtet werden46

xx

xx

marginale, also nochunbenutzte Register

lokale Register, also Register, dievom Unterprogramm bereits ver-wendet wurden

5=<rL>=7

6

$0$1

$248

...

xx

$2

$3

$4$5$6

$7$8

$9

$10

. . .

7verborgene Register, alsoRegister, die auf den Register-Stack verdrängt wurden, jedochnoch nicht auf den Arbeits-speicher ausgelagert wurden$

247

gibt die Stelle an,an der die lokalenRegister beginnen

Segmente (einzelne Register),aus denen sich der Register-Ring zusammensetztgibt die Stelle an,

an der die lokalenRegister beginnen

gibt die Stelle an, ander die verborgenenRegister beginnen

...

...

0x600..0 Stack-Segmentdes Arbeits-speichersrS-1

rS

lokale RegisterRegister

rO-1rO

6

7

marginaleRegister

5

verborgeneRegister

0x5FF..F

Pool-Segmentdes Arbeits-speichers

Abb. 201: Register-Ring

! verborgene Register

+ sind diejenigen Register, die bei einem Funktionsaufruf „auf den Register-Stack geschoben“ wurden

+ sind für die Funktion nicht mehr sichtbar, können also von der Funktion nicht überschrieben werden (� bei einem Funktionsaufruf ist keine Sicherung der verwendeten Register erfor-derlich)

+ können auf den Arbeitsspeicher ausgelagert werden, wenn die Anzahl der marginalen Re-gister für den Aufruf einer weiteren Funktion nicht ausreicht

! lokale Register

+ sind wie bisher die Register $0 bis $(<rL>-1) + der Registerbezeichner ($0, $1 etc.) alleine läßt noch keinen Schluss auf die Position des

Registers im Register-Ring zu

! marginale Register + sind wie bisher die noch unbenutzten Register + wurden durch einen Funktionsaufruf Register verborgen, so verschiebt sich die Grenze für

das grösste marginale Register nach unten • Beispiel: 2 Register wurden verborgen, 3 Register sind lokal, 4 Register sind global

! die Anzahl der marginalen Register beträgt 256 – 2 – 3 – 4 = 247 ! aufgrund der Umbenennung der Register ist das höchste marginale Register jetzt

nicht mehr Register $251, sondern Register $249

45 Globale Register und Spezialregister können als separate Hardware angesehen werden und werden deshalb hier nicht be-trachtet. Die verborgenen Register sind, je nachdem, ob sie bereits auf den Arbeitsspeicher ausgelagert sind oder nicht, entwe-der Bestandteil des Register-Rings oder des Stacksegments des Arbeitsspeichers. 46 Im Spezialregister rG steht die Nummer des ersten globalen Registers � die Anzahl der Summe der verborgenen (aber noch nicht auf den Arbeitsspeicher ausgelagerten), der lokalen und der marginalen Register entspricht dem Inhalt des Spezialregis-ters rG. Beispiel: <rG> = 253 � es gibt 256 – 253 = 3 globale Register ($253, $254 und $255) und 256 – 3 = 253 (also <rG>) lokale und marginale Register.

G-3

! Funktionsaufruf mit dem Registerstack des MMIX-Prozessors

+ Befehle zum Sprung in die Funktion: PUSHJ $X,YZ bzw. PUSHGO $X,$Y,$Z|Z (vgl.

Kap. 2.8.10)47

+ Rücksprung aus der Funktion mit dem MMIX-Befehl POP X,YZ (vgl. Kap. 2.8.10)

! findet bei einem Funktionsaufruf die Parameterübergabe auf dem Stack statt, werden die fol-genden Spezialregister wie folgt verwendet (vgl. Anhang D)

+ rJ = return-jump register: enthält nach dem Funktionsaufruf die Rücksprungadresse

+ rO = register stack offset: legt fest, an welcher Speicheradresse im Stack-Segment im Falle

einer Verdrängung das erste sichbare lokale Register abgespeichert wird

+ rS = register stack pointer: legt fest, an welcher Speicheradresse im Stack-Segment im Fal-le einer Verdrängung das erste verborgene Register abgespeichert wird

Beispielprogramm

LOC #2000000000000000 GREG @ Dummy-Aufruf LOC #2000000000000100 GREG @ Dummy-Aufruf LOC #2000000000000200 GREG @ Dummy-Aufruf LOC #100 fkt2 SET $0,0 SET $1,1 SET $2,2 SET $3,3 SET $4,4 POP 3,0 Rücksprung, 3 Rückgabewerte // Wert aus $2 (2) ist der Haupt- // rückgabewert und kommt dann in // dem Register unterhalb von $0 // abgelegt fkt GET $2,rJ Adresse von rJ nach $2 sichern ADD $3,$0,$1 Addieren der beiden Parameter PUSHJ $4,fkt2 PUT rJ,$2 Adresse restaurieren SET $0,$3 POP 1,0 Main SET $0,0 SET $1,1 // Register $2 freilassen, da dort // dann die Anzahl der auf den Stack // gelegten Register steht SET $3,3 1. Parameter SET $4,4 2. Parameter PUSHJ $2,fkt Funktionsaufruf // 2 Parameter ($3 und $4) // Anzahl der auf den Stack gesicherten // Register ($0 und $1 => 2 Stück) wird // direkt nach $0 und $1 auf den // Register-Stack geschrieben TRAP 0,Halt,0

47 PUSHJ und PUSHGO unterscheiden sich lediglich darin, dass die Zieladresse bei PUSHJ ähnlich wie beim JMP-Befehl rela-tiv angegeben wird, bei PUSHGO ähnlich wie beim GO-Befehl absolut (vgl. Kap. 2.8.10).

G-4

! Ablauf des obigen Beispiels

+ Annahmen über den Initialisierungszustand • es wurden 4 globale Register verwendet " <rG> = 252

+ das Hauptprogramm hat die Register $0 und $1 für eigene Berechnungen verwendet und

sie mit den Werten 0 und 1 belegt

SET $0,0 SET $1,1

$2

$0 = 0

marginaleRegister

lokaleRegister

5=<rL>=2

6

$3$4$251

..

.

$1 = 1

$5

$6

$7

7

$8$9

$10

$11

$12

$13

. . .

Abb. 202: Ausgangszustand vor dem Funktionsaufruf

+ als nächstes werden die Parameter für die Funktion fkt in Registern abgelegt

• die vom Hauptprogramm verwendeten Register $0 und $1 werden beim späteren Auf-ruf des PUSHJ- bzw. des PUSHGO-Befehls auf den Registerstack abgelegt (vgl. Kap. 2.8.10)

• im Anschluss daran wird die Anzahl der auf den Registerstack abgelegten Register e-benfalls auf den Registerstack abgelegt (vgl. Kap. 2.8.10) � zwischen den vom Haupt-programm verwendeten Registern ($0 und $1) und den Parameter-Registern muss ein Register unbenutzt bleiben � Register $2 nicht verwenden

• die Parameter für die Funktion fkt in Register $3 und $4 ablegen

SET $3,3 SET $4,4

$2

$0 = 0

marginaleRegister

lokaleRegister

5=<rL>=5

6

$3 = 3$4

= 4

$251

..

.

$1 = 1

$5

$6

$7

7

$8$9

$10

$11

$12

$13

. . .

Abb. 203: Ablegen der Parameter für die Funktion fkt in Registern

G-5

+ Aufruf der Funktion fkt

• die Register $0 und $1 werden auf dem Register-Stack abgelegt • der Wert 2 (Anzahl der auf den Registerstack abgelegten Register) wird ebenfalls auf

dem Register-Stack abgelegt • die Register $3, $4, … werden umbenannt in Register $0, $1, … • die Rücksprungadresse wird im Spezialregister rJ abgelegt • da jetzt 3 Register verborgen sind, ist das höchste marginale Register das Register $248 und nicht mehr $251

PUSHJ $2,fkt

2

0

marginaleRegister

lokaleRegister

5=<rL>=2

6

$0 = 3$1

= 4$248

..

.

1

$2

$3

$4$5$6

$7$8

$9

$10

. . .7

verborgeneRegister

Abb. 204: Register-Ring nach dem Funktionsaufruf

+ Sicherung der Rücksprungadresse

• die Rücksprungadresse, also der „Weg zurück ins Hauptprogramm“, steht jetzt im Spe-zialregister rJ

• da die Funktion fkt die Funktion fkt2 aufruft und bei diesem Aufruf in das Register rJ die Rücksprungadresse der Funktion fkt2, also der „Weg zurück zu fkt“ abgelegt wird, muss das Register rJ vor dem Aufruf von fkt2 in ein lokales Register gesichert werden, damit aus fkt heraus später wieder zurück ins Hauptprogramm gesprungen werden kann

• da durch die Sicherung von rJ ein neues lokales Register belegt wird, erhöht sich der Inhalt des Spezialregisters rL, in dem die Anzah der benutzten lokalen Register abge-legt ist

GET $2,rJ

2

0

marginaleRegister

lokaleRegister

5=<rL>=3

6

$0 = 3$1

= 4

$248

...

1

$2= 324$3

$4$5$6

$7$8

$9

$10

. . .

7

verborgeneRegister

Abb. 205: Sicherung der Rücksprungadresse in Register $2

G-6

+ die Funktion verwendet für Berechnungen zusätzlich weitere Register

• es werden die beiden vom Hauptprogramm übergebenen Parameter, die sich jetzt nach der Umbenennung in Register $0 und $1 befinden, addiert und das Ergebnis in Regis-ter $3 abgelegt

ADD $3,$0,$1

2

0

marginaleRegister

lokaleRegister

5=<rL>=4

6

$0 = 3$1

= 4

$248

..

.

1

$2= 324$3

=7$4$5$6

$7$8

$9

$10

. . .7

verborgeneRegister

Abb. 206: Registerring nach der Addition der Parameter

+ die Funktion fkt ruft die Funktion fkt2 auf

• die Register $0, $1, $2 und $3 kommen auf den Register-Stack • der Wert 4 (Anzahl der auf den Register-Stack abgelegten Register) wird ebenfalls auf

den Register-Stack geschrieben (und zwar in das soeben noch lokale Register $4) • die Register $5, $6, … werden umbenannt in Register $0, $1, … • es werden keine Parameter übergeben � nach dem Funktionsaufruf hat das Spezialre-

gister rL den Wert 0

PUSHJ $4,fkt2

2

0

marginaleRegister

5=<rL>=0

6

3

4

$243

...

1

324

74$0$1

$2$3

$4

$5

. . .7

verborgeneRegister

Abb. 207: Register-Ring nach dem Aufruf der Funktion fkt2

G-7

+ die Funktion fkt2 verwendet lokale Register

SET $0,0 SET $1,1 SET $2,2 SET $3,3 SET $4,4

2

0

marginaleRegister

lokaleRegister

5=<rL>=5

6

3

4

$243

...

1

324

74

$0=0

$1=1

$2=2

$3=3

$4=4

$5

. . .

7verborgene

Register

Abb. 208: Die Funktion fkt2 verwendet lokale Register

+ Rücksprung aus der Funktion fkt2

• die Funktion fkt2 soll drei Werte zurückgeben • die Rückgabewerte müssen stets in dem unteren Teil der lokalen Register stehen • � die Rückgabewerte stehen hier in den Registern $0, $1 und $2 • der Rückgabewert mit dem höchsten lokalen Register (hier: der Wert 2 aus $2) ist im-

mer der Hauptrückgabewert • der Hauptrückgabewert wird beim Rücksprung in dasjenige Register geschrieben, das

direkt unterhalb des ersten Rückgabewertes liegt, also in dasjenige Register, in das zu-vor die Anzahl der auf den Registerstack geschobenen Register abgelegt wurde

POP 3,0

2

0

marginaleRegister

lokaleRegister

5=<rL>=7

6

$0 = 3$1

= 4

$248

..

.

1

$2= 324$3

=7

$4=2

$5=0

$6=1

$7$8

$9

$10

. . .

7

verborgeneRegister

Abb. 209: Register-Ring nach dem Rücksprung aus fkt2

G-8

+ Rücksprungadresse restaurieren und Rückgabewert in Register $0 ablegen

• vor dem Rücksprung aus der Funktion fkt muss zuerst die Rücksprungadresse, die zuvor in Register $2 gesichert wurde, in das Register rJ übertragen werden

• da Rückgabewerte immer in den unteren lokalen Registern zurückgegeben werden, muss bei der Rückgabe nur eines Wertes dieser vor dem Rücksprung in Register $0 abgelegt werden

PUT rJ,$2 SET $0,$3

2

0

marginaleRegister

lokaleRegister

5=<rL>=7

6

$0 = 7$1

= 4

$248

..

.

1

$2= 324$3

=7

$4=2

$5=0

$6=1

$7$8

$9

$10

. . .

7

verborgeneRegister

Abb. 210: Ablegen des Rückgabewerts in Register $0

+ Rücksprung aus der Funktion fkt

• es wird ein Rückgabewert zurückgegeben • der Rückgabewert steht vor dem Rücksprung in Register $0 • beim Rücksprung werden die Register wieder umbenannt, so dass der Rückgabewert

dann im obersten lokalen Register steht

POP 1,0

$2 = 2

$0 = 0

marginaleRegister

lokaleRegister

5=<rL>=4

$3 = 7$4

$251

...

$1 = 1

$5

$6

$7$8$9

$10

$11

$12

$13

. . .

67

Abb. 211: Rücksprung in das Hauptprogramm

H-1

H Ein- und Ausgabe von Daten

H.1 Allgemein

! Hardware vom Betriebssytem verwaltet ! Ein- und Ausgabe von Daten " Ansprechen von Hardware ! � für Ein- und Ausgabe von Daten sind Betriebssystem-Aufrufe nötig ! Betriebssystem-Aufruf " Trap " von der Software ausgelöster Interrupt ! Trip: von der Hardware ausgelöster Interrupt

H.2 Betriebssystem-Aufrufe beim MMIX

! Auslösen von Traps mit dem Befehl TRAP X,Y,Z (vgl. Kap. 2.8.11) + X: hat immer den Wert 0 + Y: 8 Bit Konstante, die die gewünschte Funktion spezifiziert + Z: Parameter, der dem Betriebssystem übergeben wird; ist bei der Ein- und Ausgabe von

Daten stets der Kanal, über den die Daten transportiert werden sollen

! Angabe weiterer Parameter bzw. Daten + zuerst werden die Parameter/Daten im Datenspeicher des MMIX abgelegt + anschliessend wird in Register $255 die Speicheradresse der Parameter/Daten abgelegt + beim Aufruf des TRAP-Befehls werden die durch das Register $255 adressierten Daten

dann dem Betriebssystem übergeben

H.3 Ein- und Ausgabe-Kanäle

C:\>mmix>

StdIn: Kanal 0

StdOut: Kanal 1

StdErr: Kanal 2

Kanal 15

Betriebssystemaufrufeüber Kanäle HardwareMMIX-Programm

Kanal 255

TRAP 0,Fgets,StdIn

TRAP 0,Fputs,StdOut

TRAP 0,Fputs,StdErr

TRAP 0,Fopen,16TRAP 0,Fread,16TRAP 0,Fclose,16

TRAP...

TRAP...

Kanal 16

TRAP 0,Fopen,15TRAP 0,Fputs,15TRAP 0,Fclose,15

Abb. 212: Ein- und Ausgabe-Kanäle beim MMIX

H-2

Ausgabe von Zeichenketten auf dem Bildschirm

! zunächst muss die auszugebende Zeichenkette im Speicher des MMIX abgelegt werden ! anschliessend wird in Register $255 die Adresse der Null-terminierten Zeichenkette abgelegt ! der Aufruf von TRAP 0,Fputs,StdOut schreibt die Zeichenkette auf die Standardausgabe

(in der Regel der Bildschirm), die auch auf andere Geräte umgeleitet sein kann ! der Aufruf von TRAP 0,Fputs,StdErr schreibt die Zeichenkette auf die Standardfehler-

ausgabe (den Bildschirm); der Kanal StdErr kann nicht umgeleitet werden

! Beispiel

LOC Data_Segment GREG @ 1H BYTE "hello world",0 LOC #100 Main LDA $255,1B TRAP 0,Fputs,StdOut TRAP 0,Halt,0

Einlesen von Zeichenketten von der Tastatur

! zunächst muss Puffer bereitgestellt werden (im Beispiel [s.u.] ab Adresse 4H) (vgl. Zeile 7) ! anschliessend muss die Parameter-Zeichenkette generiert werden, die aus der Adresse des

Eingabepuffers und der Anzahl der Byte besteht, die maximal eingelesen werden dürfen (Puf-fergrösse beachten); die Parameter-Zeichenkette steht in nachfolgendem Beispiel an der Ad-resse 1H (vgl. Zeile 3 und 4)

! in Register $255 muss die Adresse der Parameter-Zeichenkette eingelesen werden (hier: 1H) (vgl. Zeile 12)

! nach dem Aufruf von TRAP 0,Fgets,StdIn (vgl. Zeile 13) kann man eine Zeichenkette an der Konsole eingeben

! beim Drücken der Eingabetaste (return) wird die Eingabe in den Eingabepuffer geschrieben

LOC Data_Segment 01 GREG @ 02 1H OCTA 4F Adresse 4H 03 OCTA 100 100 Byte Zeichenpuffer 04 2H BYTE "Eingabe: ",0 05 3H BYTE "Die Eingabe war: " 06 4H BYTE 07 // 08 LOC #100 09 Main LDA $255,2B 10 TRAP 0,Fputs,StdOut Ausgabe von "Eingabe: " 11 LDA $255,1B 12 TRAP 0,Fgets,StdIn Einlesen der Eingabe 13 LDA $255,3B 14 TRAP 0,Fputs,StdOut Ausgabe von "Die 15 // Eingabe war: " und 16 // der Eingabe 17 TRAP 0,Halt,0 18

H-3

Ein- und Ausgabe mit Dateien

! Funktionen, die als Parameter Y des TRAP-Befehls angegeben werden können

+ Fopen: Öffnet eine Datei • als Parameter Z muss beim TRAP-Befehl eine Kanalnummer angegeben werden, die

dann für die weitere Verwendung der Datei (schreiben, schliessen etc.) anzugeben ist • in Register $255 muss die Adresse des Arguments angegeben werden • Argument besteht aus

! Octa mit der Adresse, an der der Null-terminierte Dateiname abgelegt ist ! Octa mit dem Zugriffsmodus als Konstante

+ TextRead: Öffnet der Datei als Textdatei zum Lesen + TextWrite: Öffnet die Datei als Textdatei zum Schreiben + BinaryRead: Öffnet die Datei zum binären Lesen + BinaryWrite: Öffnet die Datei zum binären Schreiben + BinaryReadWrite: Öffnet die Datei zum Lesen und Schreiben, wobei mittels

Fseek (s.u.) der Dateizeiger bewegt werden kann • Rückgabewert in Register $255

! Ok � 0 ! Fehler � –1

+ Fputs: Schreibt eine Null-terminierte Zeichenkette in eine Datei • als Parameter Z muss die Kanalnummer angegeben werden • in Register $255 muss die Adresse der zu schreibenden Zeichenkette stehen • Rückgabewert in Register $255

! Ok � Anzahl der geschriebenen Zeichen ! Fehler � –1

+ Fclose: Schließt eine Datei • die Datei, die geschlossen werden soll, ergibt sich aus der Angabe der Kanalnummer

(Parameter Z) • Rückgabewert in Register $255

! Ok � Anzahl der geschriebenen Zeichen ! Fehler � –1

• Beispiel

LOC Data_Segment GREG @ 1H BYTE "textdatei.txt",0 arg OCTA 1B,TextWrite 2H BYTE "Hallo Textdatei!" LOC #100 Main LDA $255,arg TRAP 0,Fopen,16 Kanal kann willkürlich // gewählt werden (Kanal // 0,1 und 2 ist jedoch // mit StdIn,StdOut und // StdErr vorbelegt LDA $255,2B TRAP 0,Fputs,16 TRAP 0,Fclose,16 TRAP 0,Halt,0

+ Fgets: Liest eine Zeichenkette aus einer Datei

H-4

• als Parameter Z muss die Kanalnummer angegeben werden • in Register $255 muss die Adresse des Arguments stehen • Argument besteht aus

! Octa mit der Speicheradresse des Einlesepuffers ! Octa, dass die Anzahl der einzulesenden Bytes angibt

• Rückgabewert in Register $255 ! Ok � Anzahl der gelesenen Zeichen ! Fehler � –1

+ Fread: Liest mehrere Byte aus einer Datei • als Parameter Z muss die Kanalnummer angegeben werden • in Register $255 muss die Adresse des Arguments angegeben werden • Argument besteht aus

! Octa mit der Adresse des Einlesepuffers ! Octa mit der Anzahl der zu lesenden Bytes

• Rückgabewert in Register $255 ! Ok " alle Zeichen gelesen � 0 ! nicht alle Zeichen gelesen � negierter Betrag der Anzahl der Zeichen, die fälschli-

cherweise nicht gelesen wurden (negative Zahl im 2er-Komplement)

+ Fwrite: Schreibt mehrere Byte in eine Datei • als Parameter Z muss die Kanalnummer angegeben werden • in Register $255 muss die Adresse des Arguments angegeben werden • Argument besteht aus

! Octa mit der Adresse der Bytefolge, die geschrieben werden soll ! Octa mit der Anzahl der Bytes, die geschrieben werden sollen

• Rückgabewert in Register $255 ! Ok " alle Zeichen geschrieben � 0 ! nicht alle Zeichen geschrieben � negierter Betrag der Anzahl der Zeichen, die

fälschlicherweise nicht geschrieben wurden (negative Zahl im 2er-Komplement)

+ Fgetws: Liest Unicode-Zeichen (16 Bit) aus einer Datei • Verwendung wie Fgets

+ Fputws: Schreibt Unicode-Zeichen (16 Bit) in eine Datei • Verwendung wie Fputs

+ Ftell: Liefert den Dateizeiger einer geöffneten Datei • als Parameter Z muss die Kanalnummer angegeben werden • in Register $255 kann ein Offset angegeben werden • Rückgabewert in Register $255

! Ok � gibt die Anzahl der Bytes vom Dateianfang bis zur aktuellen Position an ! Fehler � –1

+ Fseek: Positioniert den Dateizeiger in einer geöffneten Datei

• als Parameter Z muss die Kanalnummer angegeben werden • in Register $255 kann ein Offset angegeben werden

! Offset > 0 � positioniert des Dateizeigers auf die Position „Offset Byte ab Dateian-fang”

! Offset < 0 � positioniert den Dateizeiger auf die Position „Offset + 1 Byte vor das Dateiende“

! Offset = 0 � positioniert den Dateizeiger auf den Dateianfang

Documents

Prof. Dr.-Ing. K. Diepold - mzwebserver.ldv.ei.tum.de CS1 Skript.pdf · und Aufbau untersuchen. Nachdem wir uns bis zu den auf der Hauptplatine befindlichen Komponen-ten vorgearbeitet