Sie sind auf Seite 1von 250

TECHNISCHE UNIVERSITT MNCHEN

Fakultt fr Elektrotechnik und Informationstechnik Lehrstuhl fr Datenverarbeitung


Prof. Dr.-Ing. K. Diepold

Computertechnik und Computersysteme SS 2006

Sprung-Vorhersage, ~Kap. 8.2 BH-Phase Kap. 4.2.1, 4.2.2

ZusatzLogik fr komplexe Befehle

AF-Phase Gleitkomma Rechenwerk/ALU Kap. 4.4.4 AF-Phase Integer Rechenwerk/ALU Kap. 4.2.5, 4.2.6, 4.4.4 Bus Kap. 1.1.2 MikroprogrammLogik, ~ Kap. 4.4.5

BD-Phase Kap. 4.2.3, 4.2.4,

Takt

TLB

Logik fr BusSchnittstelle Kap. 5

TLB

Befehls-Cache Kap. 6.3

Daten-Cache Kap. 6.3

Inhalt
1 Motivation: Wie funktioniert ein Computer? ..............................1-1

1.1 Komponenten eines Computers ............................................................................................... 1-1 1.1.1 Peripherie-Gerte und Netzteil....................................................................................... 1-3 Netzteil ................................................................................................................................. 1-3 Grafikkarte ........................................................................................................................... 1-6 DVD-ROM......................................................................................................................... 1-15 DVD-Brenner ..................................................................................................................... 1-23 Festplatte ............................................................................................................................ 1-24 1.1.2 Komponenten auf der Hauptplatine - berblick ........................................................... 1-32 Prozessor ............................................................................................................................ 1-34 Arbeitsspeicher................................................................................................................... 1-39 Busse .................................................................................................................................. 1-46 GMCH = Graphics and Memory Controller Hub (B) ........................................................ 1-55 ICH5 = Input/Output Controller Hub (5. Generation) (C) ................................................. 1-55 SIO-Controller = Super Input/Output Controller (D)......................................................... 1-55 1.2 Von Neumann-Architektur ....................................................................................................... 1-56 1.3 Harvard-Architektur.................................................................................................................. 1-60 1.4 Vom Algorithmus zum Prozessor Abstraktionsebenen .................................................... 1-61

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 fr den Prozessor .................................................................................... 2-2 Befehlssatz ........................................................................................................................... 2-2 Register ................................................................................................................................ 2-3 Arbeitsspeicher..................................................................................................................... 2-4 2.2.2 Anweisungen fr den Assembler ................................................................................... 2-6 2.2.3 Anweisungen fr den Loader ......................................................................................... 2-6 2.3 Klassifizierung von Befehlsstzen ........................................................................................... 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 Mchtigkeit der einzelnen Befehle........................................ 2-11 CISC-Architektur ............................................................................................................... 2-11 RISC-Architektur ............................................................................................................... 2-11 VLIW-Architektur.............................................................................................................. 2-13 2.3.4 Klassifizierung nach Orthogonalitt.............................................................................. 2-14 2.4 Performance auf Assembler- bzw. Befehlsatz-Ebene........................................................... 2-14 2.4.1 Begriff "Performance"................................................................................................... 2-14 2.4.2 Entstehung der Programmausfhrungs-Zeit ................................................................ 2-14 2.4.3 Performance-Messung ................................................................................................. 2-15 2.4.4 Gesetz von Amdahl ...................................................................................................... 2-17

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 Fr 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 Verknpfungen............................................................................................... 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 Sprnge 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 Parameterbergabe in Registern......................................................................................... 3-30 Parameterbergabe auf dem Stack ..................................................................................... 3-32 3.7.2 Erzeugung von Namensrumen .................................................................................. 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 3.8 Performance.............................................................................................................................. 3-46

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 nchsten Befehls .................................................................................... 4-12 4.2.3 Dekodieren des Befehls ............................................................................................... 4-13 4.2.4 Bereitstellen der Operanden ........................................................................................ 4-14 4.2.5 Ausfhren 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

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

5.1 Logikgatter .................................................................................................................................. 5-1 5.1.1 UND-Verknpfung (AND) ............................................................................................... 5-1 5.1.2 ODER-Verknpfung (OR)............................................................................................... 5-1 5.1.3 NICHT-Verknpfung (NOT)............................................................................................ 5-1 5.1.4 NICHT-UND-Verknpfung (NAND) ................................................................................ 5-1 5.1.5 NICHT-ODER-Verknpfung (NOR)................................................................................ 5-2 5.1.6 Exklusiv-ODER-Verknpfung/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 5.2.3 Kritischer Pfad ................................................................................................................ 5-8 5.2.4 Verkrzung des kritischen Pfads durch Verwendung zustzlicher Hardware ............. 5-10

5.3 Aufbau der Kombinatorischen Funktionseinheiten.............................................................. 5-13 5.3.1 Kombinatorische Schaltungen ..................................................................................... 5-13 5.3.2 Rechenwerk: Logik-Einheiten ...................................................................................... 5-13 NICHT-Einheit (NOT unit)................................................................................................ 5-13 ODER-Einheit (OR unit).................................................................................................... 5-13 UND-Einheit (AND unit) ................................................................................................... 5-14 5.3.3 Rechenwerk: Addierer und Subtrahierer...................................................................... 5-14 1-Bit Halbaddierer.............................................................................................................. 5-14 1-Bit Volladdierer .............................................................................................................. 5-15 64-Bit Ripple-Carry Addierer ............................................................................................ 5-18 64-Bit Carry-Look-Ahead (CLA) Addierer ....................................................................... 5-19 Einstufiger Carry-Look-Ahead Addierer............................................................................ 5-19 Zweistufiger Carry-Look-Ahead Addierer ......................................................................... 5-23 Dreistufiger Carry-Look-Ahead Addierer.......................................................................... 5-24 5.3.4 Status-Einheit ............................................................................................................... 5-25 5.3.5 Multiplexer .................................................................................................................... 5-25 5.3.6 Demultiplexer/Decoder................................................................................................. 5-27 5.4 Aufbau der Sequentiellen Funktionseinheiten ...................................................................... 5-27 5.4.1 Was bedeutet sequentiell?......................................................................................... 5-27 5.4.2 Speicher ....................................................................................................................... 5-27 5.4.3 Register ........................................................................................................................ 5-27 5.4.4 Additions- und Subtraktions-Werk................................................................................ 5-27 5.4.5 Verwendung des Subtraktionswerks fr Vergleichsoperationen ................................. 5-28

Performance-Erhhung 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 Ausfhrungszeit .............................................................................. 6-4 6.2.3 Pipeline-Stufen-Fll-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 Verdrngungsalgorithmen ............................................................................................ 6-18 LRU (least recently used)................................................................................................... 6-18 Zyklische Verdrngung ...................................................................................................... 6-18 Zufllige Verdrngung ....................................................................................................... 6-18 6.3.6 Verfahren zur Verringerung der Transfer-Zeit.............................................................. 6-19 6.3.7 Prefetching ................................................................................................................... 6-19 6.3.8 Abhngigkeit der Miss-Rate von der Rahmengrsse .................................................. 6-20 6.3.9 Abschtzung des Performance-Gewinns..................................................................... 6-21

1 Motivation: Wie funktioniert ein Computer?


In diesem Kapitel geben wir Ihnen eine kleine Einfhrung in den Vorlesungsstoff der Computertechnik. Dieses Kapitel ist jedoch mehr als nur eine Einfhrung. Es dient als berblick ber den Aufbau und die Funktionsweise gngiger Arbeitsplatzrechner. Whrend 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 nherzubringen. Wenn Sie verstanden haben, welche Aufgabe Prozessoren in diesem Umfeld haben, dann kennen Sie automatisch auch das Funktionsvermgen von Prozessoren, wissen also, was so ein Prozessor eigentlich knnen muss. Dies ist die Voraussetzung fr die restlichen Kapitel dieses Skripts, in denen wir uns einen eigenen Prozessor zusammenbauen werden.

1.1 Komponenten eines Computers In diesem Kapitel ffnen wir einen gewhnlichen 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 Komponenten vorgearbeitet haben, werden wir durch eine Abstraktion (Verstecken von Details) die prinzipielle Funktionsweise des PCs zu erlutern. Nach dieser Abstraktion werden wird wieder detailreicher, wenn wir das reale (nicht abstrahierte) Zusammenspiel der einzelnen Komponenten betrachten.

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

Abb. 1: Computer-Arbeitsplatz

1-1

Wir schrauben die Seitenverkleidung ab

Abb. 2: ffnen eines Computers

und identifizieren die dann erscheinenden Komponenten.

DR NT

DB

DL

GK FW

FP

Abb. 3: Gerte in einem Computer

1-2

1.1.1

Peripherie-Gerte und Netzteil

Netzteil Das mit NT gekennzeichnete Gert 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 fr das Mainboard (die grosse grne Platine) und die darauf befindlichen bzw. damit verbundenen elektrischen Bauteile. +12 V fr die Motoren der Laufwerke und Lfter. -5 V und -12 V, die heutzutage meist gar nicht mehr verwendet werden, sondern zumeist nur noch aus Grnden der Kompatibilitt zu lteren Gerten vorhanden sind (z.B. -5 V und -12 V fr den ISA-Bus, der in der heutigen Zeit fast nur noch in der Industrie zur Maschinensteuerung (z.B. CNC-Frmaschine) verwendet wird oder -5 V zur 5 V-Versorgung lterer FloppyController, die zur Verstrkung des Lesesignals noch Operationsverstrker ohne Ladungspumpe einsetzen).

Insbesondere der hohe Stromverbrauch des Hauptprozessors und der Grafikkarte erfordern die Bereitstellung hoher Strme. 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-3

Ausgangsspannung Strom (max.) Leistung (max.) max. Gesamtleistung

+3,3 V 26 A 220 W

+5 V 42 A

+5 VSB 2,5 A 12,5 W 450 W

+12 V 18 A 216 W

Abb. 5: Typische Ausgangsleistung eines ATX-Netzteils

Aufgrund dieser hohen Strme erfolgt die Spannungsreduktion von 230 V auf die gewnschten Ausgangsspannungen nicht durch einen gewhnlichen Transformator, sondern durch den Einsatz eines Schaltnetzteils. In PCs eingesetzte Schaltnetzteile haben oft folgenden Aufbau:
Gleichrichter

230 V ~
~

LeistungsSchalter

HF-Trafo

Gleichrichter

TiefpassFilter

3
Potentialtrennung

4
Regler
=

5V=

7
Abb. 6: Prinzip-Aufbau eines Schaltreglers

Eine mgliche Zuordnung der Komponenten ist in nachfolgender Abbildung angegeben.

4 3 2 6 1 7 3 2 5

Abb. 7: Identifizierung von Schaltregler-Komponenten

1-4

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 Primrseite eines HF-Trafos (3) zugefhrt. Der Leistungsschalter sorgt durch permanentes Ein- und Ausschalten dafr, dass die am HF-Trafo angelegte Spannung mit einer Frequenz von ca. 20 200 kHz ein- und ausgeschaltet wird. Der HF-Trafo (3) bertrgt die an der Primrseite angelegte Spannung auf seine Sekundrseite. Der Gleichrichter (4) erzeugt aus der sekundrseitigen Wechselspannung wieder einen rein positiven Spannungsverlauf, der durch das Tiefpassfilter (5) auf einen Mittelwert gebracht wird. Dieser Mittelwert entspricht der aktuellen Ausgangsspannung. Die Ausgangsspannung dient als Eingang fr den Regler (6), der zur Aufgabe hat, die Ausgangsspannung auf einem bestimmten Niveau zu halten. Dies erreicht der Regler durch nderung des An-/Aus-Verhltnisses des Signals, das den Leistungsschalter steuert. Die Ausgangsspannung des Schaltnetzteils ist dabei lediglich abhngig vom Tastverhltnis (Verhltnis 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 mssen in Schaltreglern auch Trafos eingesetzt werden, diese knnen jedoch wesentlich kleiner gebaut werden, da sie durch die Verwendung einer hohen Frequenz (20 200 kHz statt 50 Hz Netzfrequenz) wesentlich mehr Leistung (proportional zur Frequenz) bertragen knnen und die Windungsanzahl somit gering bleiben kann. Wenige Windungen auf der Sekundrseite geringer Innenwiderstand der Sekundrseite in der Sekundrseite wird wenig Leistung in Wrme umgewandelt guter Wirkungsgrad. Nachfolgend angegebene Steckerbelegung eines ATX-Netzteils zeigt, dass aufgrund der hohen Strombelastung bei +3,3 V und +5 V diese Spannungen ber mehrere Kontakte parallel bertragen werden.
+3,3 V -12 V GND PS_ON GND GND GND -5 V +5 V +5 V
11 12 13 14 15 16 17 18 19 20 1 2 3 4 5 6 7 8 9 10

+3,3 V +3,3 V GND +5 V GND +5 V GND PW_OK +5 VSB +12 V

Abb. 8: Steckerbelegung eines (ATX-) Netzteils

Die Signale PS_ON und PW_OK haben folgende Funktion: PS_ON ist die Abkrzung fr Power supply on. Dieses Signal ist ein Eingangs-Signal und dient dazu, das Netzteil einzuschalten. Die Leitung PS_ON muss dabei auf Masse (GND fr engl. Ground) gelegt werden. PW_OK ist die Abkrzung fr 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 Spannung nach dem Einschalten stabilisiert hat. PW_OK ist auf der Hauptplatine mit dem Taktgeber des Prozessors verbunden und sorgt ber die Reset-Leitung dafr, dass der Prozessor erst dann mit der Abarbeitung von Befehlen beginnt, wenn sich die Versorgungsspannung stabilisiert hat. Auf diese Weise wird verhindert, dass der Prozessor in einen undefinierten Zustand gert.

1-5

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

Stecker fr zustzliche Stromversorgung Anschluss fr den Monitor (DVI) Speicherchips mit Khlkrper

BIOS Anschluss fr den Monitor (VGA)

GPU mit Khlkrper (GPU = Graphics Processing Unit) AGP-Anschluss (Verbindung zum Prozessor)
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 knnen BIOS (Basic Input Output System), um die Grafikkarte auch schon vor dem Laden von Grafikkartentreibern verwenden zu knnen (s.u.) AGP-Anschluss (oder auch PCI-Express) zur Kommunikation mit dem PC-Prozessor VGA- bzw. DVI-Anschluss zur Kommunikation mit dem Monitor

1-6

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 Prozessor liefert, in Signale, die der Bildschirm zur Anzeige bentigt.

Die Grafikkarte verfgt 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 Bildschirm-Signale.
1

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

Video-Speicher in der Grafikkarte


0x3F

Bildschirm

pro Grundfarbe 1 Byte 24 Bit Farbtiefe

0x00 0x78 0xFF 0xE8

R B R

G R G B R

B G B G

R B R B

G R G R

B G B G

1 Pixel

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

Durch ndern einzelner Byte im Grafik-Speicher kann der Prozessor die Intensitt jedes rot (R)-, grn (G)- oder blau (B)-Anteils eines Pixels ndern. Soll ein Pixel beispielsweise Rot erscheinen, werden den zugehrigen drei Byte im Grafik-Speicher die Werte R = 0xFF, G = 0x00, B = 0x00 zugeordnet. Grn entspricht dann R = 0x00, G = 0xFF, B = 0x00 und ein dunkles Grau etwa R = 0x60, G = 0x60, B = 0x60. Zum Verstndnis der Umwandlung der im Grafik-Speicher der Grafikkarte abgelegten Byte in ein Bildschirm-Signal ist es sinnvoll zu wissen, wie diese Bildschirmsignale berhaupt aussehen.

Bildschirm-Signale, die aus dem DVI-Anschluss kommen, sind digital und knnen 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 Rhrenmonitor verarbeiten lassen. Aus diesem Grund schauen wir uns erst einmal kurz an, wie ein Rhrenmonitor funktioniert (auch wenn diese gerade von TFT-Bildschirmen vom Markt gedrngt werden).

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, grn und blau zusammengemischt.

1-7

Ein (Farb-)Rhrenmonitor enthlt drei Kathoden, die jeweils einen Elektronenstrahl aussenden. Jeder Elektronenstrahl (und somit jede Kathode) ist dabei fr eine der drei Grundfarben (RGB) zustndig. Die drei Elektronenstrahlen knnen in der Rhre 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 Bildrhre 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 knnen, sind innen auf der Bildschirmvorderseite abwechselnd phosphorhaltige Stoffe aufgebracht, die bei Elektronenbeschuss entweder Rot, Grn oder Blau leuchten. Damit die Elektronenstrahlen immer nur die drei zu einem bestimmten Pixel gehrigen Punkte treffen und nicht auch noch benachbarte, ist zwischen den Kathoden und der fluoreszierenden Schicht noch eine Lochblende eingebaut.

Kathoden 3 Elektronenstrahlen Lochblende


R B R B G R G R B G B G R B R B G R G R B G B G R R

Fluoreszierende Schicht Spulen zur Ablenkung der Elektronenstrahlen

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

1-8

Fhrt man die drei Elektronenstrahlen wie in nachfolgender Abbildung angegeben ber den Bildschirm, werden alle rot, grn und blau fluoreszierenden Punkte von den zugehrigen Elektronenstrahlen getroffen.

Abb. 13: Weg der drei Elektronenstrahlen ber den Monitor

An den Ablenkspulen zur horizontalen Ablenkung muss also eine periodisch ansteigende Spannung (Sgezahn) 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 Bildrhre an, wenn alle Zeilen von links nach rechts durchlaufen wurden. 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 Strahlungsintensitt der zugehrigen Kathoden und damit die Intensitt jeder Pixel-Grundfarbe steuern.

R G B Hsync Vsync 1. Zeile 2. Zeile 1. Bild letzte Zeile 1. Zeile 2. Bild t

Abb. 14: Signale am VGA-Anschluss

1-9

Zur Umwandlung der im Grafik-Speicher abgelegten Daten in die analogen Signale R, G und B verwenden Grafikkarten sog. RAMDACs. Diese RAMDACs wenden auf die im Grafik-Speicher (GrafikRAM; 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 analogen 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 (fr Rot) RAMDAC (fr Grn) RAMDAC (fr Blau)


c:\>

Prozessor

Video-Speicher auf der Grafikkarte

Die Darstellung von Bildern auf dem Bildschirm funktioniert wie folgt: Der Prozessor schreibt die Farbwerte fr 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, mssen jedoch erst berechnet werden, was im Vergleich zu den von der Grafikkarte auszufhrenden 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 Lnge gezeichnet werden, wie z.B. die nachfolgend abgebildete Linie.

Um im Grafik-Speicher fr jedes Pixel die Intensitt der drei Grundfarben Rot, Grn und Blau ablegen zu knnen, muss der PC-Prozessor zunchst berechnen, welche Pixel beim Zeichnen der Linie mit welcher Farbe eingefrbt werden mssen.

Abb. 15: Datenverlauf vom Prozessor zum Bildschirm

Digital-Analog-Wandler (RAMDAC) VGABuchse Bildschirm


Abb. 16: Linie

1-10

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 Pixeln zu liegen kommt.
2

Farbpunkte auf dem Bildschirm zu zeichnende Linie

einzelne Pixel

Abb. 17: Ausschnitt der Linie

Fr alle Pixel, die von der Linie berhrt werden, muss der Prozessor jetzt berechnen, zu welchem Teil die Pixel von der Linie bedeckt werden. Bedeckt die Linie den Pixel vollstndig, wird er schwarz eingefrbt, d.h. im Grafik-Speicher werden an der entsprechenden Speicherstelle fr Rot, Grn und Blau jeweils die Werte 0 eingetragen. Bedeckt die Linie die Pixel nur zu 40 Prozent, so trgt die Farbe der Linie (hier schwarz) auch nur zu 40 Prozent zur Farbe des Pixels bei. Die restlichen 60 Prozent der Farbe des Pixels entsprechen der ursprnglichen Farbe des Pixels (bei uns also der Farbe weiss). Mit RGBschwarz = (0, 0, 0) und RGBweiss = (255, 255, 255) ergibt sich damit fr 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 Computergrafik als rendern bezeichnet. Das Vorgehen, von der Linie berhrte 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, grne und blaue Punkte erzeugt werden.

1-11

Die fr die Render-Vorgnge bentigten Berechnungen werden von optimierten Assembler-Routinen durchgefhrt, die im Betriebssystem verankert sind. Diese Routinen knnen 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-Vorgnge bereits als optimierter Assembler-Code geschrieben sind, dauert deren Ausfhrung (im Vergleich zur Darstellung der im Video-Speicher abgelegten Daten auf dem Bildschirm) relativ lange. Wrden die langsamen Render-Vorgnge direkt auf dem Grafik-Speicher ausgefhrt werden, dann wrden Objekte bereits dann auf dem Bildschirm erscheinen, wenn sie noch gar nicht fertig berechnet sind, was vom Betrachter insbesondere bei bewegten Objekten als sehr strend empfunden wrde (flickern). Aus diesem Grund wird beim Rendern nicht direkt in den Grafik-Speicher, sondern in einen sog. BackBuffer 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 jedoch nicht kopiert, sondern es wird den RAMDAC-Bausteinen einfach mitgeteilt, dass sich der GrafikSpeicher jetzt an einer anderern Adresse befindet. Der ehemalige Grafik-Speicher wird dann automatisch zum Back-Buffer.

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

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

RAMDAC (fr Rot)

RAMDAC (fr Grn) RAMDAC (fr Blau)

c:\>

Prozessor

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

Front- und Back-Buffer

Digital-Analog-Wandler (RAMDAC)
Abb. 19: Front- und Back-Buffer

VGABuchse

Bildschirm

1-12

Zu Beginn dieses Abschnitts hatten wir erwhnt, dass die Grafikkarte nicht nur als Schnittstelle zwischen 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 Oberflchen durch Polygone (z.B. Dreiecke) modelliert (vgl. nachfolgende Abbildung).

Abb. 20: Modellierung von Objekten durch Polygone (Daten fr die Grafikkarte)

Diese Modellierung wird vom PC-Prozessor durchgefhrt. Wenn sich beispielsweise in einem PCSpiel Personen bewegen, berechnet der PC-Prozessor permanent die Positionierung der verschiedenen Polygone. Die Polygone haben natrlich ganz bestimmte Oberflcheneigenschaften wie Farbe, Struktur etc. Diese Oberflcheneigenschaften bergibt der Prozessor zusammen mit den 3DKoordinaten der berechneten Polygonpunkte der Grafikkarte, die die aktuelle Szene dann in ein normales Bild umwandelt (vgl. nachfolgende Abbildung).

Abb. 21: Von der Grafikkarte erzeugtes Bild

Die Grafikkarte initialisiert dabei jedes Polygon mit der zugehrigen Oberflche (Struktur und Grundfarbe). Anschliessend berechnet die Grafikkarte fr jede Polygon-Position die gerade aktuellen Lichtverhltnisse der Umgebung und ndert das Erscheinungsbild der Polygone dementsprechend. Ausserdem 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 Polygone, d.h. sie erzeugt aus den Polygonen die Farbwerte der einzelnen Pixel, die sie dann in den Back-Buffer bertrgt. Zur Darstellung des Bilds auf dem Bildschirm mssen dann nur noch Front- und Back-Buffer umgeschaltet werden.

1-13

Die Berechnungen zur Oberflchenstrukturierung, Beleuchtung und Verdeckung sind sehr aufwendig. Ohne Grafikbeschleunigung mssten diese Berechnungen alle vom PC-Prozessor ausgefhrt werden. Mit Grafikbeschleunigung kann die Arbeit des PC-Prozessors auf die Berechnung der PolygonPositionen beschrnkt bleiben, da die Grafikkarte den Rest erledigt. Da die Grafikkarte auf diese Art von Berechnungen spezialisiert ist, kann sie diese wesentlich schneller ausfhren als der PCProzessor. Darber hinaus arbeitet die Grafikkarte parallel zum Prozessor, so dass die Grafikkarte beispielsweise ein Bild rendern kann, whrend der PC-Prozessor gerade die Polygon-Positionen des nchsten Bildes berechnet.

1-14

DVD-ROM Das in Abb. 3 auf Seite 1-2 mit DR gekennzeichnete Gert ist das DVD-ROM-Laufwerk.

DVD-ROM-Laufwerke dienen zum Lesen von DVDs und CDs. Diese Laufwerke knnen also keine Daten aufzeichnen (ROM = Read Only Memory nur lesen), sondern sie lediglich lesen. Um den Aufbau eines DVD-ROM-Laufwerks leichter verstehen zu knnen, schauen wir uns erst einmal an, wie Daten auf einer DVD gespeichert werden. Wie in nachfolgender Abbildung gezeigt, besteht eine DVD aus Spuren, die spiralfrmig von innen nach aussen verlaufen.

Abb. 22: Spuren auf einer DVD

1-15

Die Spuren bestehen dabei aus einer Folge verschieden langer Erhhungen, 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 geschtzt, die andere Seite dient der Beschriftung der DVD.

Von der Seite betrachtet, ergibt sich fr Pits und Land somit folgendes Bild:
Beschriftung der DVD/Etikett Drehrichtung Trger (Land) Land Pit Leseseite der DVD
Abb. 24: Aufbau einer DVD-ROM

reflektierende ALU-Schicht Polycarbonat

1-16

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

Halbdurchlssiger Spiegel Photo-Detektor Laser Auswertung der Signale Umwandlung in einzelne Byte

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

Angenommen, die DVD bewegt sich in der angegebenen Drehrichtung. Was fr ein Licht-Signal kommt dann beim Photo-Detektor an? Auf den ersten Blick scheint sich beim Photo-Detektor keine nderung des Licht-Signals zu ergeben, da sowohl die Pits als auch das Land das Laser-Licht reflektieren. Wenn die Hhe der Pits auf dem Land jedoch ein Viertel der Wellenlnge des Lasers betrgt, 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 grsserer Amplitude ergibt. Die Wellen berlagern sich also konstruktiv, man spricht von konstruktiver Interferenz. gegenphasigen Wellen beide Wellen genau auslschen. Die Wellen berlagen sich also destruktiv, man spricht von destruktiver Interferenz. 1-17

Betrachtet man die Pits und das Land auf der DVD von der Leseseite her, fllt folgendes auf:
destruktive Interferenz konstruktive Interferenz

Ansicht von unten (Leseseite) destruktive Interferenz

Laser
Abb. 27: Auftreffen des Lasers auf der DVD

Trifft der Laser auf reines Land, wird er einfach reflektiert. Trifft der Laser jedoch auf ein Pit, so trifft er neben dem Pit auch noch auf Land, da der Radius des Laserstrahls grsser ist als die Breite eines Pits. Das reflektierte Laser-Licht enthlt also sowohl Licht, das vom Land reflektiert wurde, als auch Licht, das vom Pit reflektiert wurde.

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

Ansicht von der Seite (Querschnitt)

von der Leseseite reflektiertes Laserlicht

konstruktive Interferenz (es wird viel Licht reflektiert)

destruktive Interferenz (es wird fast kein Licht reflektiert, da sich die Wellen gegenseitig auslschen)

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

Der Photo-Detektor bekommt dabei bei rotierender DVD eine Folge von Licht an/Licht aus mit, die er als Rechteck-Spannung an einen im DVD-Laufwerk eingebauten Chip weiterleitet.

Spannung

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

Dieser Chip tastet die Rechteckspannung ab und wandelt die darin gespeicherte Information in Bits um. Die Bits sind jedoch nicht direkt als Pits und Land codiert. Das hat folgende Grnde: Sich rasch ndernde Bitfolgen wie z.B. 10101 knnen vom Laser nicht mehr aufgelst werden. Bei sich sehr langsam ndernden Bitfolgen wie z.B. 00000000000000000000000111111 111111 geht die Synchronisation verloren, d.h. es kann nicht genau gezhlt werden ob jetzt bspw. 23 oder 24 Nullen in der Bitfolge vorkamen. Das liegt daran, dass die Umdrehungsgeschwindigkeit der DVD whrend des Lesens schwanken kann und Zeitmessungen dadurch nur fr relativ kurze Zeiten in die von der aktuellen DVD-Spur zurckgelegte Strecke (und damit die Anzahl der Bits) umgerechnet werden kann.

Aus diesen Grnden hat man bei der Standardisierung der DVD folgendes festgelegt: es mssen 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 sptestens zehn Pit-Stellen oder zehn Land-Stellen muss ein Wechsel stattfinden. Zwischen zwei Einsen knnen also zwei bis zehn Nullen auftreten. Dies fhrt zur sog. Eight-to3 Fourteen-Modulation (EFM), in der ein Byte (8 Bits) durch 14 sog. Channel-Bits kodiert wird. Damit auch beim Aneinanderfgen von Channel-Codewrtern die obige Forderung nicht verletzt wird, werden zwischen zwei Channel-Codewrtern noch drei sog. Merge-Bits eingefgt. Zur Codierung eines Bytes sind somit 14 + 3 = 17 Bits notwendig. Diese Bits werden zusammen mit weiteren Bits zur Fehlerkorrektur und Adressierung als Pits und Lands auf die DVD gepresst. Aus Grnden 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 gelschten 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

Von den mit 14 Bit darstellbaren 214 Bitkombinationen entsprechen lediglich 267 Kombinationen den oben genannten Forderungen. Von diesen 267 gltigen Folgen wurden 256 ausgewhlt, um ein Byte (8 Bit, also 28 = 256 verschiedene Werte) zu codieren.

1-19

Zur Erhhung der Speicherkapazitt knnen auf jeder DVD-Seite Daten auf zwei Ebenen, den sog. Layern abgespeichert werden. Der dem Laser nhere Layer ist dabei halbtransparent ausgefhrt, so dass der Laser von diesem zwar reflektiert wird, der untere Layer aber auch noch erreicht werden kann. Die Auswahl der Layer erfolgt durch Einstellung des Brennpunkts des Lasers (Bewegung der Linse) entweder auf den einen oder den anderen Layer.

reflektierender Layer halbtransparenter Layer

verschiebbare Linsen
Abb. 31: Doppel-Layer DVD

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

Linse DVD Antriebsmotor

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

Im echten DVD-Laufwerk sieht das folgendermaen aus:

Abb. 33: DVD-Laufwerk

1-20

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

Auflagepunkt fr die DVD (Antrieb)

Motor zum horizontalen Verschieben der Linse

Linse

Abb. 34: Innenleben eines DVD-ROM-Laufwerks

Die horizontale Positionierung der Linse erfolgt folgendermaen: Zunchst wird die ungefhre Position der Linse durch Parameter wie Spurbreite, mittlere PitLnge 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 Adressinformation.

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

Vergrssert man den Bildausschnitt noch weiter, kann man auch gut die Elektromagnete/Spulen erkennen, 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-22

DVD-Brenner Das in Abb. 3 auf Seite 1-2 mit DB gekennzeichnete Gert 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 frbt und das Licht dann nicht mehr so gut reflektiert. Auf diese Weise wird die gegenphasige Auslschung der DVD-ROM nachgeahmt.
Beschriftung der DVD/Etikett Drehrichtung Schutzschicht reflektierende Schicht

Land Pit Leseseite nicht reflektierende schwarze Punkte

Polycarbonat

Abb. 37: Beschreibbare DVD (DVD-R)

Bei beschreibbaren DVDs muss das Laufwerk die Adresse der zu beschreibenden Stellen finden knnen. Nachfolgende Grafik zeigt das Verfahren, das bei der DVD+RW angewendet wird: Die Pits werden in eine Art Spurrille, den sog. Grooves geschrieben. Die Seiten der Grooves sind jedoch nicht gerade, sondern durch eine Modulation von Sinus-Signalen geprgt. Diesen wellenfrmigen Seiten kann das DVD-Laufwerk die Information ber die aktuelle Position auf der DVD entnehmen und damit Daten adressieren.
Grooves (Vertiefungen) Land

Pits
Abb. 38: Adressierung von beschreibbaren DVDs

Im Gegensatz zu einmal beschreibbaren DVDs (DVD-R) mssen mehrfach beschreibbare DVDs auch gelscht werden knnen. Dies wird durch eine spezielle Metall-Legierung als Reflexionsschicht erreicht: In Abhngigkeit der Strke des Lasers, der die DVD beschreibt, wird das Material entweder amorph (ungeordnete Anordnung der Molekle, schlecht reflektierend) oder kristallin (regelmige Anordnung der Molekle, gut reflektierend).

1-23

Festplatte Das in Abb. 3 auf Seite 1-2 mit FP gekennzeichnete Gert ist die Festplatte.

Abb. 39: Festplatte

Die Festplatte ist ein magnetisches Speichermedium, das sehr grosse Datenmengen aufnehmen kann. Aufgrund des technischen Fortschritts knnen ca. alle 12 Monate Festplatten mit doppelter Kapazitt hergestellt werden. Im Inneren bestehen Festplatten in der Regel aus ein bis vier drehbar gelagerten festen Platten (deswegen 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 Oberflche (z.B. Eisenoxyd, Kobalt etc.) beschichtet, auf der noch eine Schutzschicht aus Graphit aufgebracht wird.
Armpositionierung (Elektromagnet) Permanentmagnet

Schreib-/Lese-Kopf

schwenkbarer Arm

magnetisierbare Speicherplatte

Anschluss fr die Elektronik

Abb. 40: Aufau einer Festplatte

1-24

Das Abspeichern von Daten auf die Festplatte erfolgt durch die sog. Schreib-/Lesekpfe, die (wie bei einer Audio-Cassette) Teile der Plattenoberflche magnetisieren (vgl. nachfolgende Abbildung).

Spule Magnetfeldlinien

Schreib-/Lesekopf magnetisierbare Schicht

N N

S S

N N

S S

N N

Bewegungsrichtung der Platte Stromverlauf beim Schreiben

Trgermaterial aus Glaskeramik t


Abb. 41: Datenspeicherung auf der Festplatte durch Magnetisierung

Nachfolgende Abbildung zeigt den Vorgang der Magnetisierung der Festplatte.

+
Spule

Magnetfeldlinien

geordnete Elementarmagnete

ungeordnete Elementarmagnete

Magnetisierung (quivalent-Magnet)
Abb. 42: Magnetisierung

keine Magnetisierung

1-25

Die Schreib-/Lesekpfe haben die Gestalt eines auf einer Seite aufgesgten 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 zunchst im Luftspalt des Schreib-/Lesekopfes (die aufgesgte Stelle) ein Magnetfeld. Wird der Spalt in die Nhe der magnetisierbaren Platte gebracht, schlieen sich die Feldlinien nicht mehr ber die Luft, sondern ber das magnetisierbare Material, da sich Feldlinien leichter ber magnetische Leiter als ber mag4 netische Nichtleiter schlieen. Durch die magnetische Kraft der Feldlinien werden die im Plattenmaterial befindlichen Elementarmagnete dabei so geordnet, dass sie ihre Nord-Sd-Ausrichtung alle in dieselbe Richtung haben. Die Feldlinien der Elementarmagnete heben sich dann also nicht mehr gegenseitig auf (wie auf der rechten 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 erhalten bleiben.

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

Strommessung (siehe Stromverlauf) Spule Magnetfeldlinien

+ OpAmp -

Schreib-/Lesekopf magnetisierbare Schicht

N N

S S

N N

S S

N N

Bewegungsrichtung der Platte Stromverlauf beim Lesen t1 t2


Abb. 43: Auslesen von der Festplatte

Trgermaterial aus Glaskeramik t

Detektiert werden dabei lediglich die Grenzen unterschiedlicher Magnetisierung, die sich in kurzen Stromstchen (einige A) ussern (vgl. Abb. 43). Diese Unterschiede im Stromverlauf werden mit geeigneten elektrischen Schaltungen verstrkt, detektiert und dann ausgewertet. Die abgespeicherte Information steckt dabei in den unterschiedlichen Lngen zwischen den Stromsten. In Abb. 43 ist erkennbar, dass die Zeit t1 wesentlich krzer ist als die Zeit t2. Diese Zeitunterschiede werden von dem auf der Festplatte integrierten Controllerchip (Festplatten-Controller) registriert, ausgewertet und in einzelne Byte dekodiert. Diese Byte stellen dann die auf der Festplatte abgespeicherte Information dar. Um die Oberflche der Festplatte nicht zu beschdigen, sind die Schreib-/Lesekpfe auf einem sog. Schlitten montiert, der im Betrieb durch den von den Platten verursachten Luftzug nach oben gedrckt wird. Die Schreib-/Lesekpfe 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 Kpfe ber den Platten schweben zu lassen. Deshalb wird der schwenkbare Arm, auf dem die Kpfe montiert sind, in eine Park-Position gezogen.
4 Das ist wie beim elektrischen Strom, der auch lieber durch einen Leiter als durch einen Nichtleiter fliet: berbrckt man einen Widerstand (Nichtleiter) mit einem Draht (Leiter), dann fliet der ganze Strom durch den Draht und nicht durch den Widerstand.

1-26

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

Um auf der Festplatte gespeicherte Informationen zu finden, mssen 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 verfgen ber mehrere tausend Zylinder, also mehrere tausend Spuren pro Plattenoberflche, wobei die Platten auch beidseitig beschrieben werden. Da die Spuren mehrere Mega-

1-27

byte (MB) gross sein knnen, 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 knnen. Ca. 60 dieser Byte werden fr Verwaltungsinformation verwendet. Werte zur Synchronisation fr den Taktgenerator, der die Zeit zwischen zwei Stromstssen (vgl. Abb. 43) nur messen kann, wenn er die genaue Umdrehungsgeschwindigkeit der Platte kennt. Prfsummen Speicherung der Nummer des aktuellen Zylinders Speicherung der Nummer des aktuellen Sektors Speicherung der Nummer des aktuellen Schreib-/Lesekopfs Start- und Ende-Marken fr den Datenbereich mehrere Leer-Byte als Toleranzzone fr 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 Gegensatz zur logischen Formatierung, bei der Betriebssystem-spezifische Daten zur Verwaltung von Dateien auf die Platten geschrieben werden (z.B. ein Inhaltsverzeichnis).

Um Daten aus einem bestimmten Sektor einer bestimmten Spur einer bestimmten Platte auslesen zu knnen, werden die Schreib-/Lesekpfe ber dem gewnschten 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 gewnschte Sektor-Nummer detektiert, macht sich dann lesebereit und liest beim Auftreten der nchsten Start-Marke solange Werte ein, bis er eine Ende-Marke detektiert. Da alle Schreib-/Lesekpfe an einem einzigen schwenkbaren Arm befestigt sind, knnen alle zu einem Zylinder gehrigen Spuren gleichzeitig gelesen werden. Die Positionierung der Schreib-/Lesekpfe ist dabei eine sehr heikle Angelegenheit. Betrachten Sie dazu die in nachfolgender Tabelle angegebenen typischen Daten einer Festplatte:

Abmessung der Schreib-/Lesekpfe Dicke des Luftkissens, auf dem die Kpfe schweben Umdrehungsgeschwindigkeit der ueren Spuren (Radius = 4 cm, 7200 U/min) Spurabstand (bei 1500 Spuren pro cm) Bit-Abstand
Abb. 46: Festplatten-Daten

0,3 mm x 0,1 mm 20 nm 110 km/h 6,7 m 0,5 m

Um uns diese Daten besser vor Augen fhren zu knnen, rechnen wir sie einmal so um, dass die Dicke des Luftkissens 1 cm betrgt, die Schreib-/Lesekpfe also 1 cm ber den Platten schweben. Zur Skalierung mssen wir dann alle Festplatten-Parameter mit 1 cm / 20 nm = 500.000 multiplizieren. Es ergeben sich dann folgende Werte:
Abmessung der Schreib-/Lesekpfe Dicke des Luftkissens, auf dem die Kpfe schweben Umdrehungsgeschwindigkeit der ueren Spuren (Radius = 4 cm, 7200 U/min) Spurabstand (bei 1500 Spuren pro cm) Bit-Abstand
Abb. 47: Skalierte Festplatten-Daten

150 m x 50 m 1 cm 55.000.000 km/h 3,35 m 25 cm

1-28

Nach dieser Skalierung wren die Schreib-/Lesekpfe gut eineinhalb mal so lang und ein halbes mal so breit wie die Mnchener Frauenkirche hoch ist und wrden mit einer Geschwindigkeit, mit der sie in 2,6 Sekunden die Erde umrunden, nur 1 cm ber dem Boden gleiten. Dabei wrden Sie Daten auslesen 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 stoen. Eine unvorstellbare Leistung! Typische Festplattenlaufwerke haben eine durchschnittliche Zugriffszeit von ca. 8 ms, das bedeutet, sie bentigen ca. 8 ms, um ein Drittel aller auf der Oberflche befindlichen Spuren zu berqueren und dann zielsicher auf der richtigen Spur zu landen. In unserem Skalierungs-Beispiel betrgt die Entfernung, die in den 8 ms von den Schreib-/Lesekpfen in Frauenkirche-Grsse zurckgelegt werden mssen, gute 5 km. Das entspricht einer Seitwrts-Geschwindigkeit von 625.000 km/h (in knappen 4 Minuten um die Erde). Wie kann so eine schwierige Aufgabe gelst werden? Modernste Regelungstechnik machts mglich! Da die Schreib-/Lesekpfe im Betrieb nicht auf den Platten aufliegen, ergibt sich bei der Bewegung der Arme so gut wie keine Reibung. Die Arme knnen also mit minimalstem Kraftaufwand bewegt werden. Sie lassen sich also auch ruckfrei anfahren und abbremsen. Der Antrieb erfolgt dabei durch magnetische Krfte: Am drehbar gelagerten Arm ist an der Hinterseite eine Spule angebracht, deren Magnetfeld sich vom Festplatten-Controller steuern lsst. Im Gehuse der Festplatte sind zwei sehr starke Permanent-Magnete montiert, zwischen denen die Spule des drehbaren Arms eingebettet ist.

Wird die Spule bestromt, stt sie sich vom Permanent-Magneten ab und bewegt dabei die SchreibLesekpfe ber die Platten.

PermanentMagnet zum Halten des Arms in der Parkposition

PermanentMagnete Spule (am Arm montiert) Drehlager zur Rotation des Arms

drehbar gelagerter Arm

Abb. 48: Mechanik zur Armpositionierung

1-29

Doch woher wei der Festplatten-Controller, wieviel Strom er durch die Spule schicken muss, um die Schreib-/Lesekpfe genau auf den gewnschten Zylinder (auf die gewnschten Spuren) zu positionieren? Die Antwort ist: Auf den Platten sind sog. Servo-Informationen gespeichert, in denen auch die Nummer des jeweiligen Zylinders gespeichert ist. Diese Servo-Informationen werden in der Regel zwischen den einzelnen Sektoren gespeichert.

Sektoren

Servo-Informationen

Abb. 49: Servo-Information

Zur Positionierung wartet der Festplatten-Controller zunchst, bis ein Schreib-/Lesekopf ber einen Servo-Bereich fhrt. 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) ermittelt der Festplatten-Controller, wie weit die Schreib-/Lesekpfe noch vom Ziel-Zylinder entfernt sind und erhht oder verringert den Spulenstrom dementsprechend. Die Platte dreht sich dabei weiter. Wenn die Schreib-/Lesekpfe das nchste mal einen Servo-Bereich berfahren, vergleicht der Festplattencontroller 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. Anschlieend findet noch eine Feinpositionierung statt, die mithilfe spezieller (ebenfalls im Servo-Bereich abgespeicherten) Fein-Positionierungs-Informationen durchgefhrt wird. Im Festplatten-Controller ist also unter anderem ein Regler implementiert, der aus den Laufwerkspa5 ramtern, der Ist- und der Soll-Position den ntigen Spulenstrom bestimmt.
aktueller Fehler

Soll-Position

Regler

Spulenstrom

Ist-Position

Laufwerk

Abb. 50: Regelkreis


5 Wie solche Regler funktionieren und wie sie ausgelegt werden mssen, um nicht nur sehr schnell, sondern auch noch stabil zu arbeiten, knnen 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-30

Um gute Zugriffszeiten der Festplatte zu erreichen, muss der Arm mglichst schnell von seiner IstPosition 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 zurckzufhren. Zur Verbesserung der Zugriffszeit der Festplatte kann die Umdrehungsgeschwindigkeit der Platte erhht werden, so dass die zeitlichen Abstnde, in denen die Servo-Informationen an die Schreib/Lesekpfe gelangen, verringert werden. Eine weitere Mglichkeit zur Beschleunigung der Kopfpositionierung besteht darin, die Servoinformationen nicht nur zu Beginn eines Sektors, sondern auch in krzeren Abstnden auf die Platten zu speichern. Eine verbreitete Vorgehensweise spendiert eine komplette Plattenoberflche allein fr die Servo-Informationen. Diese Festplatten erkennt man oft daran, dass sie ber eine ungerade Anzahl an Schreib-/Lese-Kpfen verfgen. Die Servo-Informationen werden vom Festplatten-Hersteller auf die Platte geschrieben und knnen nicht gelscht werden. Auch nicht mit der zuvor erwhnten Grundformatierung.

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

DR

NT

DB

DL GK FP FW

Abb. 51: Gerte in einem PC

Wir haben dabei gemerkt: Die betrachteten Gerte sind ziemlich intelligent. Sie knnen selber schwierige Aufgaben ausfhren (z.B. Kopf-Positionierung bei der Festplatte) und dadurch den PC-Prozessor entlasten. Die Intelligenz und hohe Leistungsfhigkeit der Gerte rhrt von den eingebauten Chips her, die z.T. sehr hnlich aufgebaut sind wie PC-Prozessoren, mit denen wir uns in dieser Vorlesung hauptschlich beschftigen werden.

1-31

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 folgendes Bild:

D5 D6 C1 D1 A D2 FS B1 C5 LA C6 B2 C7 B3 C7 C7 C4 C7 C7 C7 B

D3 D

D4 B4 B4 B4 B4

C3 HI C3 C C2 C8 C9

Abb. 52: Hauptplatine eines Computers

Die grosse grne Platine ist die Hauptplatine unseres Computers, die auch Mainboard oder Motherboard genannt wird. Auf der Hauptplatine sind alle wichtigen Komponenten des PCs untergebracht, die nicht so wie die Festplatte oder das DVD-Laufwerk als Peripherie-Gerte angesehen werden. Auf ihr befindet sich der Prozessor (A) der Hauptspeicher (B4), der Chipsatz (B, C), viele Anschlussmglichkeiten fr Steckkarten (B2, C7), fr interne Gerte (C3, D4) wie beispielsweise DVD-ROM und fr externe Gerte (z.B. D1, D2).

Da die Hauptplatine auf den ersten Blick ziemlich kompliziert aussieht, haben wir davon auf der nchsten Seite eine Schema-Darstellung angefertigt, aus der hervorgeht, wie die einzelnen Bausteine auf der Hauptplatine heien und wie sie miteinander verschaltet sind.

1-32

A Prozessor Intel P4 NT 230 V ~ Netzteil


RechenWerk SteuerWerk

Adress-Umsetzer BefehlsCache DatenCache

FSB Logik/Treiber

FS B TFTBildschirm B1 DVI B2 Grafikkarte GK AGP-Port Analoger VGAAnschluss


GrafikController AGP-

Prozessor-Bus, 4200 MHz (FSB = Front Side Bus)

Intel 82865G GMCH

DDR-RAM
DDR-RAM

B4

2,1 GByte/s Controller Controller

Kanal A 3,2 GyteB/s

DDR-RAM B4 DDR-RAM B4

Gigabit-EthernetCSAController Controller 266 MByte/s B3


HI Controller

Kanal B 3,2 GByte/s

DDR-RAM B4

1 GBit/s HI LA LANAnschluss C

HI = Hub Interface 266 MByte/s

Intel 82801EB ICH5 100 MBit/s


Ethernet- SystemController Managmnt. PCIUSB2.0Controller Controller 2 SATAController CMOSRAM

C6 Takt-Generator CPU, PCI, C7 PCI-Bus 133 MByte/s 6 PCI-Slots FW Batterie C8 FireWireAdapter

C1 FP Festplatte DVDROM DVDBrenner DR C3 C2

Anschlsse fr USB 2.0

480 MBit/s

2 Anschlsse 150 MByte/s fr Serial-ATA 2 Anschlsse fr ATA 100 Audio-Codec AC `97 3 100 MByte/s

ATA 100 Bios-interf. Controller Controller AC `97 SMBus Controller Controller LPC-interface Controller

Flash-Bios SMBus 2.0/ I2C-Bus

C9

DB

C4

LPC-Interface (Low Pin Count) D Super Input/Output Controller D4 D1 Anschluss fr seriellen Port D2 Anschluss fr parallelen Port Anschluss fr Ventilator
RS 232 Floppy Controller Controller LPT Tastatur Controller Controller DrehzahlMaus regelung Controller

DL DiskettenLaufwerk Tastatur

Anschluss Disketten-Laufwerk PS/2 Anschluss D5 Tastatur PS/2 Anschluss Maus

D3

Maus D6

Abb. 53: Schematischer Aufbau eines Computers

1-33

Die wichtigste Komponente dieser Schema-Darstellung ist der Prozessor (A). Prozessor Nachfolgende Abbildung zeigt den auf der Hauptplatine befindlichen Prozessor (A), nachdem wir den Khlkrper entfernt haben.

Abb. 54: Prozessor (Pentium 4, Vorder- und Rckseite)

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 ProzessorBefehlen bestehen. Die Prozessor-Befehle sind auerhalb 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 ausgefhrt. Die zu den Befehlen gehrigen Operanden (die sog. Daten) liegen zunchst ebenfalls auerhalb des Prozessors und mssen 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 knnen, verfgen Prozessoren ber sog. Register. Register sind sehr schnelle Speicherelemente, die genau soviele Bits aufnehmen knnen, 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 betrgt die Wortbreite 32 Bit, die Register sind also 32 Bit breit und knnen somit genau 32 Bits aufnehmen.
jeweils 1 Bit MSB LSB

2 1 0
Datenwort mit Wortbreite n
Abb. 55: Datenwort

Numerierung der Bits:

n-1

1-34

Die Bitstelle mit der geringsten Wertigkeit (ganz rechts) wird auch LSB (engl. Least Significant Bit dt. niederwertigstes Bit) genannt. Die Bitstelle mit der hchsten Wertigkeit (ganz links) wird MSB (engl. Most Significant Bit dt. hchstwertigstes Bit) genannt. Um Befehle sowohl abspeichern, als auch ber den Bus bertragen zu knnen, werden Befehle genauso wie Operanden und Adressen als Zahlen codiert. Der Befehl Addiere zwei Zahlen kann beispielsweise 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 nchstes auszufhrende Befehl wird aus einem externen Speicher ber den FSB in das BefehlsRegister transportiert. Anschliessend werden die zugehrigen Operanden (ebenfalls ber den FSB) geladen.

FSB = Front Side Bus

2
BR: BZ:

3 Steuerung

Registerblock mit Registern

Flags:

ALU

Steuerwerk

Abb. 56: Laden von Befehlen in den Prozessor

Dazu wird vom sog. Steuerwerk zuerst der im Befehlszhler BZ (ein Register im Steuerwerk) stehende Wert als Adresse auf den FSB gelegt (1). Diesen Vorgang nennt man Befehlsadressierung, da im Befehlszhler immer die Zahl steht, die der Adresse des als nchstes auszufhrenden Befehls entspricht. Auf den FSB wird also die Adresse des nchsten Befehlsworts gelegt.

Kurz danach erhlt der Prozessor ber den FSB das gewnschte Befehlswort, das er dann im Befehlsregister 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 Operanden 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 mssen.

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 Befehlsausfhrung leitet (leiten im Sinne von berwachen, verantwortlich sein), zum anderen die Befehle und Operanden zu den jeweiligen Prozessor-Komponenten hinleitet (leiten im Sinne von entlangleiten, hinfhren).

1-35

Nach dieser Analyse sorgt das Steuerwerk dafr, dass die bentigten Operanden der sog. ALU (Arithmetic Logic Unit), der Recheneinheit des Prozessors, zugefhrt 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 dafr, dass die adressierten Operanden aus dem Registerblock an die ALU geleitet werden (6).
FSB = Front Side Bus

BR: BZ:

5 4

Registerblock mit Registern 6 ALU

Steuerung

Flags:

Steuerwerk

Abb. 57: Bereitstellung von Operanden: Direktoperanden und Register-Operanden.

mssen die Operanden erst ber den FSB in den Prozessor geladen werden, + legt die Steuerung zunchst 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 zugefhrt werden knnen (10).
FSB = Front Side Bus

9
BR: BZ:

Steuerung

Registerblock mit Registern 8 10 ALU

Flags:

Steuerwerk

Abb. 58: Bereitstellen von Operanden ber den FSB

1-36

Nachdem die Steuerung alle Operanden an die ALU angelegt hat, teilt sie der ALU den auszufhrenden Befehl (z.B. Addieren, Multiplizieren etc.) mit (11) und startet dann die Befehlsausfhrung (12).
FSB = Front Side Bus

BR: BZ:

13 11 12 14

Registerblock mit Registern

Steuerung

ALU

Flags:

Steuerwerk

Abb. 59: Berechnung des Ergebnisses

Treten bei der Befehlsausfhrung in der ALU unvorhergesehene Ereignisse/Fehler auf (z.B. Division durch Null), werden diese der Steuerung gemeldet (13), die dann weitere Manahmen trifft. Hat die ALU die ihr aufgetragenen Berechnungen abgeschlossen, meldet sie bestimmte Eigenschaften des Ergebnisses (z.B. Ergebnis ist Null, Ergebnis ist negativ), indem Sie das im Steuerwerk untergebrachte Flag-Register aktualisiert (14).

Nachfolgende Abbildung zeigt ein Beispiel fr ein Flag-Register.

Overflow: berlauf bei vorzeichenbehafteten Zahlen Carry (bertrag): berlauf bei vorzeichenlosen Zahlen Zero: Ergebnis ist Null Sign (Vorzeichbit): Ergebnis ist negativ OC Z SW I X E Gleitkomma-Zahl ungenau (z.B. 1.0/3.0) Gleitkomma-Division durch Null Ungltige Gleitkomma-Operation (z.B. 1 ) berlauf bei Gleitkomma-Festkomma-Wandlung
Abb. 60: Flag-Register

1-37

Je nach ausgefhrtem Befehl muss die Steuerung jetzt das am ALU-Ausgang anliegende Ergebnis ber den FSB verschicken (15). Dazu muss die Steuerung neben dem Ergebnis auch die Zieladresse (Adresse im Arbeitsspeicher oder Peripherie-Gert) mit auf den FSB legen (16). in ein Register des Registerblocks transportieren (17). Hierbei muss die Steuerung durch Anlegen der Registeradresse an den Registerblock diesem mitteilen, in welches Register das Ergebnis abgelegt werden soll (18).

FSB = Front Side Bus

20
BR: BZ:

18 Steuerung 16 21

Registerblock mit Registern 19 ALU

Flags:

15

Steuerwerk

17

Abb. 61: Sichern des Ergebnisses

Wird das Ergebnis in einem Register abgelegt, kann es sofort wieder verwendet werden (19). Eine zeitaufwendige Datenbertragung 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 nchsten Befehl ber den FSB in den Prozessor zu laden, muss der Befehlszhler (die Adresse auf den nchsten Befehl) angepasst werden. Dazu wird zu dem aktuellen Wert des Befehlszhlers die Wortbreite eines Befehls (in Byte) addiert und der Wert des neuen Befehlszhlers dann wieder auf den FSB gelegt [(1) aus Abb. 56 (Seite 1-35)].

Wortbreite des aktuellen Befehls

Addierer

+
BZ zum FSB
Abb. 62: Anpassen des Befehlszhlers

Ab diesem Zeitpunkt wiederholen sich die in den Abb. 56 bis Abb. 61 dargestellten Schritte. Die im Speicher stehenden Befehle werden der Reihen nach ausgefhrt. 1-38

Fast genauso wichtig wie der Prozessor ist der Arbeitsspeicher, in dem sowohl die auszufhrenden Befehle, als auch die zugehrigen 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 temporre Speicherung von Daten und Befehlen. Mit temporr ist gemeint, dass zum Einen die im Arbeitsspeicher abgelegten Daten mit dem Ausschalten des PCs verloren gehen. Der Arbeitsspeicher wird deshalb auch als volatiler (= flchtiger) 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 flchtiger) 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, mssen 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, mssen sie wieder vom Arbeitsspeicher in den Prozessor geladen werden (5). Dort werden Sie weiterverarbeitet (6) und im Anschluss wieder in den Arbeitsspeicher zurckgeschrieben (7). Wrde der Rechner jetzt ausgeschaltet werden, gingen die Daten verloren. Um sie permanent zu speichern, mssen sie auf der Festplatte abgelegt werden (8).

1-39

36

Abb. 64: Datenflu im PC

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

SpeicherAdressen Adresse 1 z.B. 0x00..02 3 Steuerleitungen Lesen Schreiben 8 2 0x00..00 0x00..01 0x00..02 0x00..03 5 0x00..04 10 0x00..05 Daten 0x4B 6 0x4B 7

Speicher-Inhalt (Daten) 0x10 0x2F 0x4B 11 0xC3 0x96 0x83

4 9 0x5D 0xFF..FF Datum (1 Byte)

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 gewnschten Speicherstelle an (1). Diese sog. Adressierung hat zur Folge, dass im Speicher die Speicher-Stelle mit dem gewnschten Datum ausgewhlt wird (2). Soll das ausgewhlte Datum aus dem Speicher ausgelesen werden, muss man dies dem Speicher durch ein Signal auf der Steuerleitung Lesen mitteilen (3). Der Speicher reagiert darauf, indem er zwischen der adressierten Speicherstelle und der mit Daten gekennzeichneten Spei-

1-40

cher-Schnittstelle eine Verbindung freischaltet (4), so dass das gewnschte Datum nach aussen geleitet wird (5) und dann dort abgegriffen werden kann (6). Soll an die ausgewhlte Stelle jedoch ein neues Datum geschrieben werden, muss dieses Datum zunchst an die Daten-Schnittstelle angelegt werden (7). Durch ein Signal auf der Steuerleitung Schreiben (8) wird dann eine Verbindung zwischen der Daten-Schnittstelle und der adressierten Speicherstelle hergestellt (9), ber die das Datum dann transportiert wird (10). Das Datum wird anschliessend an der adressierten Speicherstelle abgespeichert (11).

Die Daten-Schnittstelle zum Speicher muss also bidirektional ausgelegt sein, d.h. sie dient beim Lesen als Ausgang und beim Schreiben als Eingang. Die Adress- und Steuer-Schnittstelle des Speichers ist unidirektional. Sie dient immer nur als Eingang und niemals als Ausgang. Neben der zuvor besprochenen Eigenschaft, dass der Arbeitsspeicher ein nicht flchtiger 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 welcher Speicherstelle man gerade gelesen hat, dauert der Zugriff auf eine beliebige andere Speicherstelle immer gleich lang. Man spricht deshalb auch von einem Speicher mit wahlfreiem Zugriff, was im englischen mit RAM (Random Access Memory) abgekrzt wird. Im Gegensatz dazu muss bei einer Festplatte in Abhngigkeit der Position des gerade adressierten Datums zur Adressierung eines anderen Datums der Schreib- und Lesekopf einmal mehr, einmal weniger weit verschoben werden, was natrlich Zeit kostet. Darberhinaus kann nach der Positionierung des Schreib- Lesekopfs erst dann auf den gewnschten Sektor zugegriffen werden, wenn sich dieser unter dem Schreib-Lesekopf befindet. Bei DVD-Laufwerken, bei denen die DVD mit gleicher Linear-Geschwindigkeit, also mit unterschiedli7 cher Winkel-Geschwindigkeit rotiert, muss zustzlich noch die Geschwindigkeit erhht bzw. verringert werden.

RAMs lassen sich in zwei Gruppen einteilen: SRAMs (= Statisches RAMs) und DRAMs (Dynamisches RAMs). Eine SRAM-Speicherzelle bentigt zur Abspeicherung eines Bits sechs Transistoren, von denen sich vier gegenseitig Sperren bzw. Durchschalten, wie in nachfolgender Abbildung gezeigt.
Zeilenleitung (Auswahl) Spaltenleitung invertiert Bit

UB
P1 N1 N3 N4 P2 N2

Spaltenleitung 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-41

Nachfolgende Abbildung zeigt, wie man in dieser rckgekoppelten Transistor-Schaltung ein Bit abspeichern kann. Spannungspegel auf der Hhe der Versorgungsspannung sind dabei mit +, Masse durch gekennzeichnet.
Zeilenleitung (Auswahl) Spaltenleitung invertiert

1 4 + 19 Spaltenleitung

UB
12 + - 11 P1 5 + 13 + + N1 X 7 N3 10 16 + 15 + P2 Y 6

N2 9 18 8 + N4 14 - 17

2 Bit = 1 (+)

3 Bit = 0 (-)

Abb. 67: Abspeichern eines Bits im SRAM

Im Grundzustand liegt die Zeilenleitung auf Masse (1). Da an den Gates der beiden N-KanalTransistoren N1 und N2 dann ebenfalls Masse anliegt, sperren beide. Die aus den vier Transistoren P1, P2, N3 und N4 aufgebaute Rckkopplungsschaltung ist somit von der Aussenwelt isoliert. Will man ein Bit mit dem Wert 1 in dieser Speicherzelle abspeichern, legt man zunchst den Eingang Bit auf 1, also auf den Pegel der Versorgungsspannung UB (2) und den Eingang Bit invertiert auf 0, also auf Masse (3). Whlt man anschlieend durch Anlegen der Versorgungsspannung an die Zeilenleitung (4) die SRAMZelle 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), weswegen 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 angelegt wird (19), die Transistoren N1 und N2 damit nicht mehr durchschalten und die aus P1, P2, N3 und N4 bestehende Rckkopplungsschaltung wieder von der Aussenwelt abtrennen. Durch die Rckkopplung 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. Lge Punkt X auf Masse und Punkt Y auf +UB, entsprche das dem abgespeicherten Wert 0.

1-42

Wie der im SRAM gespeicherte Wert wieder ausgelesen werden kann, zeigt die nachfolgende Abbildung.
UB/2 5 4 + N5 2 3 + 7 Precharge UB/2 5 4 + N6

6 UB/2 Zeilenleitung (Auswahl)

6 UB/2

P1 Spaltenleitung N1

P2 Y N2 N4

X N3

Bit

Spaltenleitung invertiert Bit

1 8 + 16 -

UB

10

+ +

+UB 1 11 - UB 0 12

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). Fr 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 Differenzverstrker weitergeleitet (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 Differenzverstrker mglichst 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 Kapazitt verfgen, ist auf ihnen stets eine gewisse Ladung gespeichert. Im ungnstigen Fall hat diese Ladung ein zur Ladung an den Punkten X und Y genau entgegengesetztes Vorzeichen. Diese Ladung auf den Spaltenleitungen muss beim Durchschalten der Transistoren erst berwunden werden, was einen Zeitverlust darstellt.

1-43

Liegen beide Spaltenleitungen vor dem Durchschalten von N1 und N2 jedoch auf selbem Potential, gengt bereits der Transport einer sehr geringen Ladungsmenge, um den zwischen den Punkten X und Y vorhandenen Potentialunterschied durch den Differenzverstrker detektieren zu knnen. 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 Rckkopplungsschaltung ist somit von den Spaltenleitungen getrennt.

Um die Spaltenleitungen auf gleiches Potential (in diesem Beispiel UB/2) zu legen, wird auf der Steuerleitung Precharge fr kurze Zeit die Spannung +UB angelegt (3). Da das Gate (4) der Transistoren N5 und N6 dann auf hherem Pegel liegt als die zugehrigen Source-Anschlsse (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) danach 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, fhrt 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 Differenzverstrker das Vorzeichen der Pegeldifferenz der Punkte X und Y sofort detektiert werden kann.

1-44

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

Zeilenleitung

Abb. 69: DRAM-Speicher

Der Transistor dient wie die beiden Transistoren N1 und N2 beim SRAM zur Isolierung des Speicherelements von der Aussenwelt. Das Speicherelement ist hier jedoch nicht eine rckgekoppelte 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 Leckstrmen 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 bentigt (U(t) = U0 e fe auf DRAMs im Vergleich zu Zugriffen auf SRAMs wesentlich langsamer.
-RC/t

), sind Speicherzugrif-

Da fr DRAM-Speicherzellen vier Bauteile weniger bentigt werden als fr SRAM, kann DRAM billiger hergestellt werden als SRAM. Zudem bentigt eine DRAM-Speicherzelle wesentlich weniger SiliziumFlche als eine SRAM-Speicherzelle, weshalb deutlich mehr DRAM-Speicherzellen als SRAMSpeicherzellen auf einen Chip passen. Aus diesem Grund erreicht man bei einer bestimmten Speichergrsse mit DRAM auch eine hhere Ausbeute als mit SRAM, was den Preis von DRAM im Vergleich zu SRAM weiter senkt. Gerade diese Wirtschaftlichkeit hat dafr 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 werden knnen, sind die Daten aufeinanderfolgender Adressen in der Regel in verschiedenen Speicherchips abgelegt. Auf diese Weise kann bei den hufig auftretenden konsekutiven Speicherzugriffen (Zugriffe auf aufeinanderfolgende Adressen) die eine Speicherzelle bereits ausgelesen werden, whrend in die andere noch die beim Auslesen verlorengegangene Ladung zurckgeladen wird. Solche Verfahren haben zu einer Vielzahl unterschiedlicher DRAM-Speicherarten gefhrt. Eine von diesen ist auch das in unserem PC verwendete DDR-RAM (Double-Data-Rate RAM), das eine Weiterentwicklung des SD-RAMs (Synchronous DRAM) ist.

1-45

Wie wir in Abb. 64 auf Seite 1-40 gesehen haben, werden zwischen Prozessor und Arbeitsspeicher Daten transportiert. Prozessor und Arbeitsspeicher sind dazu ber einen sog. Bus miteinander verbunden. Dass dieser Bus in Abb. 53 auf Seite 1-33 noch von einem weiteren Chip, dem GMCH (frher Northbridge genannt), gekreuzt wird, soll uns hier erstmal nicht stren. Wir nehmen zunchst einfach an, dass der Arbeitsspeicher direkt mit dem Prozessor verbunden ist (vgl. nachfolgende Abbildung).

Prozessor (CPU)

Arbeitsspeicher Bus

BR:

Registerblock mit Registern

Steuerwerk/ Leitwerk

Rechenwerk/ ALU

Abb. 70: Prozessor, Arbeitsspeicher und Bus

Desweiteren betrachten wir zunchst auch nicht den in unserem Rechner real verwendeten Bus, sondern wir whlen eine Art Phantasie-Bus, mit dem sich das Prinzip der Datenbertragung leichter verstehen lsst. 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 erfllen: Das bertragen von Daten von einem Sender zu einem Empfnger. 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 TeilBusse 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 Auswhlen bestimmter Speicherstellen (oder Gerte 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 Speicherstellen bestimmt, aus denen die Daten ausgelesen werden sollen.

1-46

Steuerbus: Der Steuerbus steuert die Datenbertragung. + 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 gltig sind und vom Speicher bernommen werden knnen. die auf dem Adressbus befindliche Adresse gltig ist und vom Speicher verwendet werden kann. der Schreibvorgang jetzt durchgefhrt werden soll. + Wenn der Prozessor Daten aus dem Speicher liest, gibt eine fallende Flanke auf der Leseleitung Lesen an, dass der Datenbus jetzt hochohmig (Tristate) ist, so dass der Speicher Daten auf den Datenbus ablegen kann, ohne dass es zu einem Kurzschluss kommt. die auf dem Adressbus befindliche Adresse gltig ist und vom Speicher verwendet werden kann. der Lesevorgang jetzt durchgefhrt 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 intern ab. Nachfolgende Abbildung zeigt die Verwendung unseres Phantasie-Busses bei einem Schreibvorgang. Dabei wird der 4-Bit-Wert 10102 an die Speicheradresse 01102 geschrieben.
Adress-Bus:
Bit 3 Bit 2 Bit 1 Bit 0
1 0 1 0 1 0 1 0

3 Adr. 0000 0001 0010 0011 0100 0101 0110 0111 1000 1001 1010 1011 1100 1101 1110 1111 Inhalt

8 Daten-Bus: 2 0110 1 1010 5 Bus


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

1010 9

7 Steuer-Bus:
Lesen Schreiben
1 0 1 0

6 t tschreiben

Prozessor schreibt Daten 1010 an Adresse 0110 und gibt an der Leitung Schreiben eine fallen- Bus besteht aus Adress-, de Flanke aus. Daten- und Steuer-Bus.

Spannungs-Pegel auf den Busleitungen in Abhngigkeit der Zeit.

Wert am Adress-Bus whlt die Speicherzelle aus, in die die Daten geschrieben werden.

Abb. 71: Bussignale und deren Verwendung beim Schreibzugriff

1-47

Zuerst legt der Prozessor das Datenwort (1), das abgespeichert werden soll, zusammen mit der Adresse (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), whlt er die durch den Adressbus adressierte Speicherzelle aus (8) und schreibt dorthin das am Datenbus anliegende Datenwort (9).

Das Einlesen von Daten aus dem Speicher in den Prozessor funktioniert so hnlich:
Adress-Bus:
Bit 3 Bit 2 Bit 1 Bit 0
1 0 1 0 1 0 1 0

2 Adr. 0000 0001 0010 0011 0100 0101 0110 0111 1000 1001 1010 1011 1100 1101 1110 1111 Inhalt

6 Daten-Bus: 1 0110 10 1010 3 9 Bus


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

1010 7

Prozessor legt Adresse 0110 Steuer-Bus: 4 9 auf den Adress1 Lesen Bus, hlt den 0 Datenbus hochSchreiben 1 ohmig und gibt 0 auf der Leitung t Lesen eine faltschreiben lende Flanke aus. Damit zeigt er, dass die Adresse jetzt Bus besteht aus Adress-, Spannungs-Pegel auf den Busgltig ist und leitungen in Abhngigkeit der Zeit. sofort gelesen Daten- und Steuer-Bus. werden soll.

Wert am Adress-Bus whlt die Speicherzelle aus, aus der die Daten gelesen werden.

Zunchst 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 Arbeitsspeicher, dass dieser den Inhalt der zur am Adressbus anliegende Adresse gehrigen Speicherstelle auf den Daten-Bus legen soll. Detektiert der Arbeitsspeicher die fallende Flanke auf der Lesen-Leitung (5), whlt 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-48

Busse sind jedoch viel universeller, als dass sie nur die Datenbertragung zwischen Prozessor und Arbeitsspeicher bernehmen knnten: ber Busse knnen auch alle im PC installierten Gerte angesteuert werden. Der Verdrahtungsaufwand ist dabei gering, da alle Kommunikationsteilnehmer sich einfach an den Busleitungen einklinken knnen, jede Busleitung also mit jedem Gert verbunden ist.

Die nachfolgende Abbildungen zeigen, wie Daten nicht nur zwischen Prozessor und Speicher, sondern auch zwischen Prozessor und einem beliebigen Peripherie-Gert bertragen werden knnen.

Das Schreiben von Daten in ein Peripheriegert 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 Gerte zugeordnet.

Adress-Bus:
Bit 3 Bit 2 Bit 1 Bit 0
1 0 1 0

2 3
0110 1010
1 0 1 0

Gert 1 7
ja

Adresse == meine? nein

3 Daten-Bus: 1 0110 4 1010 10 Bus


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

0110

Gert 2 7
ja 9

1010

Adresse == meine? nein

6 12

1010

3
0110 1010

Gert 3 7
ja

Adresse == meine? nein

6 Steuer-Bus:
Lesen Schreiben
1 0 1 0

11 t tschreiben

3
0110 1010

Gert 4 7
ja

Adresse == meine? nein

Prozessor schreibt Daten 1010 an die Adresse 0110 und gibt an der Leitung Schreiben eine falBus besteht aus Adress-, lende Flanke Daten- und Steuer-Bus. aus.

Pegel auf den Busleitungen in Abhngigkeit der Zeit.

Am Bus angeschlossene Gerte berprfen die Adresse und bernehmen ggf. die Daten.

Abb. 72: Schreiben von Daten in ein am Bus angeschlossenes Gert (z.B. Steuerbefele frs 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 angeschlossenen Gerten an (3). Als nchstes legt der Prozessor die zu schreibenden Daten (4) auf den Daten-Bus (5), so dass auch diese an allen am Bus angeschlossenen Gerten anliegen (6). Jedes der am Bus angeschlossenen Gerte berprft nun, ob es fr die auf dem Adress-Bus anliegende Adresse (3) zustndig ist (7). In unserem Beispiel erkennen die Gerte 1, 3 und 4, dass sie nicht fr die am Adress-Bus anliegende Adresse zustndig sind, weshalb sie nichts unternehmen (8).

1-49

Gert 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 Gerte gelangt, bernimmt Gert 2 die am Datenbus anliegenden Daten in seine durch 0110 adressierte Speicherstelle (12).

Das Lesen von Daten aus am Bus angeschlossenen Gerten funktioniert sehr hnlich:

Adress-Bus:
Bit 3 Bit 2 Bit 1 Bit 0
1 0 1 0 1 0 1 0

2 3
0110

Gert 1 4
ja

Adresse == meine? nein

3 Daten-Bus: 1 0110 12 1010 7 11 Bus


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

0110

Gert 2 4
ja 6

10

1010

Adresse == meine? nein

1010

3
0110

Gert 3 4
ja

Adresse == meine? nein

5 Steuer-Bus:
Lesen Schreiben
1 0 1 0

11 3
0110

Gert 4 4
ja

Adresse == meine? nein

t Prozessor liest Daten aus der Speicherstelle 0110 eines ex- Bus besteht aus Adress-, ternen Gerts Daten- und Steuer-Bus. ein.

Pegel auf den Busleitungen in Abhngigkeit der Zeit.

Am Bus angeschlossene Gerte berprfen die Adresse und legen ggf. die Daten auf den Bus.

Abb. 73: Einlesen von Daten von einem am Bus angeschlossenen Gert (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 Gerten an (3). Jedes Gert berprft nun, ob es fr diese Adresse zustndig ist (4). In obiger Abbildung sind wieder die Gerte 1, 3 und 4 nicht fr die am Bus befindliche Adresse zustndig und ignorieren somit die Anfrage (5). Gert 2 erkennt, dass es fr die am Bus anliegende Adresse zustndig ist (6) und macht sich fr 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 Gerten detektiert. Sobald das Gert 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-50

Nachdem wir nun wissen, wie der Prozessor Peripheriegerte ansprechen kann, knnen wird das in Abb. 70 auf Seite 1-46 gezeigte Bild wie nachfolgend angegeben erweitern:

Arbeitsspeicher

B4 C9

Bus Prozessor (CPU)

Bios-Programm (Flash) Bios-Daten (batteriegepuffert) in C enthalten

Peripherie:
A

BR:

DL

Diskettenlaufwerk Festplatte

Registerblock mit Registern


c:\>

FP

Steuerwerk/ Leitwerk

Rechenwerk/ ALU

DR DB C1

CD-/DVD-Laufwerk LAN, USB, FireWire

Bildschirm

GK
D5

Tastatur

Abb. 74: Vereinfachter Aufbau eines Computers

Der Prozessor ist ber einen Bus mit der Aussenwelt verbunden. Der Bus dient als einziges Kommunikationsmittel zwischen dem Prozessor und den restlichen Komponenten und wird (bis auf DMAZugriffe) 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 ausgefhrt werden; man spricht hier vom sog. BIOS (Basic Input Output System), da in diesem Chip Programme abgelegt sind, die eine rudimentre Ansteuerung von Ein- und Ausgabegerten ermglichen. Benutzerdefinierte Einstellungen, die beim Starten des Rechners durchgefhrt werden sollen, sind dabei in einem 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 ausfhrt, auch die Daten, mit denen der Prozessor seine Berechnungen anstellt.

1-51

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 lsst sich damit im wesentlichen auf drei Schritte zurckfhren: Der Prozessor liest Daten aus dem Speicher oder einem Peripherie-Gert ein. Der Prozessor verarbeitet diese Daten oder fhrt sie als Programm aus. Der Prozessor speichert verarbeitete Daten ab oder schickt sie an ein Peripherie-Gert.

Wenn wir unseren Computer einschalten, beginnt der Prozessor automatisch damit, Befehle aus einer bestimmten Speicheradresse zu holen und dann als Programm auszufhren. Diese allererste Speicheradresse liegt im Hauptplatinen-BIOS. Der Prozessor fhrt also zunchst Befehle aus, die in dem auf der Hauptplatine aufgelteten Flash-Speicher abgelegt sind. Mit diesen Befehlen wird zunchst die Hardware der Hauptplatine berprft (POST = Power On Self Test). Im Anschluss berprft der Prozessor den Arbeitsspeicher auf Kapazitt (Menge des verfgbaren Speichers) und Funktionsfhigkeit. 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 zeigen. Auf diese Weise werden im Chipsatz z.B. Einstellungen fr das Ansprechen des Arbeitsspeichers (Verzgerungszeiten etc.) oder fr die Zugriffsweise auf den PCI-Bus gettigt. Die Ausfhrung des im BIOS abgelegten Codes sorgt auch dafr, dass die BIOS-Bausteine der Steckkarten und Peripherie-Gerte ausgelesen werden und der dort abgelegte Befehlscode vom Prozessor teilweise ausgefhrt wird. Bei der Ausfhrung dieses Codes werden dann die zugehrigen Steckkarten bzw. Peripherie-Gerte initialisiert. Dazu schreibt der Prozessor wieder Daten an Adressen, die auf Speicherstellen in den Steckkarten (z.B. Grafikkarte) bzw. in den Peripherie-Gerten verweisen. Diese Daten werden von den entsprechenden Gerten dann als Befehle interpretiert und ausgefhrt, was beispielsweise zu einer Grund-Einstellung der Grafikkarte fhrt. Desweiteren werden aus den BIOS-Bausteinen rudimentre Treiber fr die zugehrigen Steckkarten bzw. Gerte ausgelesen und im Arbeitsspeicher abgelegt. Der Begriff rudimentr meint dabei, dass die Treiber einen sehr eingeschrnkten Funktionsumfang aufweisen und lediglich dafr Sorge tragen, dass beim Starten des PCs die betreffenden Gerte in ihrer Grundfunktionalitt verwendet werden knnen. Sollen beim Starten des Computers Funktionen einer Steckkarte ausgefhrt werden, verzweigt der Programmfluss in den Treiber, der dann die Kommunikation mit der Karte bernimmt, ihr die durchzufhrende Aktion mitteilt und evtl. ein Ergebnis zurckliefert. Beispielsweise ermglicht 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 Betriebssystems werden von der Festplatte dann die richtigen Treiber fr die Grafikkarte geladen, mit denen sich das volle Leistungsspektrum der Grafikkarte ausschpfen lsst. Da es wesentlich gnstiger ist, Treiber von der Festplatte zu laden, als jede Steckkarte bzw. jedes Gert mit einem Flash-Speicherchip auszursten, verfgen nur diejenigen Steckkarten/Gerte ber einen BIOS-Chip, die bereits beim Booten des Rechners funktionieren mssen: Grafikkarten, da diese evtl. Fehlermeldungen auf dem Bildschirm ausgeben mssen. Netzwerkkarten, da der Rechner evtl. ber das Netzwerk gestartet werden soll, der sog. Bootloader (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 gnstiger, 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 herunterzuladen und in einem bestimmten Ordner abzulegen, als den Flash-Speicher neu zu programmieren.

1-52

Nach dem Laden/Ausfhren der BIOS-Routinen der Steckkarten sorgt das im Hauptplatinen-BIOS abgelegte Programm dafr, 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 ldt. Ist der Bootloader gefunden, sorgt das BIOS-Programm dafr, dass der Bootloader in den Arbeitsspeicher geladen und dann vom Prozessor ausgefhrt wird. Die Kontrolle geht in diesem Moment vom BIOS-Programm an den Bootloader ber, der zunchst die Festplatte nach einem gltigen Betriebssystem durchsucht und den Programmcode des Betriebssystems dann ebenfalls in den Arbeitsspeicher ldt und dann vom Prozessor ausfhren lsst. Jetzt geht die Kontrolle vollstndig an das Betriebssystem ber, das der Reihe nach immer mehr Daten von der Festplatte in den Arbeitsspeicher ldt und dann als Programm ausfhrt. Dabei werden neben Betriebssystem-Code insbesondere auch die auf der Festplatte gespeicherten Treiber der Peripherie-Gerte in den Arbeitsspeicher geladen (und z.T. ausgefhrt), so dass die am PC angeschlossenen Gerte ber diese Treiber-Schnittstelle angesprochen/verwendet werden knnen. Aber nicht nur beim Starten des PCs dreht sich alles darum, dass der Prozessor Daten aus dem Arbeitsspeicher oder den Peripherie-Gerten einliest, verarbeitet (oder ausfhrt) und dann wieder ausgibt: Wir haben zuvor gesehen, dass die ganze Darstellung des Bildschirminhalts darauf basiert, dass der Prozessor Daten in den Video-Speicher der Grafikkarte schreibt. Drckt man eine Taste auf der Tastatur wird dies dem Prozessor gemeldet und ber den Bus wird dann der Wert der gedrckten Taste ausgelesen. Beim Bewegen der Maus wird dem Prozessor ber den Bus mitgeteilt, um wieviele Lngeneinheiten die Maus nach links/rechts bzw. vorne/hinten bewegt wurde. Der Prozessor berechnet dann aus dieser Information die neue Position des Maus-Cursors, rendert im Arbeitsspeicher die neue Bildschirmansicht, die den verschobenen Mauszeiger darstellt und bertrgt dieses Bild dann wieder in den Video-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 nchsten Seite noch einmal abgebildete Rechner-Architektur entspricht der realen Implementierung der in Abb. 74 auf Seite 1-51 gezeigten stark vereinfachten Rechner-Architektur. Die Unterschiede sind klar erkennbar: In unserem vereinfachten Modell (Abb. 74) sind alle Komponenten direkt an den Prozessor angeschlossen. Es gibt nur einen Bus, ber den alle Komponenten und Peripherie-Gerte miteinander und mit dem Prozessor verbunden sind. Unabhngig davon, wie schnell die einzelnen Gerte Daten verarbeiten oder bertragen knnen. So ein System wre prinzipiell lauffhig, aber sehr langsam, da die langsamen Gerte am Bus die schnellen ausbremsen. Die reale Rechner-Architektur aus Abb. 75 verwendet mehrere verschiedene Busse, die unterschiedlich schnell sind und ber sog. Bridges miteinander verbunden sind. Die englische Bezeichnung Bridge trifft die Funktion dieser Bausteine auf den Kopf: Bridges sind Brcken, die verschiedene Bussyteme miteinander verbinden. Dabei werden die Daten, die ber den sehr schnellen FSB mit dem 9 spezifischen FSB-Protokoll an den GMCH geschickt werden und nicht fr ein direkt mit dem GMCH verbundenes Gert bestimmt sind, in das Bus-Protokoll des etwas langsameren HI-Busses gepackt und dann an den ICH5 bertragen. Sind die Daten auch fr keine direkt im ICH5 integrierte Komponente gedacht, werden die Daten in das entsprechend nchste 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 PCIProtokoll und verarbeitet sie.
9 Unter einem Bus-Protokoll versteht man die Regeln, nach denen die Kommunikation ber den Bus abluft. Beispiele fr solche Regeln sind: Zuerst legt der Sender die Adresse fr mindestens 20 ms auf den Adress-Bus. 5 ms, nachdem die Adresse am Bus anliegt, folgt ein fallender Pegel auf der Lesen-Leitung...

1-53

Die gesamte Rechner-Architektur ist also gekennzeichnet durch ein von Bridges aufgespanntes Verbindungsnetzwerk, dessen bertragungsrate hher wird, je nher man dem Prozessor kommt und niedriger wird, je weiter man sich vom Prozessor entfernt.
A Prozessor Intel P4 NT 230 V ~ Netzteil
RechenWerk SteuerWerk

Adress-Umsetzer BefehlsCache DatenCache

FSB Logik/Treiber

FS B TFTBildschirm B1 DVI B2 Grafikkarte GK AGP-Port Analoger VGAAnschluss


GrafikController AGP-

Prozessor-Bus, 4200 MHz (FSB = Front Side Bus)

Intel 82865G GMCH

DDR-RAM
DDR-RAM

B4

2,1 GByte/s Controller Controller

Kanal A 3,2 GyteB/s

DDR-RAM B4 DDR-RAM B4

Gigabit-EthernetCSAController Controller 266 MByte/s B3


HI Controller

Kanal B 3,2 GByte/s

DDR-RAM B4

1 GBit/s HI LA LANAnschluss C

HI = Hub Interface 266 MByte/s

Intel 82801EB ICH5 100 MBit/s


Ethernet- SystemController Managmnt. PCIUSB2.0Controller Controller 2 SATAController CMOSRAM

C6 Takt-Generator CPU, PCI, C7 PCI-Bus 133 MByte/s 6 PCI-Slots FW Batterie C8 FireWireAdapter

C1 FP Festplatte DVDROM DVDBrenner DR C3 C2

Anschlsse fr USB 2.0

480 MBit/s

2 Anschlsse 150 MByte/s fr Serial-ATA 2 Anschlsse fr ATA 100 Audio-Codec AC `97 3 100 MByte/s

ATA 100 Bios-interf. Controller Controller AC `97 SMBus Controller Controller LPC-interface Controller

Flash-Bios SMBus 2.0/ I2C-Bus

C9

DB

C4

LPC-Interface (Low Pin Count) D Super Input/Output Controller D4 D1 Anschluss fr seriellen Port D2 Anschluss fr parallelen Port Anschluss fr Ventilator
RS 232 Floppy Controller Controller LPT Tastatur Controller Controller DrehzahlMaus regelung Controller

DL DiskettenLaufwerk Tastatur

Anschluss Disketten-Laufwerk PS/2 Anschluss D5 Tastatur PS/2 Anschluss Maus

D3

Maus D6

Abb. 75: Architektur eines Computers

1-54

Im Folgenden sind die Funktionen der Haupt-Bridges stichpunktartig zusammengestellt. GMCH = Graphics and Memory Controller Hub (B) ist direkt am Prozessor angeschlossen Datenverteiler fr sehr schnelle Gerte fhrt fr den Prozessor Zugriffe auf den Arbeitsspeicher (engl. Memory, hier: DDR-RAM) aus verfgt ber einen integrierten Grafik-Controller (eine integrierte Grafik-Karte), mit der der Prozessor 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 Anschlussmglichkeit fr 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 frher auch Northbridge genannt (North, da oben beim Prozessor und Bridge, da Verbindung zwischen zwei Bussen [Brckenfunktion]) ICH5 = Input/Output Controller Hub (5. Generation) (C) Datenverteiler fr mittel schnelle bis schnelle Gerte 11 12 verfgt ber diverse Ein- und Ausgabe-Controller, insbesondere fr PCI und IDE internes batteriegepuffertes RAM zur Sicherung von Konfigurationsdaten (z.B. BIOSEinstellungen) bietet Anschlussmglichkeit fr den Flash-BIOS-Chip, der den System-Startup-Code enthlt frher auch Southbridge genannt, (South, da unterhalb der Northbridge und Bridge, da Brckenfunktion zwischen verschiedenen Bussen) SIO-Controller = Super Input/Output Controller (D) Datenverteiler fr langsame Gerte verfgt insbesondere ber die Controller fr serielle/parallele Schnittstellen, Floppy, Tastatur und Maus
10

Controller = aktive Komponente, die andere Elemente steuert (engl. to control = steuern). PCI = Peripheral Component Interconnect: Standardisierter Peripheriebus Peripherie-Gerte (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-Gerte auch ber mehrere Prozessorgenerationen hin verwendet werden knnen. Bei der Entwicklung neuer Prozessoren, die evtl. auch ber einen genderten FSB verfgen, 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-Gerte knnen dann trotz gendertem 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 begrndet sich darin, dass Festplatten vor IDE-Zeiten ber keine eigenen Controller-Chip verfgten, also direkt vom Prozessor gesteuert wurden. Mit der Einfhrung von IDE wurden die Steueraufgaben der Festplatte (z.B. Kopfpositionierung) von einer im Festplattengehuse untergebrachten Steuerelektronik (dem Controller) erledigt, was zu einer starken Entlastung des Hauptprozessors fhrte. Durch die Standardisierung von IDE und der Entkoppelung vom Prozessor/FSB ergeben sich die selben Vorteile wie beim PCI-Bus.
11

10

1-55

1.2 Von Neumann-Architektur Die Architektur unseres Rechners geht unter anderem auf den Mathematiker John von Neumann zurck, 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, ausgewhlte 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 frh von Joseph-Marie Jacquard, dessen Lochkartenbetriebene Websthle in Abhngigkeit 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 Mitschler auch nur annhernd das Wasser reichen. Whrend seine Kameraden auf dem Pausenhof spielten, stand der kleine Johnny eher abseits und analysierte das Verhalten seiner Mitschler. Sein Vater frderte ihn, indem er Professoren anstellte, die Johnny nach der Schule daheim unterrichteten. Johnny wollte Mathematiker werden, doch sein Vater drngte ihn, in Berlin Chemieingenieur zu studieren, da diesem Beruf gute Zukunftsaussichten nachgesagt wurden. Johnny entschloss sich schlielich fr einen ehrgeizigen Kompromiss, der ihn zum Einen absicherte, zum Anderen aber auch alle Karriere-Chancen offen lie: Noch bevor er sich fr das Studium als Chemieingenieur einschrieb, schrieb er sich an der Universitt Budapest als Doktorand in Mathematik ein. Er hatte vor, als Student und Doktorand gleichzeitig zu arbeiten und zwar in zwei mehreren hundert Kilometer auseinanderliegenden Stdten. Um diese Unverfrohrenheit auf die Spitze zu treiben, wollte der damals 17-jhrige Gymnasiast in seiner Doktorarbeit die Axiomatisierung der Mengenlehre Georg Cantors versuchen das strittigste Themen der zeitgenssischen Mathematik, das bereits einige berhmte Professoren aufs Glatteis gefhrt hatte. Das Studium als Chemieingenieur in Berlin sah John von Neumann eher als lstige Nebenttigkeit an, weshalb er es auch nach zwei Jahren ohne Abschluss beendete und dafr im Herbst 1923 die Aufnahmeprfung fr das zweite Jahr des Vierjahreskurses Chemieingenieur an der 13 rennomierten ETH (Eidgenssische Technische Hochschule) Zrich bestand. John von Neumann hatte eine aussergewhnliche Begabung: Er konnte sich sehr schnell in fremde Thematiken einlesen und dann die in diesem Bereich ttigen Forscher mit seinem Wissen meilenweit berholen.

Abb. 76: John von Neumann

13 Albert Einstein mit dem John von Neumann spter in Princeton zusammenarbeitete versagte 1895 bei der Aufnahmeprfung der ETH, woraufhin er eine Stelle im Berner Patentamt annahm. Dort entwickelte er dann die Spezielle Relativittstherorie.

1-56

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 Verallgemeinerung von Brouwers Fixpunkt-Theorem wichtigste Beitrge zu den Wirtschaftswissenschaften. Ende der 1980er Jahre wurde die genannte Niederschrift von berhmten Wirtschaftswissenschaftlern als der wichtigste Artikel auf dem Gebiet der mathematischen konomie, der jemals geschrieben wurde bezeichnet. John von Neumanns Beitrge zur Computertechnik liegen insbesondere in der Programmierbarkeit von Computern. Bevor John von Neumann die Computertechnik revolutionierte, waren Computer darauf ausgerichtet, die Lsung fr ein ganz bestimmtes Problem zu berechnen. Die Computer wurden damals programmiert, indem die Kabelverbindungen zwischen den Komponenten des Computers gendert wurden. John von Neumann erinnerte sich an die in seiner Kindheit kennengelernten Websthle von Joseph-Marie Jacquard, die in Abhngigkeit 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 Abhngigkeit von Lochkarten unterschiedliche Programme ausfhren. 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 ntig. Der Aufbau des Rechners war pltzlich unabhngig vom zu lsenden 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 abhngig, in dem der Befehl stand. Betrachtet man beispielsweise im Satz Fliegen ist schn. 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 schne 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 Regelmigkeit 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 uerst regelmiges Befehlsformat: Das erste Byte ist immer der Befehl, die nchsten drei Byte sind immer die Operanden.) John von Neumann schlug vor, den von Eckert und Mauchly am IAS gebauten Computer um die Programmierbarkeit 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 fr 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 flschlicherweise Ehren zugesprochen, die eigentlich Eckert und Machly zugestanden htten, 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-Verffentlichung gebaut wurden und in groben Zgen immer noch der Architektur unserer heutigen Rechner entsprechen, von Neumann-Architektur genannt werden.

1-57

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

Speicher fr Daten und Befehle

Registerblock mit Registern Steuerwerk/ Leitwerk Rechenwerk/ ALU

Ein- und Ausgabe

c:\>

Prozessor
Abb. 77: von Neumann-Architektur

Das Rechenwerk verknpft die Operanden, indem es Operationen auf sie anwendet. Beispiele hierfr sind die vier Grundrechenarten (Addition, Subtraktion, Multiplikation und Division) und Schiebeoperationen (links schieben/rechts schieben). Allein mit den vier Grundrechenarten lassen sich auch die kompliziertesten Formeln und Funktionen berechnen. Beispiele hierfr sind die Verwendung von Potenzreihen zur Berechnung von Sinus und Cosinus:
sin x = x x 3 x5 x7 x 2n +1 + + ... + ( 1)n + ... 3! 5! 7! (2n + 1)!

Im Speicher stehen sowohl die Befehle, als auch die Operanden/Daten. Beide sind als Zahlen codiert. Bei einem Blick in den Speicher kann man somit keinen Unterschied zwischen Befehlen und Operanden/Daten erkennen. Dass eine Bitfolge ein Befehl ist, erkennt man erst dann, wenn sie vom Steuerwerk in das Befehlsregister geladen und dann ausgefhrt worden ist. Das Steuerwerk steuert den Ablauf im Prozessor/Rechner. Es ldt die Befehle aus dem Speicher, analysiert sie, ldt die entsprechenden Operanden aus oder in den Speicher, teilt dem Rechenwerk mit, welche Operation es ausfhren soll und leitet das Ergebnis wieder an die gewnschte Stelle. Das Ein- und Ausgabewerk (E/A-Werk) ist die Schnittstelle zwischen Rechner und PeripherieGert, zu von Neumanns Zeit also die Anbindung des Rechners an den Lochkartenleser. Im letzten Abschnitt haben wir gesehen, dass bei unseren weiterentwickelten von NeumannArchitekturen 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 spter noch der Bus dazugekommen, der somit nicht zu den original von Neumannschen Funktionseinheiten gehrt.

1-58

Im Folgenden sind einige fr von Neumann-Maschinen typische Merkmale aufgefhrt: Der Aufbau des Rechners ist unabhngig vom Problem. Durch Laden eines bestimmten Programms in den Speicher kann der Rechner zu Lsung jedes beliebigen Problems verwendet werden. Die Hardware (z.B. Verbindungsleitungen) muss also nicht mehr auf die jeweilige Problemstellung angepasst werden. Alle Daten (nicht nur die Operanden, sondern auch die Adressen und insbesondere auch die Befehle) werden als Zahlen binr kodiert und im Speicher abgelegt. Der Speicher besteht dabei aus gleich grossen, durchnumerierten Zellen. Die zu einem Programm gehrigen Befehle stehen sequentiell (einer nach dem anderen) im Speicher und werden der Reihe nach ausgefhrt. Lediglich bei Sprngen findet eine Verzweigung statt. Da von Neumann auf eine Patentierung seiner Erweiterungen verzichtete , konnte jede Forschungsanstalt/Firma ohne Lizenzgebhren auf diesen Erweiterungen aufbauen und sie weiter vorantreiben. Es war genau dieser Sachverhalt, der sich als sehr fruchtbarer Boden fr Weiterentwicklungen erwies und damit zum Siegeszug der von Neumann-Architektur fhrte.
14

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

1-59

1.3 Harvard-Architektur Der gemeinsame Speicher fr Programme und Daten macht die Entwicklung und den Test von Programmen auf einer von Neumann-Architektur sehr einfach: Man schreibt in einem Texteditor ein Programm, bersetzt es in Maschinencode und kann es dann sofort ausfhren. Whrend des Vorgangs des bersetzens sind die Befehle des generierten Maschinencodes die Daten, die das bersetzungsprogramm erzeugt. Diese Daten werden erst zu einem Programm, wenn sie vom Prozessor in das Befehlsregister geladen werden und dann ausgefhrt werden. Da Daten und Programme nicht unterscheidbar im selben Speicher liegen, bedeutet es keinen zustzlichen Aufwand, Daten als Programm auszufhren. Es ergibt sich jedoch auch ein Nachteil: Da Programme und Daten im selben Speicher liegen, mssen beide ber den gleichen Bus zum Prozessor transportiert werden. Whrend 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 insbesondere 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 fr Daten

Prozessor
Registerblock mit Registern Steuerwerk/ Leitwerk Rechenwerk/ ALU

Ein- und Ausgabe

c:\>

Speicher fr Befehle
Abb. 78: Harvard-Architektur

Da Daten- und Befehlsspeicher bei dieser Architektur getrennt sind, knnen sie ber separate Busse an den Prozessor angebunden werden. Somit kann gleichzeitig auf Befehle und Daten zugegriffen werden, was insbesondere die Ausfhrung von Programmen mit hohem Datenverkehr beschleunigt. Da solche Programme (z.B. ein Videodecoder in einer Set-Top-Box) besonders oft auf spezialisierten Signalprozessoren ablaufen, verfgen Digitale Signalprozessoren (DSPs) ebenso wie Mikrocontrol15 ler hufig ber eine Harvard-Architektur. Programme fr DSPs und Mikrocontroller werden in der Regel auf einem gewhnlichen 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 Daten- oder den Befehls-Speicher eines Signalprozessors geladen werden, hat die Verwendung einer 16 Harvard-Architektur fr Embedded-Prozessoren keine Nachteile. Bei der Verwendung einer HarvardArchitektur als PC-Prozessor hingegen msste nach der bersetzung eines Programms der Programmcode erst vom Daten- in den Befehlsspeicher kopiert werden, was die Programmentwicklung verlangsamen und umstndlich machen wrde.
15 Mikrocontroller sind Mikroprozessoren, die ber zustzliche Peripherie auf dem Chip (z.B. Ein- und Ausgabe-Ports, A/DWandler, Timer, Befehls- und Datenspeicher) verfgen. Mikrocontroller werden im Embedded-Bereich beispielsweise zur Steuerung von Waschmaschinen, Kochfeldern etc. verwendet. 16 Unter Embedded-Prozessoren bzw. Prozessoren fr den Embedded-Bereich versteht man Prozessoren, die nicht in PCs, sondern in anderen eigenstndigen Gerten wie beispielsweise einer Mikrowelle, einer Waschmaschine oder einem DVDPlayer integriert (eingebettet) sind.

1-60

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 Lsung von Problemen eingesetzt werden kann. Nachfolgende Abbildung dient uns dabei als Wegweiser durch die nchsten Kapitel.

i>0

Algorithmus-Ebene
x = x + aibi i =i1

Problemlsung in AlgorithmusForm

bersetzung durch den Menschen Hochsprachen-Ebene bersetzung durch Compiler Assembler-Ebene bersetzung durch Assembler Bibliothek *.obj Befehlssatz-Ebene *.asm *.c Compiler *.asm Maschinennahe Form der Problemlsung *.c Problemlsung in Hochsprache (z.B. C)

Beim Entwurf

Assembler *.obj Linker *.obj Maschinencode der Problemlsung

Linker

*.exe Interpretation oder direkte Ausfhrung durch die Hardware Mikroarchitektur-Ebene Steuerung Interpretation HardwareSteuerung Mikroprogramm

Elektr. Signale Gatter/Hardware

Aufbau des Problemlsers (Rechner/Prozessor) aus Speicher, ALU Aufbau von Speicher, ALU.. aus LogikGattern Aufbau von Logik-Gattern aus Transistoren Aufbau von Transistoren aus n- und pSchichten

Zur Laufzeit

Ebene der digitalen Logik

Transistor-Ebene

Transistoren

Layout-Ebene

Halbleiter-Strukturen

Abb. 79: Abstraktionsebenen

1-61

Integr. Schaltungen

Computertechnik/Computersysteme

Grundl. d. Informatik

i = n, x = 0

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 (Hochsprachen-Ebene) formuliert werden kann. Aufgabe der Algorithmus-Ebene ist es, Informationen und Anweisungen, die zur Lsung des betrachteten Problems notwendig sind, in einer einheitlichen Darstellung festzuhalten. Beispiele fr solche Darstellungen sind z.B. Lsungsformeln

x = [a1

a2

b1 b2 a n ] = a1b1 + a2 b2 + bn

+ a n bn

Abb. 80: Formel zur Berechnung eines Skalarprodukts

oder Diagramme.
i = n, x = 0 i>0 x = x + aibi i =i1
Abb. 81: Nassi-Shneiderman-Diagramm/Struktogramm

Ist die gewhlte Darstellungsart hinreichend bekannt, kann sie zur Weitergabe von Informationen oder Lsungsverfahren genutzt werden. Wenn Sie beispielsweise wissen, wie man die in Abb. 80 dargestellten Buchstaben, Zahlen (Indices) und Symbole interpretieren muss und zustzlich ber die Information verfgen, dass die in Abb. 80 dargestellte Formel zur Berechnung von Skalarprodukten dient, knnen sie automatisch auch Skalarprodukte berechnen. Die Darstellungen auf der Algorithmus-Ebene dienen also zum Informationsaustausch zwischen Menschen. Fr Maschinen (Computer) sind diese Darstellungsarten zu abstrakt. Ein Computer kommt mit einer Problem-Beschreibung auf Hochsprachen-Ebene wesentlich besser zurecht. Das liegt insbesondere daran, dass bei der Entwicklung von Hochsprachen darauf geachtet wurde, dass sie nicht nur vom Menschen (Programmierer), sondern auch vom Computer (Compiler) gut verstanden werden kann. Eine Hochsprache ist also eine definierte Schnittstelle zwischen Mensch und Maschine. Nachfolgende Abbildung zeigt, wie ein Programmierer einen ihm als Nassi-Shneiderman-Diagramm bermittelten Algorithmus in die Hochsprache C bersetzt. i = n, x = 0 i>0 x = x + aibi i =i1

*.c

*.c

Abb. 82: bersetzen eines Algorithmus auf Hochsprachen-Ebene

1-62

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 fr einen Menschen etwas schwieriger zu lesen als die Darstellung als Formel oder Nassi-Shneiderman-Diagramm. Fr eine Maschine ist diese Darstellung jedoch wesentlich angenehmer, da sie beispielsweise nur aus ASCII-Zeichen besteht. Hochsprachen sind aber keineswegs die Muttersprache eines Computer, also keine Sprache, die Computer direkt verstehen knnen. Hochsprachen sind ein Kompromiss zwischen fr den Menschen verstndlich und fr den Computer verstndlich. Damit ein Computer den Sinn von HochsprachenAnweisungen verstehen kann, mssen diese in Maschinen-Code, die Muttersprache der Computer bersetzt werden. Dazu wird zunchst die Hochsprache mit Hilfe eines Compilers in Assembler-Befehle bersetzt. Nachfolgende Abbildung zeigt den Ausschnitt aus Abb. 79, der in *.c-Dateien abgespeicherten CQuellcode in Assembler-Code bersetzt.

*.c

*.c

Compiler

*.asm

*.asm

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. Zustzlich zu den vom Prozessor untersttzten Befehlen findet man auf der Assembler-Ebene jedoch noch Anweisungen fr den Assembler, also Anweisungen fr das Programm, das den Assembler-Code in Maschinen-Code bersetzt. Diese Anweisungen dienen zum Einen dazu, den Code lesbarer zu machen, zum Anderen, um festzulegen, wo im Speicher das bersetzte Programm zur Ausfhrung abgelegt werden soll.

1-63

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

LOC GREG N ADR_A1 OCTA OCTA OCTA OCTA OCTA OCTA OCTA OCTA OCTA IS IS IS IS IS IS LOC SETL LDA LDA LDO MUL BZ SUB LDO LDO MUL ADD JMP TRAP

Data_Segment @ 4 1 2 3 4 10 20 30 40 $1 $2 $3 $4 $5 $6 #100 x,0 u,ADR_A1 v,ADR_B1 w,N w,w,8 w,Ende w,w,8 y,u,w z,v,w y,y,z x,x,y Start 0,Halt,0 Vektordimension a1 a2 a3 a4 b1 b2 b3 b4 Fr Fr Fr Fr Fr Fr Parameter 1 Parameter 2 Parameter 3 das Ergebnis Zwischenberechnungen Zwischenberechnungen

ADR_B1

u v w x y z Main

Start

Initialisierung Referenz auf a1 in u speichern Referenz auf b1 in v speichern Vektordimension laden verwendete Worte haben 8 Byte wenn fertig -> Ende w = w - 8 y = <u + w> z = <v + w> y = <u + w> * <v + w> x = x + <u + w> * <v + w> Ergebnis steht in x

Ende

Das Assembler-Programm ist wesentlich lnger als das C-Programm. Das liegt daran, dass Hochsprachen-Anweisungen wesentlich mchtiger sind (mehr knnen) als Assembler-Anweisungen. Aus diesem Grund wird eine C-Anweisungen in mindestens eine, meist jedoch mehrere AssemblerAnweisungen bersetzt. Damit ein Prozessor Assembler-Anweisungen verstehen kann, mssen diese erst in Maschinen-Code bersetzt werden, der dann in einer Programm-Datei abgelegt wird. Diese Aufgabe wird vom Assembler bernommen. Besteht ein Programm aus mehreren Programm-Dateien, mssen diese zustzlich von einem Linker zu einer einzigen Programm-Datei (unter Windows die *.exe-Datei) zusammengefgt werden. Nachfolgende, der Abb. 79 entnommene Darstellung verdeutlicht diesen Vorgang.

*.asm

*.asm

Assembler Bibliothek *.obj *.obj Linker *.obj

Linker

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

1-64

In der ausfhrbaren Programmdatei stehen neben den Maschinen-Befehlen unter anderem auch Anweisungen fr das Betriebssystem (den Loader), der das Programm in den (Befehls-) Speicher ldt und dann an einer bestimmten Stelle mit der Ausfhrung beginnt. Nachfolgende Abbildung zeigt den Inhalt der zum oben angegebenen Assembler-Code gehrigen Programmdatei.
98 00 00 00 00 00 98 98 8D 8C F1 98 00 41 31 40 82 1F 1F 09 00 00 00 00 00 06 07 03 05 FF 0A 00 20 28 40 20 75 79 01 00 00 00 00 00 00 00 FE 01 FF 00 01 44 84 30 53 01 05 01 00 00 00 00 00 03 18 00 03 FA FE 00 20 40 4D 20 85 89 3E 00 00 00 00 00 73 E3 19 8C 98 20 98 52 40 20 74 1F 0F B7 00 00 00 00 00 6B 04 03 06 04 00 0B 20 20 61 20 76 7A E8 00 00 00 00 00 61 00 03 02 00 00 00 5F 45 20 61 02 06 DB 04 02 04 14 28 6C 00 08 03 07 00 00 30 20 69 10 86 8A 98 00 00 00 00 98 70 23 42 18 98 00 20 41 6E 02 20 1F 98 01 00 00 00 00 01 72 01 03 05 07 00 3A 09 20 6E 72 77 0C 20 00 00 00 00 00 6F FE 00 05 00 00 50 31 64 01 02 03 00 01 00 00 00 00 01 64 08 00 06 25 00 50 08 02 00 74 87 18 00 00 00 00 00 00 2E 23 25 20 00 00 50 83 65 81 01 1F 00 00 00 00 00 00 6D 02 03 04 00 00 50 20 01 09 14 78 00 00 00 00 00 01 6D FE 03 04 00 00 40 42 30 4E 8C 04 00 01 03 0A 1E 00 73 28 08 05 00 00 20 09 8B 00 10 88

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

Abb. 79 knnen Sie entnehmen, dass wir nun den kompletten oberen Bereich Beim Entwurf durchlaufen haben. Von der Algorithmus-Ebene bis zur Befehlssatz-Ebene haben wir uns dabei stets mit der Darstellung von Information beschftigt. Wir haben die Informationsdarstellung schrittweise von fr den Menschen gut lesbar, aber fr den Computer schlecht lesbar bis fr den Menschen schlecht lesbar, aber fr den Computer gut lesbar verndert. Die gezeigten Umwandlungen von einer Darstellung in eine andere finden immer beim Entwurf statt, also whrend der Entwicklung des Programms. Im Gegensatz dazu beschftigt 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 Baueinheiten, welche die als Nullen und Einsen codierten Programme interpretieren und ausfhren. Nachfolgende Darstellung zeigt die Mikroarchitektur des MMIX-Prozessors, mit dem wir uns im Laufe der Vorlesung beschftigen werden.

1-65

BZ bernehmen 4 64 Add 64 64 24..31

Ergebnisauswahl

Steuerung

ALU-Funktion

Registerblock
SchreibDaten $X

8 64 64 64 ALU

BZ
64 16..23

DatenSpeicher
SchreibDaten

Schreiben/ LeseLesen $X Daten $X Lesen $Y LeseDaten $Y

64

BefehlsSpeicher
Daten

32

8..15

Adr.

0..7
Adresse

LeseLesen $Z Daten $Z

64 64 64

LeseDaten

0 1

Abb. 85: Einfacher MMIX-Datenpfad

Die einzelnen Elemente dieses sog. Datenpfads sowie deren Zusammenwirken werden im Laufe der nchsten Kapitel erklrt werden. Nachdem wir verstanden haben, wie ein Prozessor (ein Datenpfad) auf Mikroarchitektur-Ebene funktioniert, 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 fr die Realisierung eines dieser Elemente als Logikschaltung ist der in nachstehender Abbildung angegebene Aufbau des Befehlszhlers.

D0 Q0

D1 Q1

BZ

D2 Q2

D63 Q63

Abb. 86: Aufbau des Befehlszhlers aus Logik-Gattern

1-66

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 kennengelernt haben und uns einen Eindruck davon verschafft haben, wie sich das Funktionsvermgen eines Prozessors aus Transistoren entwickeln lsst, zeigen wir kurz anhand der sog. Layout-Ebene, wie Transistoren auf einem Chip integriert werden knnen. Eine kleine Vorschau gibt das nachstehende Layout der bereits kennengelernten Implementierung eines NOR-Gatters:

VDD

Eingang 1

Ausgang 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 erfahren, wie man die Leistungsfhigkeit von Prozessoren messen und bewerten kann. Im Anschluss werden wir dieses Wissen anwenden, um in den Kapiteln Cache und Pipeline gngige Verfahren zur Leistungssteigerung von Prozessoren zu erarbeiten. Zunchst schlieen wir jedoch an die im Fach Grundlagen der Informatik kennengelernte Algorithmus- und Hochsprachen-Ebene an, indem wir die darunter liegende Assembler- und BefehlssatzEbene zunchst allgemein untersuchen. 1-67

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 As17 sembler-Befehle bersetzt. Programme knnen 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 bersetzen, die dann in einer Objektdatei abgelegt werden. Diese Nullen und Einsen sind die Schnittstelle zwischen Hard- und Software: Sie werden aus Assembler-Befehlen erzeugt, im Speicher abgelegt und dann bei der Ausfhrung von der Hardware interpretiert.

Im Folgenden ist nocheinmal die im vorigen Kapitel kennengelernte Rechner-Architektur abgebildet.

Daten-Speicher

Befehls-Speicher

Register Steuerwerk/ Leitwerk Rechenwerk/ ALU

Ein- und Ausgabe

c:\>

Prozessor
Abb. 89: Rechner-Architektur

Wie sieht diese Architektur auf Assembler- und Befehlssatzebene aus? Da die eben erwhnten 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 ntig sind, um die Hardware zu benutzen. Es gibt dabei drei verschiedene Arten von Anweisungen, die in Programmen zusammengefasst werden: Anweisungen fr den Prozessor, Anweisungen fr den Assembler und Anweisungen fr 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-1

2.2 Programme Programme bestehen aus Anweisungen fr den Prozessor, Anweisungen fr den Assembler und Answeisungen fr den Loader. 2.2.1 Anweisungen fr den Prozessor Prozessor-Anweisungen sind Befehle, die direkt vom Prozessor ausgefhrt werden. Im Gegensatz zu Befehlen einer Hochsprache wie z.B. C beziehen sie sich immer direkt auf die im Prozessor verfgbaren Ressourcen, sind also Anweisungen, um beispielsweise einen Wert von einer bestimmten Adresse 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 ausfhren kann, ist im Befehlssatz festgelegt. Der Befehlssatz ist dabei nichts anderes als eine Liste, in der alle Befehle des betreffenden Prozessors stehen fr jeden Befehl erklrt wird, was dieser Befehl eigentlich macht (z.B. zwei Zahlen addieren) angegeben ist, welche Operanden mit dem Befehl verwendet werden knnen + 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) fr Integer-Werte + Grundrechenarten fr Gleitkomma-Werte + Links- und Rechts-Schieben + Sprungbefehle (Befehle zur Steuerung des Kontrollflusses) + Bedingte Sprnge Sprung hngt von einer Bedingung ab, z.B. springe, wenn Wert in Register $1 Null ist Realisierung von ifthenelse-Konstrukten Realisierung von Schleifen + Unbedingte Sprnge es wird immer gesprungen, unabhngig von einer Bedingung Programmverzweigung Aufruf von Funktionen

2-2

Befehle fr 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 Ausgabegerten (z.B. Festplatte, CD-ROM, Tastatur etc.) wird in der Regel ber Speicherzugriffe realisiert Ein- und Ausgabegerten werden in einen bestimmten Speicherbereich des Prozessors eingeblendet Schreibzugriffe auf diese Speicheradresse landen dann bei dem jeweiligen Gert Lesezugriffe auf diese Speicheradressen lesen dann vom jeweiligen Gert Daten ein Register Ein Register ist ein spezieller, sehr schneller Datenspeicher, der genau ein Wort abspeichern kann und direkt im Prozessor untergebracht ist. Prozessoren verfgen 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 + knnen vom Programmierer beliebig verwendet werden als Quelloperanden fr beliebige Befehle als Zieloperanden fr 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 + knnen vom Programmierer nur im Zusammenhang mit dieser speziellen Funktion genutzt werden + werden oft dazu verwendet, um im Prozessor bestimmte Ablufe zu steuern (im Befehlszhler-Register steht beispielsweise immer die Adresse, von der der nchste Befehl geholt werden soll) bestimmte Einstellungen an der Hardware vorzunehmen (z.B. Festlegung der bertragungsgeschwindigkeit der seriellen Schnittstelle eines Mikrocontrollers) + knnen oft nur von bestimmten Befehlen gelesen oder geschrieben werden Spezialregister knnen also in der Regel nicht als Operanden fr ProzessorAnweisungen wie ADD etc. verwendet werden
18

Register werden in Prozessoranweisungen als Operanden verwendet und bei der Programmierung in Assembler-Code direkt angegeben. Dazu werden oft Buchstaben (zur Kennzeichnung eines bestimmten Registertyps) mit Zahlen (zur Kennzeichnung des Registers) kombiniert. fr Allzweckregister wird oft $0, $1, $2, oder R0, R1, R2, oder EAX, EBX, ECX, geschrieben, um die Allzweckregister mit der Nummer 0, 1, 2 zu bezeichnen

18

Ein Wort ist die Verallgemeinerung eines Bytes: Whrend ein Byte immer genau aus 8 Bit besteht, ist die Anzahl der Bits, die ein Wort bilden, nicht festgelegt. Ein Wort wird oft fr 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 knnen. Bei einem 32 Bit-Prozessor umfasst ein Halbwort somit 16 Bits und ein Doppelwort (DWORD) 64 Bits.

2-3

fr Spezialregister wird of rA, rB, rC, oder CR0, CR1, CR2, (CR fr Control Register) verwendet, oft werden aber auch bestimmte Namen wie z.B. IDTR fr Interrupt Descriptor Table Register verwendet

Unabhngig vom Typ des jeweiligen Registers knnen Registern bei der Programmierung benutzerdefinierte Namen zugewiesen werden, was dem Programmierer die Arbeit enorm vereinfachen kann. So lsst 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 ursprnglich mit dem Register $0 vorhatte. Arbeitsspeicher Der Arbeitsspeicher ist ein wesentlich langsamerer Speicher als es die Register sind, dafr lsst er sich wesentlich gnstiger herstellen. Aufgrund des sehr gnstigen Preis-Leistungs-Verhltnisses verfgen Computersysteme ber Arbeitsspeicher, dessen Speicherkapazitt die von Registern in der Regel um mehrere Grssenordnungen 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 19 Tabelle vorstellen: In jeder Tabellenzeile kann ein einzelnes Byte gespeichert werden, die Adresse des Bytes entspricht dabei der laufenden Nummer der Tabellenzeile.

Adresse 0x001 0x002 0x003 0x004 0x005 0x006 0x007 0x008 0x009 0x00A

Inhalt 0x12 0x34 0x56 0x78 0x90

jeweils 1 Byte

0xFFE 0xFFF

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 Mglichkeiten, 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 Binrzahlen (Basis 2) mglich ist (1 Stelle in der Basis 16 ergibt dann immer genau 4 Stellen in der Basis 2).

2-4

Allgemein unterscheidet man u.a. folgende Adressierungsarten:

Diese Adressierungsarten funktionieren fr beliebige Wortbreiten, also sowohl fr 8 Bit-, fr 16 Bit-, fr 32 Bit-, fr 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 gngige 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 hherwertigste 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;
Adresse Daten Big Endian Daten Little Endian

Computertechnik

0x00 0x01 0x02 0x0E 0x0F 0x10 0x11 0x12 0x13

C o m k \0 0x00 0x00 0x07 0xD4

C o m k \0 0xD4 0x07 0x00 0x00

2004

Abb. 90: Little- und Big-Endian Format

2-5

+ 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 mglich, 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 fr den Assembler Der Assembler ist das Programm, das Assembler-Programme in Nullen und Einsen bersetzt und diese in einer Objektdatei ablegt. Anweisungen fr den Assembler sind solche Befehle, die nicht direkt vom Prozessor ausgefhrt werden. Assembler Befehle werden entweder direkt vom Assembler verarbeitet + Beispiele hierfr ist die Angabe von Marken, an die whrend der Programmausfhrung hingesprungen werden kann SUB BZ Ziel DIV ADD $1,$2,$3 $1,Ziel $5,$3,$1 $2,$3,$4 Reg. $3 von $2 abziehen, Erg. nach $1 Nach Ziel springen, wenn $1 = 0, sonst mit nchster Zeile weitermachen Division wird in beiden Fllen ausgefhrt

+ diese Marken sind nicht Teil des Befehlssatzes, der vom Prozessor verarbeitet wird + die Marken werden whrend der Assemblierung (also whrend 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 Programms vom Loader (derjenige Betriebssystem-Teil, der Programme, die ausgefhrt werden sollen, in den Arbeitsspeicher ldt und initialisiert) interpretiert und ausgefhrt zu werden.

2.2.3 Anweisungen fr den Loader Loader-Befehle sind in der Objektdatei enthaltene Anweisungen, die den Loader (s.o.) beim Laden des Programms in den Arbeitsspeicher untersttzen. Beispiele hierfr 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 auszufhrenden Programms vom Betriebssystem Speicher fr globale und statische Variable allozieren (reservieren) und diesen dann mit den zugehrigen Werten initialisieren Die Loader-Befehle werden vom Betriebssystem interpretiert. Als Folge fhrt das Betriebssystem dann bestimmte Prozessor-Befehle aus, die die Funktion der Loader-Befehle implementieren.

2-6

2.3 Klassifizierung von Befehlsstzen In diesem Kapitel werden verschiedene Mglichkeiten angegeben, wie Befehlsstze klassifiziert werden knnen. Als Beispiel wird dabei stehts folgende Addition verwendet:
Operation

Zieloperand

A=B+C Quelloperanden

2.3.1

Klassifizierung nach der Anzahl der Operanden

Dreiadressmaschine die Maschinenbefehle sind so ausgelegt, dass alle drei Operanden explizit angegeben werden knnen 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 knnen 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 Ergebnis 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. Akkumulator-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-7

2.3.2

Klassifizierung nach der Bereitstellung der Operanden

Register-Register-Architektur (Load-Store-Architektur) bei der Ausfhrung 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 werden, d.h. es gibt z.B. keine arithmetischen Befehle, die als Operanden Arbeitspeicher-Adressen aufnehmen knnen Load-Store-Architektur Berechnung von A = B + C (vgl. auch nachfolgende Abbildung) Einlesen des Operanden B vom Arbeitsspeicher in Register $2 (1). b ist hierbei als diejenige Adresse anzusehen, an der der Wert des Operanden B steht, d.h. B == <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 analog zu vorher der Adresse von A entspricht

Load

$2,b

Register-Block

1 2 4

Arbeitsspeicher

3 3

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, mssen sie nicht erneut aus dem Arbeitsspeicher geladen werden, da sie sich bereits in Registern befinden Zeitvorteil je mehr Register ein Prozessor hat, desto seltener mssen Zugriffe auf den langsamen Arbeitsspeicher durchgefhrt werden! da im Beispiel-Code fr den Add-Befehl drei verschiedene Operanden angegeben werden knnen, spricht man hier auch von einer Dreiadress-Maschine, wobei der Begriff DreiadressMaschine nicht auf Register-Register-Architekturen beschrnkt ist

2-8

Register-Speicher-Architektur bei der Ausfhrung von Rechenoperationen befindet sich mindestens einer der Operanden im Arbeitsspeicher Beispielhafter Ablauf der Berechnung A = B + C (vgl. nachfolgende Abbildung)

Load Add

$1,b $1,c

Store $1,a

Einlesen des Operanden B vom Arbeitsspeicher (B steht an Adresse b) in Register $1 (1) Addieren von C (Wert an Adresse c im Arbeitsspeicher) zum Operanden B, also zum Register $1 Ergebnis steht dann auch in Register $1 (2) Abspeichern des Ergebnisses aus Register $1 in den Arbeitsspeicher an die Adresse a (3)
Register-Block Arbeitsspeicher

3 2 2 2

Abb. 92: Register-Speicher-Architektur

Vorteile gegenber Register-Register-Architektur 20 + weniger Load- und Store-Befehle notwendig weniger Zugriffe auf den Befehls-Speicher Programm wird krzer und bentigt weniger Speicherplatz Nachteile gegenber Register-Register-Architektur + soll das Ergebnis hier weiterverwendet werden, muss es erst wieder aus dem langsamen Arbeitsspeicher geladen werden mssen zur Durchfhrung von Operationen nur zwei Operanden angegeben werden (in obigem Beispiel-Code dient bei der Addition $1 sowohl als erster Quelloperand als auch als Zieloperand), spricht man von einer Zweiadress-Maschine, wobei dieser Begriff nicht auf RegisterSpeicher-Architekturen beschrnkt ist

20 Ist in Bezug auf die Ausfhrungsgeschwindigkeit 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 durchgefhrt wird oder implizit durch bspw. einen ADD-Befehl, ist egal. Speicherzugriff bleibt Speicherzugriff. Wesentlich mehr fllt 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-9

Akkumulator-Architektur Bei der Ausfhrung von Rechenoperationen befindet sich stets ein Operand im sog. Akkumulator-Register, weswegen dieser Operand nicht mehr adressiert werden muss es muss nur noch ein weiterer Operand angegeben werden Einadress-Maschine Ablauf der Befehlsausfhrung fr A = B + C (vgl. nachfolgende Abbildung)

Load Add

b Einlesen des Operanden B in das Akkumulator-Register (Datum B steht wieder an Adresse b) (1) 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)


Arbeitsspeicher

2 2 2
AkkumulatorRegister

1 3

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 Befehlsausfhrung (ausser zum Laden und Speichern) kein Operand angegeben werden Nulladress-Maschine Ablauf der Befehlsausfhrung von A = B + C (vgl. nachfolgende Abbildung)

Push b Push c Add Pop a

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

3
Register 2

3 3

Register 1

2 1 4

Abb. 94: Stack-Architektur

2-10

2.3.3

Klassifizierung nach der Mchtigkeit der einzelnen Befehle

CISC-Architektur CISC Complex Instruction Set Computer veraltetes Prozessor-Design Idee: fr jede bentigte Aufgabe gibt es einen speziellen Maschinenbefehl + sehr viele, mchtige Maschinenbefehle + Funktionalitt der Maschinenbefehle hnlich der von Hochsprachen-Befehlen + viele Adressierungsmodi Vorteile + Hochsprachen-hnliche Befehle einfache Programmierung (Compiler damals sehr schlecht, wenn berhaupt vorhanden) + mchtige Befehle geringe Programmgrsse grosser Vorteil, da Speicher damals sehr teuer und langsam Nachteile + viele Befehle mit unterschiedlicher Lnge des Befehlsworts kaum Fliessbandverarbeitung (Pipelining) mglich + wenige, dafr sehr lange Taktzyklen pro Befehl Befehle, die eigentlich in einem Bruchteil eines Taktzyklusses durchfhrbar wren, werden ausgebremst (allgemein kann pro Taktzyklus maximal ein Befehl ausgefhrt 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) bentigt werden + Ergebnisse es gibt ein paar wenige Befehle, die berproportional hufig verwendet werden gerade die sehr oft vorkommenden Befehle sind sehr einfacher Natur die extra fr aufwendige Berechnungen eingefgten Spezial-Befehle werden fast nie verwendet + Beispiel:

Rang 1 2 3 4 5 6 7 8 9 10

Befehlstyp Datum aus dem Arbeitsspeicher laden (load) Bedingte Verzweigung (conditional branch) Vergleich (compare) Datum in den Arbeitsspeicher bertragen (store) Addition (add) UND-Verknpfung (and) Subtraktion (sub) Datum von Register nach Register kopieren (move) Funktionsaufruf (call) Rcksprung (return) Summe:

Anteil % 22 % 20 % 16% 12 % 8% 6% 5% 4% 1% 1% 95 %

2-11

Idee: Quantitativer Ansatz + Befehlssatz auf die in der Analyse (s.o.) hufig vorkommenden Befehle beschrnken + Befehlssatz mit wenigen und sehr einfachen Befehlen + zur Lsung komplexerer Probleme einfach mehrere einfache Befehle verwenden Baukasten-Prinzip (zuvor bei CISC: komplexes Problem ein sehr mchtiger Befehl) + Auslagerung der Lsung komplexerer Probleme von der Hardware in den Compiler (in die Software) Vorteile + Baukastenprinzip Verlagerung von Befehls-Optimierungen von der Hardware in die Software Compiler-Technologie mittlerweile besser Programmierer schreibt Programm mit wenigen Hochsprachen-Befehlen und der Compiler bersetzt diese Befehle dann in viele, dafr sehr schnelle Maschinen-Befehle wenn neue, verbesserte Algorithmen fr die Lsung eines Problems gefunden werden, muss nicht mehr die Implementierung des komplexen CISC-Befehls im Prozessor gendert werden, sondern lediglich der Compiler (Software ist wesentlich einfacher nderbar als Hardware!) + wenige, sehr einfache Befehle Steigerung der Zuverlssigkeit des Chips, da weniger Fehlerquellen (damals sehr wichtig) einheitliches Befehlsformat, insbesondere konstante Befehlslnge mglich ermglicht sehr einfache Hardware, da alle Befehle sehr hnlich behandelt werden einfache Hardware mehr Spielraum fr Parallelverarbeitung einfache Realisierung der Fliessbandverarbeitung alle Befehle zeitlich ungefhr gleich lang kein Zeitverlust durch Warten auf komplexe, langsame Befehle hoher Gewinn bei der Fliessband-Verarbeitung Nachteile Hherer Speicherbedarf fr das Programm Programmgrsse 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

21

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

2-12

VLIW-Architektur Name: VLIW Very Long Instruction Word Prozessor mit sehr langem Befehlswort Idee: RISC-Konzept auf Parallel-Verarbeitung bertragen Prozessor hat mehrere Ausfhrungseinheiten (AF), so dass er bspw. zwei Integer- und eine Gleitkomma-Operation gleichzeitig durchfhren kann Compiler bzw. Assembler + gruppiert die in einem Programm vorhandenen sequentiellen Befehle so, dass mglichst 22 immer alle Ausfhrungseinheiten (AE) Arbeit haben + fasst die gruppierten Befehle zu einem langen Befehlswort zusammen, dass dann vom Prozessor parallel ausgefhrt wird

Programm (mehrere Befehle)

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

bersetztes Programm (mehrere Befehlsworte)

0x20010203 0x060A0807 0x24050904

1 langes Befehlswort fr VLIW-Architektur

0x2001020324050904060A0807

Prozessor mit 3 Ausfhrungseinheiten (AF) (2 x Integer, 1 x Gleitkomma)

AE 1 (Int)

AE 2 (Int)

AE 3 (GK)

Abb. 95: VLIW-Konzept

Vorteile + Optimierungen einfach durchfhrbar, da nur der Compiler/Assembler und nicht der Prozessor gendert werden muss (vgl. RISC-Architektur) + keine grosse Zunahme der Prozessor-Komplexitt, da viel Intelligenz im Compiler steckt Geschwindigkeitsvorteil bei der Programmausfhrung Prozessor kann gnstiger hergestellt werden Nachteile + Code muss neu bersetzt werden + Code-Kompatibilitt geht verloren

22 Ausfhrungseinheit: Derjenige Teil eines Prozessors, der Berechnungen durchfhrt. VLIW-Architekturen verfgen ber mehrere Ausfhrungseinheiten, die parallel betrieben werden knnen.

2-13

2.3.4

Klassifizierung nach Orthogonalitt

Orthogonaler Befehlssatz die einzelnen Befehle sind ihrer Funktionalitt nach vollkommen disjunkt. Es gibt also keine Befehle, die sich in ihrer Funktionalitt berlappen. 2.4 Performance auf Assembler- bzw. Befehlsatz-Ebene 2.4.1 Begriff "Performance"

Performance = Leistung =

Arbeit Zeit

Arbeit beim Computer: Programmausfhrung Abarbeitung aller Befehle des Programms Zeit beim Computer: Programmausfhrungs-Zeit Leistungsvergleich meherer Systeme am einfachsten, wenn

Arbeit = konst. Performance


(je schneller, desto besser)

1 Programmausfhrungs-Zeit

2.4.2

Entstehung der Programmausfhrungs-Zeit

Abbildung der Hochsprache auf Maschinen-Code + 1 Taktzyklus + 1 Speicherzugriff

Hochsprache
a = b (d + c)*a

Compiler

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

Assembler

Maschinen-Code
0x8D010600 0x20050403 0x18050501 0x24010205 0xAD010600 10001101000000010000011000000000 00100000000001010000010000000011 00011000000001010000010100000001 00100100000000010000001000000101 10101101000000010000011000000000 + 10 +

2-14

Speicherzugriffszeit Anzahl der Speicherzugriffe Zyklusdauer ( CPI i Befehlsanzahl i ) + Zyklusdauer alle Befehle i Anzahl der Gesamtzyklen des Programms
Programmausfhrungs-Zeit:

CPI = Cylces per instruction Zyklusdauer

Taktzyklen Befehl

2 Prozessortakt

Zyklusdauer

2.4.3

Performance-Messung

In der Regel relative Performance-Messung + Vergleich mehrerer Systeme + Bestimmung der Leistungserhhung eines Systems nach einer Modifikation Selbes Programm auf mehreren Rechnern + Arbeit = konst. + Performance ~ Ausfhrungs-Geschwindigkeit Idealfall: Ein Benutzer, der immer nur dasselbe Programm verwendet + Ausfhrungszeit auf mehreren Systemen bestimmen + Schnellster Rechner ist fr den Benutzer dann der Beste Realitt: 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 mglichst gut reprsentieren sollen Einteilung von Benchmarks:

2-15

Benchmarks

Synthetische Benchmarks

Nicht synthetische (echte) Benchmarks

Programme, die extra fr die Verwendung als Benchmark geschrieben wurden.

Reale Programme, die als Benchmark ausgewhlt wurden.

Vorteil synthetischer Benchmarks: Kurze Codesequenzen mglich Einfache Optimierung von Rechnerarchitektur und Compiler Zu Design-Beginn (noch kein Compiler verfgbar) einfach per Hand codierbar Nachteil: Ausschliessliche Optimierung der in Benchmarks enthaltenen Befehlsfolgen fhrt aufgrund der geringen Benchmark-Lnge zu einem hohen prozentualen Anteil der optimierten Befehle und somit zur Verzerrung der Leistungsdarstellung

Arten der Programmausfhrungszeit

Antwortzeit BS Benutzer-CPU-Zeit Benutzer-CPU-Zeit + Betriebssystem (BS) -CPU-Zeit Start P1 BS P2 BS P1 BS P1 BS BS Ende P1 BS

+ Antwort-Zeit Vom Benutzer wahrgenommene Zeit Quasi-paralleler Ablauf von Programmen keine Eignung zur PerformanceBestimmung + Benutzer-CPU-Zeit Nur ungenaue Messung der vom Betriebssystem verbrauchten Zeit mglich Unterschiedliche Betriebssysteme Messung unterschiedlicher Programmlngen Arbeit nicht konstant! + Benutzer-CPU-Zeit + Betriebssystem-CPU-Zeit Vorteil: Zugehrigkeit von Programmteilen zum Betriebssystem z.T. schwer bewertbar

2-16

Definition + System-Performance: Auf unbelastetem System vergangene Zeit + CPU-Performance: Benutzer-CPU-Zeit Zeitmessung + Ausfhrungs-Zeit eines Programms = (

alle Befehle i Anzahl der Gesamtzyklen desProgramms

CPI i Befehlsanzahl i ) Zyklusdauer

+ Parameterbestimmung Zyklusdauer: Dokumentation des Sytems (z.B. 2,4 GHz Zyklusdauer = CPIi Befehlssatz des Prozessors Dokumentation Problem: Nicht konstant bei Verwendung von Pipelining und Cache Abhilfe: Simulation, HW-Zhler Befehlsanzahli Software-Tools (Profiling) HW-Zhler auf CPU

1 ns) 2,4

MIPS: Million instructions per second: Kein geeignetes Performance-Ma, da keine Aussage ber die Mchtigkeit der Befehle gemacht wird (Arbeit unbekannt Keine Aussage ber die Leistung mglich) MFLOPS: Million floating point operations per second: Aus den 1970/80-er Jahren; Nachteil wie MIPS
2.4.4 Gesetz von Amdahl

Erhhung der Performance durch Verbesserung einer bestimmten Eigenschaft ist durch die Anzahl der Verwendungen dieser Eigenschaft beschrnkt Beispiel: Programmaufhrungszeit betrgt 10 Sekunden, 2 Sekunden davon entfallen auf Speicherzugriffe
Durch Optimierung des Speichersystems knnen maximal 2 Sekunden Programmausfhrungszeit 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 schlgt sich nicht direkt proportional in der Verbesserung der Performance des Gesamtsystems nieder + Umkehrschluss

Verbesserung des hufig vorkommenden Falls um einen bestimmten Faktor ergibt einen hheren Performance-Gewinn als die Verbesserung des nicht so hufig vorkommenden Falls (make the common case fast).

2-17

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 fr Mathematik am California Institute of Technology (Caltech) bis 1968 + ab 1968 Professor fr Computertechnik (computer science) und Elektrotechnik in Stanford + 25 Ehrendoktor-Titel + ist insbesondere durch seine 3 Bcher The Art of Computer Programming bekanntgeworden, die unter anderem neben den Bchern Einsteins und Mandelbrots zu den wichtigsten wissenschaftlichen Bchern des (letzten) Jahrhunderts gezhlt werden + 4. Teil der Reihe The Art of Computer Programming gerade in Arbeit + hat aufgrund seiner Unzufriedenheit mit der typografischen Gestaltung seiner ersten Bcher TEX erfunden, was ihn eigenen Angaben nach 12 Jahre lang von seinem eigentlichen Ziel, der Analyse und Darstellung von Algorithmen, abgehalten hat + MIX rmische 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 fr die Analyse von Algorithmen in The Art of Computer Programming entwickelt hat + MMIX rmische 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 Bnde 4-6 der Reihe The Art of Computer Programming beschreibt + mehr unter www-cs-faculty.stanford.edu/~knuth/

Abb. 96: Donald E. Knuth

3-1

MMIX ist ein Prozessor-Modell + nicht real existent keine legacy-Effekte, d.h. keine unsaubere (und damit schwer verstndliche) Architektur aufgrund von Rckwrtskompatibilitten + fr Lehr- und Forschungszwecke + sehr einfach, da extrem regulr + Software-Simulations-Tools verfgbar Praktikum + gcc-Compiler verfgbar

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 Stck) Adressierbarer Speicherbereich: 264 Byte 256 Befehle, die zumeist nur 1 Takt bentigen
Spezialregister
PUT

Allzweckregister
Laden

Arbeitsspeicher

GET

Speichern

$X

$Y

$Z

Abb. 97: MMIX-Prozessor

3.2.2

Register

Allzweckregister (GPR = General Purpose Register) 256 Stck (0255) 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 enthlt 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-2

+ 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. fr Unterprogramme verwendet 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)
$255
globale Register

rG

marginale Register

rL
lokale Register

$0
Abb. 98: Allzweckregister beim MMIX

Spezialregister beim MMIX 32 Stck vorhanden knnen nur ber die MMIX-Befehle PUT und GET angesprochen werden (vgl. Kap. 2.8.13) Ermglichen die Steuerung/Konfiguration bestimmter Prozessor-Eigenschaften (z.B. Freischalten bestimmter Interrupts) Melden dem Benutzer das Auftreten bestimmter Ereignisse (z.B. Division durch Null, berlauf etc.)

3-3

3.2.3

Speicherorganisation

Der Adressbereich des MMIX ist in mehrere Segmente aufgeteilt.

0x0000000000000000 = Text_Segment 0x00000000000000FF 0x0000000000000100

InterruptVektoren TextSegment Programm

0x1FFFFFFFFFFFFFFF 0x2000000000000000 = Data_Segment


Datensegment

0x3FFFFFFFFFFFFFFF 0x4000000000000000 = Pool_Segment


Poolsegment

0x5FFFFFFFFFFFFFFF 0x6000000000000000 = Stack_Segment


Stacksegment

0x7FFFFFFFFFFFFFFF 0x8000000000000000

Fr Betriebssystem reserviert

0xFFFFFFFFFFFFFFFF
Abb. 99: Speicherorganisation beim MMIX-Prozessor

3-4

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 23 + sollte Sprung in den Trip-Handler beinhalten
Adresse 0x00 0x04 0x08 0x0C 0x10 0x14 0x18 0x1C 0x20 0x24 0x28 0x2C 0x30 0x34 0x38 0x3C 0x40 0x44 0x48 0x4C 0x50 0x54 0x58 0x5C 0x60 0x64 0x68 0x6C 0x70 0x74 0x78 0x7C 0x80 0x84 0x88 0x8C Inhalt
Sprung in Trip-Handler fr allgemeine Trips

Sprung in Trip-Handler fr Division durch Null

Sprung in Trip-Handler fr Integerberlauf

Sprung in Trip-Handler fr berlauf bei GK-FK-Wandlung

Sprung in Trip-Handler fr ungltige GK-Operation

Sprung in Trip-Handler fr GK-berlauf

Sprung in Trip-Handler fr GKUnterlauf

Sprung in Trip-Handler fr GK-Divison durch Null

Sprung in Trip-Handler fr GK-Zahl ungenau

Abb. 100: Interruptvektoren im Textsegment

Datensegment dient zur Aufnahme der verwendeten Variablen, die beginnend bei 0x200 in Richtung steigender Adressen abgelegt werden nimmt bei uns beginnend bei 0x3FF8 in Richtung fallender Adressen den Stack auf

23

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

3-5

Poolsegment dient zur Kommunikation zwischen Betriebssystem und Anwendungsprogramm nimmt Aufrufparameter fr das Programm und Ergebnisse des Programms auf + Register $0 enthlt beim Programmstart die Anzahl der bergebenen Argumente (argc = argument count) + Register $1 enthlt beim Programmstart einen Zeiger auf eine Zeigerliste im Poolsegment (argv = argument vector) + Zeigerliste ist mit Nullzeiger abgeschlossen + Zeigerliste enthlt Zeiger auf Speicherbereiche im Poolsegment, in denen die einzelnen Argumente als 0-terminierter String abgelegt sind

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


$0 enthlt den Wert 0x0A, da 10 Argumente bergeben werden $1 enthlt beim Start 0x4000000000000008 Startadresse im Poolsegment das Poolsegment sieht dann wie folgt aus:
Adresse Wert (hex) Wert (ascii)

0x4000000000000000 0x4000000000000008 0x4000000000000010 0x4000000000000018 0x4000000000000020 0x4000000000000028 0x4000000000000030 0x4000000000000038 0x4000000000000040 0x4000000000000048 0x4000000000000050 0x4000000000000058 0x4000000000000060 0x4000000000000068 0x4000000000000070 0x4000000000000078 0x4000000000000080 0x4000000000000088 0x4000000000000090 0x4000000000000098 0x40000000000000a0 0x40000000000000a8 0x40000000000000b0 0x40000000000000b8

0x40000000000000b8 0x4000000000000060 0x4000000000000070 0x4000000000000078 0x4000000000000080 0x4000000000000088 0x4000000000000090 0x4000000000000098 0x40000000000000a0 0x40000000000000a8 0x40000000000000b0 0x0000000000000000 0x736b616c70726f64 0x6172670000000000 0x3400000000000000 0x3100000000000000 0x3200000000000000 0x3300000000000000 0x3400000000000000 0x3130000000000000 0x3230000000000000 0x3330000000000000 0x3430000000000000 0x0000000000000000

@ @ @ @ @ @ @ @ @ @ @ \0 s a 4 1 2 3 4 1 2 3 4 \0

\0 \0 \0 \0 \0 \0 \0 \0 \0 \0 \0 \0 k r \0 \0 \0 \0 \0 0 0 0 0 0

\0 \0 \0 \0 \0 \0 \0 \0 \0 \0 \0 \0 a g \0 \0 \0 \0 \0 \0 \0 \0 \0 \0

\0 \0 \0 \0 \0 \0 \0 \0 \0 \0 \0 \0 l \0 \0 \0 \0 \0 \0 \0 \0 \0 \0 \0

\0 \0 \0 \0 \0 \0 \0 \0 \0 \0 \0 \0 p \0 \0 \0 \0 \0 \0 \0 \0 \0 \0 \0

\0 \0 \0 \0 \0 \0 \0 \0 \0 \0 \0 \0 r \0 \0 \0 \0 \0 \0 \0 \0 \0 \0 \0

\0 \0 \0 \0 \0 \0 \0 \0 \0 \0 \0 \0 o \0 \0 \0 \0 \0 \0 \0 \0 \0 \0 \0

` p x \0 d \0 \0 \0 \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 Registerstack verdrngten Register automatisch ausgelagert mit dem MMIX-Befehl POP werden die zuvor vom Registerstack in das Stacksegment ausgelagerten Register von dort wieder in die entsprechenden Register zurckgeschrieben wird bei uns nicht verwendet, da wir den Stack selber verwalten Fr Betriebssystem reservierter Bereich Fr Programmierer nicht erreichbar geschtzter Speicherbereich wird von uns nicht verwendet

3-6

3.2.4

Speicher-Zugriffsarten

Beim MMIX-Prozessor sind Speicherzugriffe auf 4 verschiedene Wortbreiten mglich:


Byte-Zugriff + Zugriff auf jedes einzelne im Speicher abgelegte Byte mglich (vgl. in nachfolgender Abbildung, Spalte Byte) + es knnen 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, weshalb 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 Zugriffsadresse 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 0...0 0...0 0...0 0...0 0...0 0...0 0...0 0...0 0...0 0...0 0...0 0...0 0...0 0...0 0...0 0...0 0...0 0...0 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0001 0001 0000 0001 0010 0011 0100 0101 0110 0111 1000 1001 1010 1011 1100 1101 1110 1111 0000 0001 Byte Wyde Tetra Octa

1...1 1...1 1...1 1...1 1...1

1111 1111 1111 1111 1111

1011 1100 1101 1110 1111

Abb. 102: Mgliche Speicherzugriffe beim MMIX-Prozessor

3-7

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 getrennt sind.
Marke + dient zum Verweis auf die aktuelle Programmzeile 24 + ist optional , muss also nicht mit angegeben werden Befehlscode (Operationscode, Opcode): der MMIX-Befehl, der ausgefhrt werden soll Operanden: Operanden des MMIX-Befehls; 4 Mglichkeiten + 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 spteren Betrachten des geschriebenen Programms wieder daran zu erinnern, was man mit der betreffenden Code-Zeile eigentlich wollte + ist optional

Marke

Befehlscode

Operanden

Kommentar

[Marke]

LZ

Befehlscode

LZ

$X

$Y

$Z

[LZ

Kommentar]

[Marke]

LZ

Befehlscode

LZ

$X

$Y

[LZ

Kommentar]

[Marke]

LZ

Befehlscode

LZ

$X

YZ

[LZ

Kommentar]

[Marke]

LZ

Befehlscode

LZ

XYZ

[LZ

Kommentar]

Abb. 103: MMIX-Befehlsformat

Beispiel fr einen MMIX-Befehl:

Marke

Befehlscode Operanden Kommentar

Addiere ADD $1,$2,$3 Register $1=$2+$3 ADD $1,$2,$3 geht auch ohne Marke % // diese Zeile ist ein Kommentar diese auch

24

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

3-8

Bedeutung des Befehls: Nehme den Inhalt von Register $2, addiere ihn zum Inhalt von Register $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 GREG N ADR_A1 OCTA OCTA OCTA OCTA OCTA OCTA OCTA OCTA OCTA IS IS IS IS IS IS LOC Main SETL LDA LDA LDO MUL BZ SUB LDO LDO MUL ADD JMP TRAP Data_Segment @ 4 1 2 3 4 10 20 30 40 $1 $2 $3 $4 $5 $6 #100 x,0 u,ADR_A1 v,ADR_B1 w,N w,w,8 w,Ende w,w,8 y,u,w z,v,w y,y,z x,x,y Start 0,Halt,0 01 02 03 Vektordimension 04 a1 05 a2 06 a3 07 a4 08 b1 09 b2 10 b3 11 b4 12 13 Fr Parameter 1 14 Fr Parameter 2 15 Fr Parameter 3 16 Fr das Ergebnis 17 Fr Zwischenberechnungen 18 Fr Zwischenberechnungen 19 20 21 22 23 Initialisierung 24 Referenz auf a1 in u speichern 25 Referenz auf b1 in v speichern 26 Vektordimension laden 27 verwendete Worte haben 8 Byte 28 wenn fertig -> Ende 29 w = w 8 30 y = <u + w> 31 z = <v + w> 32 y = <u + w> * <v + w> 33 x = x + <u + w> * <v + w> 34 35 36 Ergebnis steht in x 37

ADR_B1

u v w x y z

Start

Ende

3-9

3.4 Befehlstypen 3.4.1 MMIX-Befehlssatz

sind Befehle, die vom MMIX-Prozessor ausgefhrt werden werden vom Assembler jeweils in eine 32 Bit-Zahl (8 Bit Befehlscode + 24 Bit Operanden) bersetzt werden zur Laufzeit vom Prozessor ausgefhrt werden im nchsten Kapitel tabellarisch angegeben Beispiel: ADD $1,$2,$3, SETL x,0, LDA u,ADR_A1 etc.
25

3.4.2

Loader -Befehle

sind Befehle, die vom Loader beim Laden des Programms in den Arbeitsspeicher ausgefhrt werden werden vom Assembler bei der bersetzung in sog. Loader-Opcodes bersetzt und in die Objektdatei (ausfhrbare Binrdatei) geschrieben, so dass sie dann beim Laden des Programms vom Loader interpretiert und ausgefhrt werden knnen dienen dazu, dem Loader mitzuteilen, an welcher Stelle im Arbeitsspeicher er welche Daten ablegen soll + Beispiel: LOC Data_Segment LOC #2000000000000000 (vgl. Zeile 1) LOC steht fr 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, ermglicht der LOCBefehl 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 MMIXBefehle dann vom Loader der Reihe nach ab Adresse 0x100 im Arbeitsspeicher abgelegt werden + Beispiel: ADR_A1 OCTA 1 (vgl. Zeile 5) 26 weist den Loader an, an der Speicherstelle 0x2000000000000008 ein 8 Byte grosses Speicherwort zu reservieren und mit dem Wert 1 vorzubelegen die vor den Befehl OCTA geschriebene Marke ADR_A1 ermglicht, dass die Speicherstelle 0x2000000000000008 auch ber die Marke ADR_A1 angesprochen werden kann die Marke wird dann vom Assembler whrend der bersetzung in die entsprechende Adresse umgewandelt

25 Der Loader (auch Lader genannt) ist dasjenige Programm im Betriebssystem, das eine bersetzte, ausfhrbare Binrdatei im Arbeitsspeicher ablegt, so dass diese dort ausgefhrt werden kann. Die Binrdatei enthlt dabei Informationen darber, 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 LoaderBefehl, der ein Register vorbelegt und bentigt damit keinen Platz im Arbeitsspeicher. Die nchste 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 nchste freie Speicherstelle an Adresse 0x2000000000000008.

3-10

3.4.3

Assembler-Befehle

sind Befehle bzw. Hinweise, die der Assembler whrend der bersetzung auswertet werden nicht vom Prozessor ausgefhrt! dienen in erster Linie dazu, dem Programmierer das Leben zu erleichtern + ermglichen, dass Register mit Namen angesprochen werden knnen Beispiel: ADD x,x,y (vgl. Zeile 34) statt ADD $4,$4,$5 x IS $4 (vgl. Zeile 17) fhrt dazu, dass man statt $4 auch x schreiben kann vor der Assemblierung ersetzt der Assembler dann x wieder durch $4 (Prprozessor) vgl. in C: #define x $4 + ermglichen, dass Stellen im Programm ber Marken angesprochen werden knnen Adressrechnung durch Assembler weitere Erleichterung Beispiel: BZ w,Ende (vgl. Zeile 29) statt BZ w,7 + ermglichen, dass auch Stellen im Datenspeicher ber Marken angesprochen werden knnen Benutzung der Marken wie Variablennamen Adressrechung ebenfalls durch Assembler Erleichterung fr 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 Lsung: Adresse ber Basisregister adressieren 27 Der 2. Operand ($Y) des LDO-Befehls gibt ein Basisregister 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 (0255) 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 Assembler-Befehlen zu Assembler-Direktiven zusammengefasst.

Als Basisregister dienen hier die globalen MMIX-Register. Da die Anweisung GREG Ausdruck ein neues globales Register 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).

27

3-11

Nachfolgend abgebildete Tabelle listet die Assembler-Direktiven auf:


Befehl
LOC IS GREG Ausdruck Ausdruck 1, Reserviert fr jeden Ausdruck eine Ausdruck 2, 1 Byte groe Speicherzelle und ... initialisiert diese mit Ausdruck Ausdruck n Ausdruck 1, Reserviert fr jeden Ausdruck eine Ausdruck 2, 2 Byte groe Speicherzelle und ... initialisiert diese mit Ausdruck Ausdruck n

Operanden
Ausdruck

Wirkung
@=Ausdruck Ausdruck1 IS Ausdruck2

Erluterung
Legt die Adresse fest, ab welcher der nachfolgende Assembler-Code in den Speicher eingetragen werden soll Bei der Assemblierung wird Ausdruck1 durch Ausdruck2 ersetzt Reserviert ein neues globales Register und initialisiert es mit Ausdruck Anstelle der Angabe einzelner durch Kommas getrennter Bytewerte kann eine in Anfhrungszeichen stehende Zeichenkette verwendet werden.

BYTE

WYDE

Ausdruck 1, Reserviert fr jeden Ausdruck eine Ausdruck 2, TETRA 4 Byte groe Speicherzelle und ... initialisiert diese mit Ausdruck Ausdruck n Ausdruck 1, Reserviert fr jeden Ausdruck eine Ausdruck 2, 8 Byte groe Speicherzelle und ... initialisiert diese mit Ausdruck Ausdruck n Weist den Assembler an, nach der Assemblierung eine Fehlermeldung auszugeben, wenn der Wert von rG nicht grer 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 wird Beendet den durch BSPEC angefangenen Abschnitt Begin special mode: Kann beispielsweise von einem Compiler dazu verwendet werden, Debug-Informationen wie Zeilennummern o.. in die Objektdatei mit einzufgen. End special mode

OCTA

LOCAL

BSPEC Ausdruck

ESPEC

3-12

3.5

Befehlssatz

In diesem Kapitel werden die wichtigsten der insgesamt 256 MMIX-Befehle beschrieben. Weniger oft bentigte 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 + BZ $1,#2048

$X = $5, $Y = $8 und Z = 2 $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 gespeichert werden soll, entsprechen also einer Art Zieloperand + Grund fr Addition der Operanden kann auf diese Weise das selbe Rechenwerk wie fr die Addition verwendet werden einfachere, regulrere und billigere Hardware

3-13

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 LDB LDBU LDW LDWU LDT LDTU LDO LDOU LDHT

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,Label

Wirkung $X=s(M1[$Y+$Z]) $X=s(M1[$Y+Z]) $X=M1[$Y+$Z] $X=M1[$Y+Z] $X=s(M2[$Y+$Z]) $X=s(M2[$Y+Z]) $X=M2[$Y+$Z] $X=M2[$Y+Z] $X=s(M4[$Y+$Z]) $X=s(M4[$Y+Z]) $X=M4[$Y+$Z] $X=M4[$Y+Z] $X=M8[$Y+$Z] $X=M8[$Y+Z] $X=M8[$Y+$Z] $X=M8[$Y+Z] $X=(M4[$Y+$Z]<<32) $X=(M4[$Y+Z]<<32) $X=Label $X=GK64(GK32(M4[$Y+$Z])) $X=GK64(GK32(M4[$Y+Z]))

Erluterung Load byte: VZ-behaftetes Laden eines Bytes; obere 7 Byte mit VZ aufgefllt Load byte unsigned: VZ-loses Laden eines Bytes; obere 7 Byte mit 0 aufgefllt Load wyde: VZ-behaftetes Laden eines Wydes; obere 6 Byte mit VZ aufgefllt Load wyde unsigned: VZ-loses Laden eines Wydes; obere 6 Byte mit 0 aufgefllt Load tetra: VZ-behaftetes Laden eines Tetras; obere 4 Byte mit VZ aufgefllt Load tetra unsigned: VZ-loses Laden eines Tetras; obere 4 Byte mit 0 aufgefllt Load octa: Laden eines Octas Load octa unsigned: Laden eines Octas; kein Unterschied zu LDO Load high tetra: Laden eines Tetras in die linke Hlfte von $X; rechts mit 0 aufgefllt Load address: Ldt die durch Label gekennzeichnete Adresse in Register X; wird vom Assembler durch ADDU ersetzt Load short float: Interpretiert den Inhalt einer 32-Bit-Speicherzelle als 32-Bit-GK-Zahl, konvertiert diese in eine 64-Bit-GK-Zahl und ldt diese in Register X Load octa uncached: Wie LDO, informiert das System jedoch darber, dass der Wert und die Werte der angrenzenden Speicherzellen in nchster Zukunft nicht mehr bentigt werden und somit nicht in den Cache geladen werden mssen (Cache bypassing) Store byte: Schreibt ein Byte in den Speicher; berlauf, wenn -128 > $X >127 Store byte unsigned: Schreibt ein Byte in den Speicher; kein berlauf mglich Store wyde: Schreibt ein Wyde in den Speicher; berlauf mglich Store wyde unsigned: Schreibt ein Wyde in den Speicher; kein berlauf mglich Store tetra: Schreibt ein Tetra in den Speicher; berlauf mglich

LDA

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

$X,$Y,$Z LDUNC $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=M8[$Y+$Z]

$X=M8[$Y+Z] M1[$Y+$Z]=$X M1[$Y+Z]=$X M1[$Y+$Z]=$X mod 0x100 M1[$Y+Z]=$X mod 0x100 M2[$Y+$Z]=$X M2[$Y+Z]=$X M2[$Y+$Z]=$X mod 0x10000 M2[$Y+Z]=$X mod 0x10000 M4[$Y+$Z]=$X M4[$Y+Z]=$X

STB STBU STW STWU STT

3-14

$X,$Y,$Z STTU $X,$Y,Z STO STOU STCO $X,$Y,$Z $X,$Y,Z $X,$Y,$Z $X,$Y,Z X,$Y,$Z X,$Y,Z $X,$Y,$Z STHT $X,$Y,Z $X,$Y,$Z STSF $X,$Y,Z

M4[$Y+$Z]=$X mod 0x100000000 M4[$Y+Z]=$X mod 0x100000000 M8[$Y+$Z]=$X M8[$Y+Z]=$X M8[$Y+$Z]=$X M8[$Y+Z]=$X M8[$Y+$Z]=X M8[$Y+Z]=X M4[$Y+$Z]=$X>>32 M4[$Y+Z]=$X>>32 M4[$Y+$Z]=GK32(GK64($X)) M4[$Y+Z]=GK32(GK64($X))

Store tetra unsigned: Schreibt ein Tetra in den Speicher; kein berlauf mglich Store octa: Schreibt ein Octa in den Speicher Store octa unsigned: Schreibt ein Octa in den Speicher; kein Unterschied zu STO Store constant octabyte: Schreibt das Byte X als VZ-loses Octa in den Speicher Store high tetra: Schreibt die obere Hlfte von Register X nach M4[$Y+$Z] bzw.

M4[$Y+Z]
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 Store octa uncached: Wie STO, informiert das System jedoch darber, dass der Wert und die Werte der angrenzenden Speicherzellen in nchster Zukunft nicht mehr bentigt werden und somit nicht im Cache gehalten werden mssen

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

M8[$Y+$Z]=$X

M8[$Y+Z]=$X

3.5.3

Laden von Registern mit Direktoperand


Operanden $X,YZ $X=YZ $X=(YZ<<16) $X=(YZ<<32) $X=(YZ<<48) $X=($X+YZ) mod 264 $X=($X+(YZ<<16)) mod 264 $X=($X+(YZ<<32)) mod 264 $X=($X+(YZ<<48)) mod 264 Wirkung Erluterung Set to low wyde: Setzt Bits 015 in Register X auf YZ; restliche Bits 0 Set to medium low wyde: Setzt Bits 1631 in Register X auf YZ; restliche Bits 0 Set to medium high wyde; Setzt Bits 3247 in Register X auf YZ; restliche Bits 0 Set to high wyde: Setzt Bits 4864 in Register X auf YZ; restliche Bits 0 Increase by low wyde: YZ mit $X VZ-los addieren Increase by medium low wyde: YZ um 16 nach links, dann VZ-lose Addition mit $X Increase by medium high wyde: YZ um 32 nach links, dann VZ-lose Addition mit $X Increase by high wyde: YZ um 48 nach links, dann VZ-lose Addition mit $X

Befehl SETL

SETML $X,YZ SETMH $X,YZ SETH INCL $X,YZ $X,YZ

INCML $X,YZ INCMH $X,YZ INCH $X,YZ

3-15

3.5.4

Arithmetische Operationen
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 Wirkung $X=$Y+$Z $X=$Y+Z $X=($Y+$Z) mod 264 $X=($Y+Z) mod 264 $X=(2$Y+$Z) mod 264 $X=(2$Y+Z) mod 264 $X=(4$Y+$Z) mod 264 $X=(4$Y+Z) mod 264 $X=(8$Y+$Z) mod 264 $X=(8$Y+Z) mod 264 $X=(16$Y+$Z) mod 264 $X=(16$Y+Z) mod 264 $X=f($Y)+f($Z) $X=$Y-$Z $X=$Y-Z $X=($Y-$Z) mod 264 $X=($Y-Z) mod 264 Erluterung Add: Addition im 2er-Komplement; berlauf wenn Summe 263 oder < 263 Add unsigned: Addition (im 2erKomplement) ohne berlauf Times 2 and add unsigned: Wie ADDU, jedoch Register Y zuerst mit 2 multipliziert Times 4 and add unsigned: Wie ADDU, jedoch Register Y zuerst mit 4 multipliziert Times 8 and add unsigned: Wie ADDU, jedoch Register Y zuerst mit 8 multipliziert Times 16 and add unsigned: Wie ADDU, jedoch Register Y zuerst mit 16 multipliziert Floating add: GK-Addition; Invalid-Exception bei - oder - + Subtract: Subtraktion; berlauf wenn Ergebnis 263 oder < 2-63 Subtract unsigned: Subtraktion ohne berlauf Floating subtract; GK-Subtraktion; Invalid-Exception bei - oder - + Negate: Negation; berlauf, wenn Ergebnis 263; Y = 0 nur, wenn $Z = -263 Negate unsigned: Negation ohne berlauf Multiply: VZ-behaftetes Produkt; berlauf wenn Produkt < -263 oder 263 Multiply unsigned: Produkt-Bits [12764] nach rH, Produkt-Bits [630] nach $X Floating Multiply: Multiplikation zweier GKZahlen; Invalid-Exception bei (0.0)() Divide: Vorzeichenbehaftete Division; Dividend in $Y, Divisor in $Z, Quotient in $X, Rest in rR

Befehl ADD ADDU 2ADDU 4ADDU 8ADDU 16ADDU FADD SUB SUBU FSUB NEG NEGU MUL MULU FMUL

$X,$Y,$Z $X=f($Y)-f($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) mod 264 $X=($Y-Z) mod 264 $X=$Y*$Z $X=$Y*Z rH$X=$Y*$Z rH$X=$Y*Z rH$X=f($Y)*f($Z) rH$X=f($Y)*f(Z) $X=$Y/$Z wenn $Z0 rR=$Y mod $Z $X=0 wenn $Z=0 rR=$Y $X=u(rD$Y) / / u($Z) rR=u(rD$Y) mod mod u($Z) $X=rD rR=$Y $X=f($Y)/f($Z) wenn u($Z) >u(rD)

DIV

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

DIVU

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

Divide unsigned: Dividend-Bits [12764] in

rD, Dividend-Bits [630] in $Y, Divisor in $Z; Rest der Division in Register rR

sonst Floating divide: Division zweier GK-Zahlen Floating remainder: y rem z y-nz mit n = nchster zu y/z gelegener Integer. Bei Mehrdeutigkeit wird der gerade Integer verwendet Floating square root: Wurzel einer GK-Zahl

FDIV

$X,$Y,$Z

FREM

$X,$Y,$Z

$X=$Y rem $Z

FSQRT $X,$Z

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

3-16

3.5.5

Bitweise Verknpfungen

Befehl AND ANDN

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=$X&~YZ

Wirkung

Erluterung Bitwise and: Bitweise UND-Verknpfung Bitwise and-not: Bitweise UND-NICHT-Verknpfung Bitwise and not low wyde: Bitweise UNDNICHT Verknpfung von Bit 015; die restlichen Bits von $X bleiben unverndert Bitwise and not medium low wyde: Bitweise UND-NICHT Verknpfung von Bit 1632; die restlichen Bits von $X bleiben unverndert Bitwise and not medium high wyde: Bitweise UND-NICHT Verknpfung von Bit 3247; die restlichen Bits von $X bleiben unverndert Bitwise and not high wyde: Bitweise UNDNICHT Verknpfung von Bit 4863; die restlichen Bits von $X bleiben unverndert Bitwise not and: Bitweise NICHT UND-Verknpfung Bitwise or: Bitweise ODER-Verknpfung Bitwise or with low wyde: Bitweise ODERVerknpfung von Bit 015; die restlichen Bits von $X bleiben unverndert Bitwise or with medium low wyde: Bitweise ODER-Verknpfung von Bit 1632; die restlichen Bits von $X bleiben unverndert Bitwise or with medium high wyde: Bitweise ODER-Verknpfung von Bit 3247; die restlichen Bits von $X bleiben unverndert Bitwise or with high wyde: Bitweise ODERVerknpfung von Bit 4863; die restlichen Bits von $X bleiben unverndert Bitwise or-not: Bitweise ODER-NICHT-Verknpfung Bitwise not or: Bitweise NICHT ODER-Verknpfung Bitwise exclusive or: Bitweise exklusiv-ODER-Verknpfung Bitwise not exclusive or: Bitweise NICHT exclusiv-ODER Bitwise multiplex: rMj==1 $Xj=$Yj, sonst $Xj=$Zj

ANDNL $X,YZ

ANDNML $X,YZ

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

ANDMH $X,YZ

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

ANDNH $X,YZ NAND OR ORL $X,$Y,$Z $X,$Y,Z $X,$Y,$Z $X,$Y,Z $X,YZ

$X=$X&~(YZ<<48) $X=~($Y&$Z) $X=~($Y&Z) $X=$Y|$Z $X=$Y|Z $X=$X|YZ

ORML

$X,YZ

$X=$X|(YZ<<16)

ORMH

$X,YZ

$X=$X|(YZ<<32)

ORH ORN NOR XOR NXOR MUX

$X,YZ $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=$X|(YZ<<48) $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&rM)|($Z&~rM) $X=($Y&rM)|(Z&~rM)

3-17

3.5.6

Schiebe-Befehle
Operanden $X,$Y,$Z $X,$Y,Z $X,$Y,$Z $X=$Y<<$Z $X=$Y<<Z $X=($Y<<$Z) mod 264 $X=($Y<<Z) mod 264 $X=$Y>>$Z $X=$Y>>Z $X=$Y>>$Z $X=$Y>>Z Wirkung Erluterung Shift left: Schiebt $Y um $Z bzw. um Z nach links. Auffllen mit 0. berlauf mglich. Shift left unsigned: Schiebt $Y um $Z bzw. Z nach links. Auffllen mit 0. Kein berlauf mglich. Shift right: Schiebt $Y um $Z bzw. um Z nach rechts. Auffllen mit MSB (VZ). Shift right unsigned: Schiebt $Y um $Z bzw. Z nach rechts. Auffllen mit 0.

Befehl SL

SLU $X,$Y,Z SR SRU $X,$Y,$Z $X,$Y,Z $X,$Y,$Z $X,$Y,Z

3.5.7

Vergleich von Zahlen

Befehl

Operanden

Wirkung

Erluterung

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

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

FCMP

$X,$Y,$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) $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 $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

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

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

Floating compare to: GK-Vergleich von $Y und $Z Floating equal to: GK-Vergleich von $Y und $Z

FEQL

$X,$Y,$Z

FCMPE

FEQLE

$X=-1, wenn f($Y) < < N(f($Z)) UND N(f($Y))<f($Z) $X=0, wenn f($Y) N(f($Z)) $X,$Y,$Z ODER f($Z) N(f($Y)) $X=1, wenn f($Y)>N(f($Z)) UND N(f($Y)) > f($Z) $X=1, wenn f($Y) N(f($Z)) UND f($Z) N(f($Y)) $X,$Y,$Z 0 sonst

Floating compare (with respect to epsilon): GK-Vergleich von $Y und $Z,

N(u)={x||x-u| 2Charakteristik}, wird in rE abgelegt


Floating equivalent (with respect to epsilon): GK-Vergleich von $Y und $Z,

N(u)={x||x-u| 2Charakteristik}; wird in rE abgelegt

3-18

3.5.8

Bedingte Zuweisungen

Befehl CSZ CSNZ CSN CSNN CSP CSNP CSE CSO ZSZ ZSNZ ZSN ZSNN ZSP ZSNP

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 $X,$Y,Z $X,$Y,$Z $X,$Y,Z

Wirkung

Erluterung Conditional set if zero: Keine nderung von $X, wenn Bedingung nicht erfllt. Conditional set if nonzero: Keine nderung von $X, wenn Bedingung nicht erfllt. Conditional set if negative: Keine nderung von $X, wenn Bedingung nicht erfllt. Conditional set if nonnegative: Keine nderung von $X, wenn Bedingung nicht erfllt. Conditional set if positiv: Keine nderung von $X, wenn Bedingung nicht erfllt. Conditional set if nonpositive: Keine nderung von $X, wenn Bedingung nicht erfllt. Conditional set if even: Keine nderung von $X, wenn Bedingung nicht erfllt. Conditional set if odd: Keine nderung von $X, wenn Bedingung nicht erfllt. Zero or set if zero Zero or set if nonzero Zero or set if negative Zero or set if nonnegative Zero or set if positive Zero or set if nonpositive

ZSEV

ZSOD

$Y==0 $X=$Z $Y==0 $X=Z $Y!=0 $X=$Z $Y!=0 $X=Z $Y<0 $X=$Z $Y<0 $X=Z $Y0 $X=$Z $Y0 $X=Z $Y>0 $X=$Z $Y<0 $X=Z $Y0 $X=$Z $Y0 $X=Z $Y mod 2 == 0 $X=$Z $Y mod 2 == 0 $X=Z $Y mod 2 == 1 $X=$Z $Y mod 2 == 1 $X=Z $Y==0 $X=$Z, sonst $X=0 $Y==0 $X=Z, sonst $X=0 $Y!=0 $X=$Z, sonst $X=0 $Y!=0 $X=Z, sonst $X=0 $Y<0 $X=$Z, sonst $X=0 $Y<0 $X=Z, sonst $X=0 $Y0 $X=$Z, sonst $X=0 $Y0 $X=Z, sonst $X=0 $Y>0 $X=$Z, sonst $X=0 $Y>0 $X=Z, sonst $X=0 $Y0 $X=$Z, sonst $X=0 $Y0 $X=Z, sonst $X=0 $Y mod 2 == 0 $X=$Z, $X,$Y,$Z sonst: $X=0 $Y mod 2 == 0 $X=Z, $X,$Y,Z sonst: $X=0 $Y mod 2 == 1 $X=$Z, $X,$Y,$Z sonst: $X=0 $X,$Y,Z $Y mod 2 == 1 $X=Z, sonst: $X=0

Zero or set if even

Zero or set if odd

3-19

3.5.9

Verzweigungen

Bei den angegebenen Befehlen werden Rckwrtssprnge vom Assembler automatisch erkannt und in einen Opcode umgewandelt, der um den Wert 1 grsser ist als der Opcode des VorwrtsSprungbefehls Die Zieladresse bei Rckwrtssprngen berechnet sich zu YZ 2
16

Befehl BZ PBZ BNZ PBNZ BN PBN BNN PBNN BP PBP BNP PBNP BEV PBEV BOD PBOD

Operanden $X,YZ $X,YZ $X,YZ $X,YZ $X,YZ $X,YZ $X,YZ $X,YZ $X,YZ $X,YZ $X,YZ $X,YZ $X,YZ $X,YZ $X,YZ $X,YZ

Wirkung $X==0 @=@+4YZ bzw. @=@+4(YZ-216) $X==0 @=@+4YZ bzw. @=@+4(YZ-216) $X!=0 @=@+4YZ bzw. @=@+4(YZ-216) $X!=0 @=@+4YZ bzw. @=@+4(YZ-216) $X<0 @=@+4YZ bzw. @=@+4(YZ-216) $X<0 @=@+4YZ bzw. @=@+4(YZ-216) $X0 @=@+4YZ bzw. @=@+4(YZ-216) $X0 @=@+4YZ bzw. @=@+4(YZ-216) $X>0 @=@+4YZ bzw. @=@+4(YZ-216) $X>0 @=@+4YZ bzw. @=@+4(YZ-216) $X0 @=@+4YZ bzw. @=@+4(YZ-216) $X0 @=@+4YZ bzw. @=@+4(YZ-216) $X mod 2 == 0 @=@+4YZ bzw. @=@+4(YZ-216) $X mod 2 == 0 @=@+4YZ bzw. @=@+4(YZ-216) $X mod 2 == 1 @=@+4YZ bzw. @=@+4(YZ-216) $X mod 2 == 1 @=@+4YZ bzw. @=@+4(YZ-216)

Erluterung Branch if zero: Verzweigung, wenn $X==0 Verzweigung unwahrscheinlich Probable branch if zero: Verzweigung, wenn $X==0, Verzweigung wahrscheinlich Branch if nonzero: Verzweigung, wenn $X!=0, Verzweigung unwahrscheinlich Probable branch if nonzero: Verzweigung, wenn $X!=0, Verzweigung wahrsch. Branch if negative: Verzweigung, wenn $X<0, Verzweigung unwahrscheinlich Probable branch if negative: Verzweigung, wenn $X<0, Verzweigung wahrscheinlich Branch if nonnegative: Verzweigung, wenn $X0, Verzweigung unwahrscheinlich Probable branch if nonnegative: Verzweigung, wenn $X0, Verzw. wahrsch. Branch if positive: Verzweigung, wenn $X>0, Verzweigung unwahrscheinlich Probable branch if positive: Verzweigung, wenn $X>0, Verzweigung wahrscheinlich Branch if nonpositive: Verzweigung, wenn $X0, Verzweigung unwahrscheinlich Probable branch if nonpositive: Verzweig., wenn $X0, Verzweigung wahrsch. Branch if even: Verzweigung, wenn $X gerade, Verzw. unwahrscheinlich Probable 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

3-20

3.5.10 Sprnge und Funktionsaufrufe

Befehl

Operanden $X,$Y,$Z

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

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

GO $X,$Y,Z X<rG: XrL rL=X $0..$(X-1) Registerstack X Registerstack $(X+1),$(X+2),... $0,$1,... rJ=@+4 @=$Y+$Z $X,$Y,$Z XrG: $0..$(rL-1) Registerstack rL Registerstack $(rL+1),$(rL+2),... $0,$1,... rL=0 rJ=@+4 @=$Y+$Z X<rG: XrL rL=X $0..$(X-1) Registerstack X Registerstack $(X+1),$(X+2),... $0,$1,... rJ=@+4 @=$Y+Z $X,$Y,Z XrG: $0..$(rL-1) Registerstack rL Registerstack $(rL+1),$(rL+2)... $0,$1,... rL=0 rJ=@+4 @=$Y+Z @=@+4*XYZ bei Vorwrtssprung JMP XYZ @=@+4*(XYZ-224) bei Rckwrtssprung

PUSHGO

Push register and go: Sichert die Register $0...$(X-1) auf den Registerstack, schreibt anschliessend die Anzahl der gesicherten Register ebenfalls auf den Registerstack, benennt $(X+1),$(X+2),... in $0,$1,... um, speichert die Adresse des nchsten Befehls in Register rJ und springt an die durch $Y und $Z bzw. $Y und Z angegebene Adresse.

Bedingungsloser Sprung mit relativer Adressierung. Opcode Rckwrtssprung = Opcode Vorwrtssprung + 1 wird vom Assembler automatisch umgesetzt

3-21

PUSHJ

$X,YZ

X<rG: XrL rL=X $0..$(X-1) Registerstack X Registerstack $(X+1),$(X+2),... $0,$1,... rJ=@+4 @=@+4YZ bei Vorwrtssprung bzw. @=@+4YZ-262144 bei Rckwrtssprung XrG: $0..$(rL-1) Registerstack rL Registerstack $(rL+1),$(rL+2),... $0,$1,... rL=0 rJ=@+4 @=@+4YZ bei Vorwrtssprung bzw. @=@+4YZ-262144 bei Rckwrtssprung (PUSHJ)-1

Push register and jump: Sichert die Register $0...$(X-1) auf den Registerstack, schreibt anschliessend die Anzahl der gesicherten Register ebenfalls auf den Registerstack, benennt $(X+1),$(X+2),... in $0,$1,... um, speichert die Adresse des nchsten Befehls in Register rJ und springt bei einen Vorwrtssprung um 4YZ Adressen nach vorne, bzw. bei einem Rckwrtssprung |4YZ-252144| Adressen nach hinten.

POP

X,YZ

Macht einen vorausgegangenen PUSHJBefehl wieder rckgngig

3.5.11 Interrupt-Befehle
Befehl Operanden Wirkung Erluterung

TRIP

X,Y,Z

TRAP

X,Y,Z

rB=$255 $255=rJ rW=@+4 rX=(1<<63)|(0xFF X Y Z) Unterbr. Befehl Speicherbefehl: rY=zu speichernder Wert rZ=virt. Speicheradresse sonst: rY=Y rZ=Z $255=rT rK=0 rBB=$255 $255=rJ rWW=@+4 rXX=(1<<63)|(0xFF X Y Z) rYY=Y rZZ=Z

Lst einen Trip aus. Im Anschluss wird der Trip-Handler ab Adresse 0x00 ausgefhrt.

Lst einen Trap aus. Im Anschluss wird der Trap-Handler der Betriebssystemroutine, die ab der in rT angegebenen Adresse steht, ausgefhrt.

3-22

RESUME

Z==0: Rckkehr aus TripHandler ropcode==0x00 (rX&0xFFFFFFFF) als Befehl an Stelle rW-4 ausfhren ropcode==0x01 (rX&0xFFFFFFFF) als Befehl an Stelle rW-4 ausfhren, Operanden jedoch aus rY und rZ nehmen ropcode==0x02 (rX&0xFFFFFFFF) als Befehl an Stelle rW-4 ausfhren, Operand $X jedoch durch rZ ersetzen ropcode==0x03 (rX&0xFFFFFFFF) als Befehl an Stelle rW-4 ausfhren, wobei rZZ jedoch als Seitentabelleneintrag fr die virtuelle Andresse in rYY angesehen wird ropcode==0x80 @=rW Z==1: Rckkehr aus TrapHandler Setzt ein Programm nach einem Interrupt rK=$255 fort $255=rBB ropcode==0x00 (rXX&0xFFFFFFFF) als Befehl an Stelle rWW-4 ausfhren ropcode==0x01 (rXX&0xFFFFFFFF) als Befehl an Stelle rWW-4 ausfhren, Operanden jedoch aus rYY und rZZ nehmen ropcode==0x02 (rXX&0xFFFFFFFF) als Befehl an Stelle rWW-4 ausfhren, Operand $X jedoch durch rZZ ersetzen ropcode==0x03 (rXX&0xFFFFFFFF) als Befehl an Stelle rWW-4 ausfhren, wobei rZZ jedoch als Seitentabelleneintrag fr die virtuelle Andresse in rYY angesehen wird ropcode==0x80 @=rWW sonst: Auslsung des Interrupts "illegal instruction"
3-23

3.5.12 Gleitkomma-Konvertierung Befehl FINT FLOT FLOTU FIX FIXU Operanden $X,$Z $X,$Z $X,Z $X,$Z $X,Z $X,$Z $X,$Z $X,$Z SFLOT $X,Z $X=f(t(s(Z))) Wirkung $X=f(int(f($Z))) $X=f(s($Z)) $X=f(s(Z)) $X=f(u($Z)) $X=f(u(Z)) $X=s(int(f($Z))) $X=int(f($Z)) mod 264 $X=f(t(s($Z))) Erluterung Floating integer: Runden einer GK-Zahl auf eine ganze Zahl; Ergebnis wieder GK-Zahl Convert fixed to floating: VZ-behaftete Konvertierung Integer GK-Zahl Convert fixed to floating unsigned: VZ-lose Konvertierung Integer GK-Zahl Convert floating to fixed: Konvertierung GK-Zahl VZ-behafteter Integer Convert floating to fixed unsigned: Konvertierung GK-Zahl VZ-loser Integer Convert fixed to short float: Wandelt eine ganze vorzeichenbehaftete Zahl in eine 32Bit-GK-Zahl um. Die Zahl wird zuerst in eine 32-Bit-Zwischengre gewandelt, wobei Rundungsfehler auftreten knnen. 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-Zwischengre gewandelt, wobei Rundungsfehler auftreten knnen.

$X,$Z SFLOTU $X,Z

$X=f(t($Z))

$X=f(t(Z))

3-24

3.5.13 Andere Operationen

Befehl

Operanden

Wirkung

Erluterung

$X,$Y,$Z SADD $X,$Y,Z $X,$Y,$Z MOR $X,$Y,Z

$X=Bitanzahl($Y&~$Z) $X=Bitanzahl($Y&~Z) $Xij=($Y0j&$Zi0)|... ...|($Y7j&$Zi7) $Xij=($Y0j&Zi0)|...

Sideways add: zhlt die Anzahl der BitPositionen, an denen $Y==1 und $Z==0

bzw. $Y==1 und Z==0


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

MXOR

FUN

...|($Y7j&Zi7) $Xij=($Y0j&$Zi0)^ ... $X,$Y,$Z ...^($Y7j&$Zi7) $Xij=($Y0j&Zi0)^ ... $X,$Y,Z ...^($Y7j&Zi7) $X=1, wenn $Y==NaN $X,$Y,$Z ODER $Z==NaN, $X=0, sonst $X,$Y,$Z $X=1, wenn $Y==NaN ODER $Z==NaN ODER rE==NaN $X=0, sonst $X=g[Z] g[X]=$Z

Multiple or: Octabyte als 8x8-Matrix; Matrixmultiplikation mit XOR und UND Floating unordered: Test, ob $Y und $Z echte Zahlen sind, NaN Not a number Floating unordered (with respect to epsilon): Test, ob $Y,$Z und rE echte Zahlen sind, NaN bedeutet: not a number Ldt den Wert des Spezialregisters mit der laufenden Nummer Z in ein Allzweckregister Schreibt einen Wert in ein Spezialregister

FUNE

GET

$X,Z X,$Z

PUT X,Z g[X]=Z $X=@+4*YZ bei Vorwrtsverweis GETA $X,Label $X=@+4*YZ-216 bei Rckwrtsverweis $0...$(rL-1),$G...$255, rB,rD,rE,rH,rJ,rM,rR,rP rW,rX,rY,rZ Registerstack (rG<<56)|(rA&0xFFFFFFFF) Registerstack L=0 $X=oberste Stackadresse

Get address: Ldt eine Adresse in das Register X, wobei relativ adressiert wird. Opcode Rckwrtsverweis = Opcode Vorwrtsverweis + 1 Speichert den aktuellen Kontext auf den Registerstack. In $X wird im Anschluss die oberste Stackadresse abgelegt, wobei $X ein globales Register sein mu. Restauriert den zuvor von einem SAVEBefehl auf dem Registerstack abgelegten Kontext. $Z mu hierbei die Adresse sein, die von dem vorausgehenden SAVE-Befehl zurckgegeben wurde Sympathize with your machinery. Entspricht einem nop-Befehl.

SAVE

$X,0

UNSAVE $Z

(SAVE)-1

SWYM

X,Y,Z

nop

3-25

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 (fr den Menschen gut lesbar).

Befehlscodierung: Umwandlung der Zeichenketten in Zahlen (Nullen und Einsen). Zahlen fr den Prozessor gut lesbar wird vom Assembler whrend der Assemblierung durchgefhrt Es werden nur diejenigen Zeichenketten umgewandelt, die fr die Ausfhrung des Programms notwendig sind Marken werden in Adressen umgerechnet + wenn eine Marke als Sprungziel verwendet wurde, dann wird je nach Sprungbefehl entweder die die Marke reprsentierende 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 Referenzierung die zugehrige Adresse verwendet das Befehls-Feld (Mnemocode), also z.B. die Zeichenfolge ADD, wird gemss nachfolgender Tabelle in Zahlen (z.B. 0x20) bersetzt die Operanden werden gemss ebenfalls in Zahlen bersetzt Kommentare werden weggelassen

Marke

ADD $1,$2,$3

Kommentar

0x20 0x01 0x02 0x03

Opcode bersetztes Befehlswort:

00100000

00000001

00000010

00000011

1 Byte

1 Byte

1 Byte

1 Byte

Abb. 104: Befehlscodierung

3-26

3.6.2

Codierung des Opcodes

Das Befehls-Feld (Opcode, Mnemocode) wird gemss nachfolgender Tabelle bersetzt.


0x..0 0x0.. 0x1.. 0x2.. 0x3.. 0x4.. 0x5.. 0x6.. 0x7.. 0x8.. 0x9.. 0xA.. 0xB.. 0xC.. 0xD.. 0xE.. 0xF.. 0x..1 0x..2 0x..3 0x..4 0x..5 0x..6 0x..7 0x0.. 0x1.. 0x2.. 0x3.. 0x4.. 0x5.. 0x6.. 0x7.. 0x8.. 0x9.. 0xA.. 0xB.. 0xC.. 0xD.. 0xE.. 0xF.. TRAP 5 FCMP FLOT[I] 4 FMUL 4 FCMPE 4 MUL[I] 10 ADD[I] 2ADDU[I] CMP[I] SL[I] BN[B] + BNN[B] + PBN[B] 3- PBNN[B] 3- CSN[I] CSNN[I] ZSN[I] ZSNN[I] LDB[I] + LDT[I] + LDSF[I] + LDVTS[I] STB[I] + STT[I] + STSF[I] + SYNCD[I] OR[I] AND[I] BDIF[I] MUX[I] SETH SETMH ORH ORMH JMP[B] POP 3 RESUME 5 0x..8 0x..9 FUN FEQL FLOTU[I] 4 FUNE FEQLE 4 MULU[I] 10 ADDU[I] 4ADDU[I] CMPU[I] SLU[I] BZ[B] + BNZ[B] + PBZ[B] 3- PBNZ[B] 3- CSZ[I] CSNZ[I] ZSZ[I] ZSNZ[I] LDBU[I] + LDTU[I] + LDHT[I] + PRELD[I] STBU[I] + STTU[I] + STHT[I] + PREST[I] ORN[I] ANDN[I] WDIF[I] SADD[I] SETML SETL ORML ORL PUSHJ[B] [UN]SAVE 20+ 0x..A 0x..B

FADD 4 FIX 4 FSUB 4 FIXU 4 SFLOT[I] 4 SFLOTU[I] 4 FDIV 40 FSQRT 40 FREM 4 FINT 4 DIV[I] 60 DIVU[I] 60 SUB[I] SUBU[I] 16ADDU[I] 8ADDU[I] NEG[I] NEGU[I] SR[I] SRU[I] BP[B] + BOD[B] + BEV[B] + BNP[B] + PBP[B] 3- PBOD[B] 3- PBNP[B] 3- PBEV[B] 3- CSP[I] CSOD[I] CSNP[I] CSEV[I] ZSP[I] ZSOD[I] ZSEV[I] ZSNP[I] LDW[I] + LDWU[I] + LDO[I] + LDOU[I] + CSWAP[I] 2+2 LDUNC[I] + PREGO[I] GO[I] 3 STW[I] + STWU[I] + STO[I] + STOU[I] + STCO[I] + STUNC[I] + SYNCID[I] PUSHGO[I] 3 NOR[I] XOR[I] NAND[I] NXOR[I] TDIF[I] ODIF[I] MOR[I] MXOR[I] INCH INCHM INCML INCL ANDNH ANDNMH ANDNML ANDNL GETA[B] PUT[I] SYNC SWYM GET TRIP 5 0x..C 0x..D 0x..E 0x..F

Das erste Nibble (4 Bit-Wert) des Opcodes entspricht der Doppelzeile (0 bis 15), in der sich der Befehlscode 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 Befehlscode 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 hher als die nichtimmediate-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-27

[B] bedeutet: Backward-Variante des Befehls Rckwrtssprung


wird bei Sprngen rckwrts gesprungen, wird der Sprungbefehl durch einen um 1 hheren Opcode als beim Vorwrtssprung codiert Rckwrtssprung rechter Teil einer Doppelspalte gibt an, wieviele Takte der betreffende Befehl zur Ausfhrung bentigt Befehl bentigt einen Takt steht vor dem Zeichen noch eine Zahl x, so werden zur Ausfhrung des Befehls vom MMIXProzessor x Takte bentigt gibt an, wieviele Speicher-Zeiteinheiten der betreffende Befehl fr einen Speicherzugriff bentigt, 32 32 wobei beim Praktikums-Simulator mmix eine Speicher-Zeiteinheit 2 Takte, also 2 betrgt bedeutet: 2, wenn gesprungen wird, sonst 0; der Befehl BZ bentigt 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 entweder 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 zustzlich noch der ADD-Befehl bentigt zur Ausfhrung 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 Registernummer als vorzeichenlose 8 Bit-Zahl dargestellt) Vorzeichenbehaftete immediate-Operanden -128 127 werden im 2er-Komplement dargestellt + 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 fr unsigned) Vorzeichenlose immediate-Operanden 0 255 werden ebenfalls zu 0x00 0xFF bersetzt (die Zahl wird also einfach als vorzeichenlose 8 Bit-Zahl dargestellt)

3-28

3.7
3.7.1

Programmierung
Funktionsaufrufe

Motivation Modularitt: Zerlegung eines (grossen) Problems in mehrere kleinere Probleme, die dann unabhngig von einander gelst werden knnen + Funktion lst ein kleines Teilproblem + Programm ruft mehrere Funktionen auf und lst damit das (grosse) Problem Strukturierung von Programmen + Programme werden wesentlich einfacher lesbar verteilte Entwicklung durch definierte Schnittstellen + Funktionen knnen unabhngig voneinander entwickelt werden + Einsatz mehrerer Programmierer krzere Projektzeit + definierte Schnittstellen jeder Programmierer wei genau, welche Daten er als EingabeParameter bekommt und welche er als Rckgabewert zurckliefern muss separate bersetzung + es muss nicht immer bei nderung einer einzigen Funktion das gesamte Programm bersetzt werden + Zeitersparnis bei grossen Programmen Verwendung von Programmbibliotheken + bereits implementierte Lsungen knnen wiederverwendet werden

Ablauf der Verwendung einer Funktion (allgemein) der Funktionsaufrufer bringt die der Funktion zu bergebenden Parameter in den Zugriffsbereich der Funktion Funktionsaufruf 28 + der Funktionsaufrufer bergibt die Kontrolle an die Funktion, indem er den Befehlszhler auf die Einsprungadresse der Funktion setzt + die Rcksprungadresse wird entweder explizit durch den Funktionsaufrufer/die Funktion oder implizit durch den verwendeten Sprung-Befehl gerettet die Funktion alloziert Speicher fr ihre Ausfhrung 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 ldt die Rcksprungadresse in den Befehlszhler, wodurch zum Funktionsaufrufer zurck gesprungen wird der Funktionsaufrufer liest das von der Funktion bereitgestellt Ergebnis aus

28 Der Befehlszhler ist ein Register (Datenspeicher), der die Adresse des nchsten auszufhrenden Befehls beinhaltet und wird im Rahmen der Betrachtungen des Datenpfads (Kap. 7 und 10) nher erlutert. Der Aufbau des Befehlszhlers ist in Kapitel 1.4.7 dargestellt.

3-29

Parameterbergabe in Registern In diesem Abschnitt wird lediglich auf die Parameterbergabe eingegangen. Das Sichern bzw. Restaurieren des Befehlszhlers, Allozieren von Speicher etc. wird hier nicht betrachtet. Parameterbergabe mittels direkter Wertangabe (call by value) + die Daten, die der Funktion bergeben werden sollen, stehen ursprnglich entweder in Registern oder im Arbeitsspeicher + zur bergabe an die Funktion werden die zu bergebenden Daten in zuvor vereinbarte Register 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 verndern + 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) + Rckgabe eines Ergebnisses von der Funktion zum Aufrufer funktioniert analog
Register

$n

$2 $1 Wert des zweiten Datums $0 Wert des ersten Datums


1 3
Wert des ersten Datums Wert des zweiten Datums

es erW ert d tums Da sten ies zwe Wert d tums ten Da

Aufruf

Aufrufer Abb. 105: Parameterbergabe mittels direkter Wertangabe

Funktion

Parameterbergabe 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 mssen maximal ein paar Zeiger kopiert werden

3-30

obwohl wieder nur eine Kopie des Zeigers an die Funktion bergeben wird, kann die Funktion die Daten jetzt auch verndern, da ihr ja ber den Zeiger die Adresse der Original-Daten mitgeteilt wird + vor allem bei grossen Datenstzen (z.B. Matrix mit 1000 x 1000 Eintrgen) sinnvoll + Ablauf (vgl. nachfolgende Abbildung) der Funktionsaufrufer legt die Parameter im Speicher ab (ist in der Regel berflssig, da die Parameter sich im Allgemeinen bereits im Speicher befinden) (1) der Funktionsaufrufer legt Zeiger auf die Parameter (in nachfolgender Abbildung als Adresse 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 Registern (4) die Funktion greift mittels der aus den Registern geholten Adressen auf den Arbeitsspeicher zu (5) und holt sich die Parameter vom Speicher ab (6) + Rckgabe eines Ergebnisses von der Funktion zum Aufrufer funktioniert analog
Register Speicher

$n

0x00 0x08 0x10

$3 $2 $1 $0

0x... 0x...

0x... 0x...

LDV\0 2004

0x...

2 4 1
Ad re

0x...

. 0x.. LDV\0

ss

en h

ole n

0x... 2004
3 Aufrufer Abb. 106: Parameterbergabe als Referenz Aufruf

0x... 0x...
Funktion

Probleme + Register, in denen die Parameter bzw. die Zeiger auf die Parameter stehen, mssen vorher vereinbart worden sein + was passiert, wenn mehr Parameter bergeben werden sollen, als der Prozessor Register zur Verfgung hat? + was passiert, wenn in den Registern bereits Parameter aus einem vorhergegangenen Funktionsaufruf stehen, die noch gebraucht werden (z.B. bei rekursiv aufgerufenen Funktionen)? Lsung + Bei der Parameterbergabe mittels direkter Wertangabe (call by value) werden die Parameter im Arbeitsspeicher (auf dem Stack, vgl. nachfolgendes Kapitel) bergeben + Bei der Parameterbergabe mittels Referenz (call by reference) werden sowohl die Parameter, als auch die Adressen auf die Parameter im Arbeitsspeicher (auf dem Stack, vgl. nachfolgendes Kapitel) bergeben 3-31

20 LDV 04 \0

Parameterbergabe auf dem Stack Stack + Speicher, der von hohen Adressen zu niedrigen Adressen hin wchst + 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
0x2000000000000000 0x2000000000000008 0x2000000000000010

SP BOS

0x3FFFFFFFFFFFFFD8 0x3FFFFFFFFFFFFFE0 0x3FFFFFFFFFFFFFE8 0x3FFFFFFFFFFFFFF0 0x3FFFFFFFFFFFFFF8 0x4000000000000000


Abb. 107: Stack beim MMIX-Prozessor

Schreiben eines Datums auf den Stack (push) 29 + erhhen des Stackpointers (1) + Abspeichern des Datums an der Adresse, die dem (neuen) Stackpointer entspricht (2)
2 1

SP

SP

Datum

Abb. 108: Schreiben eines Datums auf den Stack

Lesen eines Datums vom Stack (pop) + Auslesen des Datums, auf das der Stackpointer zeigt (1) 30 + Stackpointer dekrementieren (2)
1

SP

Datum 2

Datum

SP

Abb. 109: Lesen eines Datums vom Stack

Das Erhhen bezieht sich hier auf die grafische Darstellung, in der der Stackpointer nach oben wandert. Die Adresse, die der Stackpointer reprsentiert, 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 reprsentiert, wird hierbei erhht.

29

3-32

Vereinbarungen zur Verwendung des Stacks fr Funktionsaufrufe + eine Funktion soll ihr Ergebnis immer an diejenige Stelle im Stack schreiben, an der ihr zuvor der Funktionsparameter bergeben wurde + wurden mehrere Parameter bergeben, soll die Stelle mit der hchsten Adresse verwendet + Beim Rcksprung 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 Funktionsaufruf befand + der Inhalt von Register $0 darf bei einem Funktionsaufruf verloren gehen muss beim Rcksprung aus einer Funktion nicht wiederhergestellt werden kann also zur Aufnahme der Rcksprungadresse verwendet werden Beispiel zum Ablaufs eines Funktionsaufrufs mit Hilfe des Stacks beim MMIX-Prozessor + Initialisierung des Stack-Bodens (BOS) und des Stackpointers (SP) BOS SP GREG GREG #4000000000000000 #4000000000000000
31

SP

0x4000000000000000 (BOS)
Abb. 110: Leerer Stack nach der Initialisierung

+ der Funktionsaufrufer legt die Parameter auf dem Stack ab SUB STO STO STO SP,SP,3*8 a,SP,0 b,SP,1*8 c,SP,2*8 alternativ :
32

SUB STO SUB STO SUB STO

SP,SP,8 c,SP,0 SP,SP,8 b,SP,0 SP,SP,8 a,SP,0

SP

a b c

0x4000000000000000 (BOS)
Abb. 111: Ablegen der Parameter auf den Stack

+ der Funktionsaufrufer bergibt die Kontrolle an die Funktion fkt gem voriger Vereinbarungen wird die Rcksprungadresse im Register $0 abgelegt (vgl. erster Parameter des GO-Befehls) der Inhalt des Stacks bleibt unverndert 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 untersttzt. 32 Es kann natrlich auch beim Schreiben jedes einzelnen Parameters auf den Stack der Stackpointer gendert werden, wofr jedoch deutlich mehr Befehle bentigt werden zeitaufwendiger.

3-33

+ die Funktion fkt sichert die im Register $0 bergebene Rcksprungadresse auf den Stack SUB STO SP,SP,8 $0,SP,0

SP

$0 a b c

0x4000000000000000 (BOS)
Abb. 112: Sicherung der Rcksprungadresse auf den Stack

+ die Funktion fkt sichert die von ihr verwendeten Register auf den Stack beim Rcksprung zum Funktionsaufrufer knnen die von fkt berschriebenen Register dann wieder hergestellt werden der Funktionsaufrufer findet so nach dem Aufruf der Funktion fkt die von ihm verwendeten Register wieder so vor, wie sie vor dem Aufruf von fkt waren vom Funktionsaufrufer in den Registern abgelegte Daten gehen durch den Funktionsaufruf somit nicht verloren SUB STO STO STO STO SP,SP,4*8 i,SP,0 j,SP,1*8 k,SP,2*8 l,SP,3*8

SP

i j k l $0 a b c

0x4000000000000000 (BOS)
Abb. 113: Sicherung der von der Funktion fkt verwendeten Register auf den Stack

+ die Funktion fkt ldt die ihr bergebenen Parameter vom Stack in die von ihr benutzten Register der Inhalt des Stacks bleibt unverndert LDO LDO LDO i,SP,5*8 j,SP,6*8 k,SP,7*8

+ die Funktion fkt verarbeitet die Parameter der Inhalt des Stacks bleibt unverndert 3-34

+ die Funktion ruft evtl. eine weitere Funktion fkt2 auf die Funktion fkt legt die Parameter fr die Funkion fkt2 auf dem Stack ab SUB STO STO SP,SP,2*8 l,SP,0 i,SP,1*8

SP

l i i j k l $0 a b c

0x4000000000000000 (BOS)
Abb. 114: bergabe der Paramter fr die Funktion fkt2 auf dem Stack

die Funktion fkt bergibt die Kontrolle an die Funktion fkt2 die Rcksprungadresse 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 unverndert GO $0,fkt2

die Funktion fkt2 sichert die ihr im Register $0 bergebene Rcksprungadresse auf den Stack SUB STO SP,SP,8 $0,SP,0

SP

$0 l i i j k l $0 a b c

0x4000000000000000 (BOS)
Abb. 115: Sicherung der Adresse zum Rcksprung in die Funktion fkt

3-35

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 STO STO STO SP,SP,3*8 p,SP,0 q,SP,1*8 r,SP,2*8

SP

p q r $0 l i i j k l $0 a b c

0x4000000000000000 (BOS)
Abb. 116: Die Funktion fkt2 sichert die von ihr verwendeten Register

die Funktion fkt2 ldt die ihr bergebenen Parameter vom Stack in die von ihr verwendeten Register der Inhalt des Stacks bleibt unverndert LDO LDO p,SP,4*8 q,SP,5*8

die Funktion fkt2 verarbeitet die Parameter

an dieser Stelle knnte die Funktion fkt2 eine weitere Funktion aufrufen (wird hier nicht durchgefhrt)

die Funktion fkt2 hat nun ihr Ergebnis berechnet und will wieder zum Aufrufer (hier: Funktion fkt) zurckspringen

3-36

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 Rcksprung aus fkt2 das Ergebnis vom Stack einlesen STO r,SP,5*8

SP

p q r $0 l r i j k l $0 a b c

0x4000000000000000 (BOS)
Abb. 117: Die Funktion fkt2 legt ihr Ergebnis auf dem Stack ab

die Funktion fkt2 stellt nun zunchst die von ihr verwendeten Register wieder her die Funktion fkt2 ldt 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 zurck fr den Aufrufer von fkt2 (hier also fr fkt) erscheint es deshalb so, als htte die Funktion fkt2 die Register gar nicht gendert der Inhalt des Stacks bleibt unverndert LDO LDO LDO p,SP,0 q,SP,1*8 r,SP,2*8

die Funktion fkt2 liest die Rcksprungadresse vom Stack und legt sie in Register $0 ab der Inhalt des Stacks bleibt unverndert LDO $0,SP,3*8

3-37

die Funktion fkt2 passt nun den Stackpointer so an, dass er auf den Rckgabewert zeigt die auf dem Stack abgelegten Daten, die sich in der nachfolgenden Abbildung oberhalb des Stackpointers befinden, werden dabei nicht gelscht! ADD SP,SP,5*8
p q r $0 l r i j k l $0 a b c

SP

0x4000000000000000 (BOS)
Abb. 118: Die Funktion fkt2 passt den Stackpointer an

die Funktion fkt2 springt zum Funktionsaufrufer (hier fkt) zurck Sprungziel steht in Register $0 ( zweiter Operand des GO-Befehls ist $0; dritter Operand des GO-Befehls ist 0, da zum zweiten Operanden nichts dazugezhlt werden soll) die Adresse fr einen theoretischen Rcksprung in die Funktion fkt2 (der natrlich nie durchgefhrt wird), wird wieder in Register $0 abgelegt (vgl. erster Operand des GO-Befehls) der Inhalt des Stacks bleibt unverndert 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 ADD k,SP,0 SP,SP,8
p q r $0 l r i j k l $0 a b c

SP

0x4000000000000000 (BOS)
Abb. 119: Stack nach dem Auslesen des Ergebnisses von fkt2

3-38

+ die Funktion fkt fhrt weitere Berechnungen durch und ruft hierzu evtl. weitere Funktionen auf + die Funktion fkt hat nun ihr Ergebnis berechnet und will wieder zum Aufrufer zurckspringen + die Funktion fkt legt zuerst ihr Ergebnis auf dem Stack ab STO j,SP,7*8

SP

p q r $0 l r i j k l $0 a b j

0x4000000000000000 (BOS)
Abb. 120: Die Funktion fkt legt ihr Ergebnis auf dem Stack ab

+ die Funktion fkt stellt nun zunchst die von ihr verwendeten Register wieder her keine nderung des Stack-Inhalts LDO LDO LDO LDO i,SP,0 j,SP,1*8 k,SP,2*8 l,SP,3*8

+ die Funktion fkt liest die Rcksprungadresse vom Stack und legt sie in Register $0 ab keine nderung des Stack-Inhalts LDO $0,SP,4*8

3-39

+ die Funktion fkt passt nun den Stackpointer so an, dass er auf den Rckgabewert zeigt die auf dem Stack abgelegten Daten, die sich in der nachfolgenden Abbildung oberhalb des Stackpointers befinden, werden dabei nicht gelscht!

ADD

SP,SP,7*8
p q r $0 l r i j k l $0 a b j

SP

0x4000000000000000 (BOS)
Abb. 121: Die Funktion fkt passt den Stackpointer an

+ die Funktion fkt springt zum Funktionsaufrufer zurck keine nderung des Stack-Inhalts 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 ADD

$1,SP,0 SP,SP,8
p q r $0 l r i j k l $0 a b j

SP

0x4000000000000000 (BOS)
Abb. 122: Stack nach dem Auslesen des Ergebnisses von fkt

3-40

Vorteile der Parameterbergabe auf dem Stack + einheitliche bergabe der Parameter + Rekursion mglich, da Parameter bei rekursivem Aufruf nicht berschrieben werden Nachteil der Parameterbergabe auf dem Stack + viele Zugriffe auf den Arbeitsspeicher langsam + bei einem Fehler in der Stackverwaltung wird als Rcksprungadresse evtl. irgendein Datum/Parameter etc. verwendet Programm springt pltzlich unkontrolliert irgendwo hin Programm strzt ab Programm berschreibt evtl. wichtige Daten

Ein besseres Konzept zur Parameterbergabe auf dem Stack stellt der sog. Register-Stack dar, der im Anhang besprochen wird

3-41

3.7.2

Erzeugung von Namensrumen

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 Fehlermeldung in der Programmiersprache C: + Variable und Marken in unterschiedlichen Funktionen knnen die selben Namen haben woher kann eine Funktion wissen, welche Namen fr Register und Marken bereits von anderen Funktionen bzw. vom Hauptprogramm verwendet wurden? Lsung + 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 knnen 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, knnen + ausserhalb einer PREFIX-Anweisung deklariert werden (z.B. globale Register [Stackpointer], globale Speicherstellen) + innerhalb einer PREFIX-Anweisung deklariert werden, indem ihnen ein Doppelpunkt vorangestellt 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 GREG OCTA IS PREFIX LOC OCTA IS LOC GREG LDO LDO GO #2000000000000000 @ 1 $1 fkt: #2000000000000008 2 $2 #100 @ :reg_a,:var_a reg_a,var_a $0,$0,0 Bedeutung Zeile ---------------------------var_a bzw. :var_a 03 reg_a bzw. reg_a 04 05 06 07 08 09 10 11 12 LDO $1,#2000000000000000 13 LDO $2,#2000000000000008 14 Rcksprung 15 16 3-42

var_a reg_a // // var_a reg_a :fkt //

var_a reg_a

PREFIX LOC OCTA IS LDO LDO LDO PREFIX

nochmal: #2000000000000010 3 $3 :reg_a,:var_a :fkt:reg_a,fkt:var_a reg_a,var_a : main: #2000000000000018 4 $4

LDO $1,#2000000000000000 LDO $2,#2000000000000008 LDO $3,#2000000000000010

// // // var_a reg_a // :Main // LDO // GO TRAP // PREFIX : $0,:fkt 0,:Halt,0 Funktion fkt aufrufen PREFIX LOC OCTA IS LOC LDO LDO LDO main:var_a main:reg_a

#110 :reg_a,:var_a LDO $1,#2000000000000000 :fkt:reg_a,:fkt:var_a LDO $2,#2000000000000008 :fkt:nochmal:reg_a,:fkt:nochmal:var_a LDO $3,#2000000000000010 reg_a,var_a LDO $4,#2000000000000018

17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43

die zugehrige 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 whrend der bersetzung einer Assembler-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 (fr das Linken mehrerer Dateien notwendig)

Symbol

Wert

fkt Main var_a fkt:var_a fkt:nochmal:var_a main:var_a reg_a fkt:reg_a fkt:nochmal:reg_a main:reg_a

0x100 0x110 0x2000000000000000 0x2000000000000008 0x2000000000000010 0x2000000000000018 $1 $2 $3 $4


Abb. 123: Symboltabelle

3-43

3.7.3

Beispiel: skalprodfkt.mms

In nachfolgendem Assembler-Code (skalprodfkt.mms) wird unter Verwendung der Funktion Skalprod das Skalarprodukt zweier Vektoren berechnet. Die Parameter (die Anfangsadressen der Vektoren a und b sowie die Vektordimension) werden der Funktion auf dem Stack bergeben. Sowohl die Funktion als auch das Hauptprogramm verfgen ber einen eigenen Namensraum

BOS SP N ADR_A1

LOC GREG GREG GREG OCTA OCTA OCTA OCTA OCTA OCTA OCTA OCTA OCTA LOC GREG PREFIX

Data_Segment @ #4000000000000000 0 4 1 2 3 4 10 20 30 40 #100 @ Skalprod: $1 $2 $3 $4 $5 $6 :SP,:SP,7*8 $0,:SP,6*8 u,:SP,5*8 v,:SP,4*8 w,:SP,3*8 x,:SP,2*8 y,:SP,8 z,:SP,0 u,:SP,(9*8) v,:SP,(8*8) w,:SP,(7*8) x,0 w,w,8 w,Ende w,w,8 y,u,w z,v,w y,y,z x,x,y Start x,:SP,9*8 u,:SP,5*8 v,:SP,4*8 w,:SP,3*8 x,:SP,2*8 y,:SP,8 z,:SP,0 $0,:SP,6*8 :SP,:SP,9*8

Bottom of Stack Stackpointer

ADR_B1

Vektordimension a1 a2 a3 a4 b1 b2 b3 b4

Start Prefix Skalprodfkt: Fr Fr Fr Fr Fr Fr Parameter 1 Parameter 2 Parameter 3 das Ergebnis Zwischenberechnungen Zwischenberechnungen

u v w x y z :Skalprod

IS IS IS IS IS IS SUB STO STO STO STO STO STO STO LDO LDO LDO SETL MUL BZ SUB LDO LDO MUL ADD JMP STO LDO LDO LDO LDO LDO LDO LDO ADD

push Rcksprungadresse sichern Register 1 sichern Register 2 sichern Register 3 sichern Register 4 sichern Register 5 sichern Register 6 sichern Parameter 1 nach u laden Parameter 2 nach v laden Parameter 3 nach w laden Initialisierung verwendete Worte haben 8 Byte wenn fertig -> Ende w = w - 8 y = <u + w> z = <v + w> y = <u + w> * <v + w> x = x + <u + w> * <v + w> Rckgabewert -> Stack Restore von Register 1 Restore von Register 2 Restore von Register 3 Restore von Register 4 Restore von Register 5 Restore von Register 6 Rcksprungadresse laden Zeige auf Speicherzelle 3-44

Start

Ende

* * * GO PREFIX : $0,$0,0

ber Aufrufer-Stack, in der der Rckgabewert steht Rcksprung Ende Prefix Skalprod:

PREFIX Main: x :Main IS SET SUB LDA STO LDA STO LDO STO GO LDO ADD TRAP PREFIX : $1 :SP,:BOS :SP,:SP,3*8 x,:ADR_A1 x,:SP,2*8 x,:ADR_B1 x,:SP,8 x,:N x,:SP,0 $0,:Skalprod x,:SP,0 :SP,:SP,8 0,:Halt,0

Start Prefix Main:

Stackpointer initialisieren push Referenz auf a1 laden ... ... und auf den Stack legen Referenz auf b1 laden ... ... und auf den Stack legen Vektordimension laden ... ... und auf den Stack legen Funktion aufrufen Rckgabewert vom Stack lesen pop, SP zeigt wieder auf BOS Ende

3-45

3.7.4

Lokale Marken

Motivation oft sind bereits in kurzen Programmabschnitten viele Marken vorhanden Marken mssen manchmal an Stellen gesetzt werden, fr 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 fr here 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 Vorwrts-Richtung zum nchsten Auftreten der Marke 4H + JMP 3B springt in Rckwrts-Richtung zum letzten Auftreten der Marke 3H lokale Marken werden immer in Abhngigkeit von der aktuellen Position angesprungen Code-Beispiel Main 2H 5H LOC JMP SET SET SUB BNZ JMP JMP TRAP JMP JMP JMP #100 unten $0,100 $1,5 $0,$0,$1 $0,5B 4F 1F 0,Halt,0 2B 1B 1B

3H 4H 1H 1H unten

Probieren Sie das Programm im Simulator aus, wenn Sie sich nicht sicher sind, wie es funktioniert!

3.8 Performance

3-46

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 Funktionseinheiten (wie z.B. Befehlszhler, 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 nchsten 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 ausgefhrt werden knnen.
4.1.1 Befehlsspeicher MMIX-Programme bestehen aus Befehlen, die in einem Speicher abgelegt sein mssen und aus diesem leicht auslesbar sein mssen. Dieser Speicher wird Befehlsspeicher genannt. Folgende Abbildung zeigt als Beispiel einen Auszug des Befehlsspeichers fr das im Kapitel 3 abgebildete Programm skalprodfkt.mms:

0x0000000000000100 0x0000000000000104 0x0000000000000108 0x000000000000010C 0x0000000000000110

0x25FCFC38 0xAD00FC30 0xAD01FC28 0xAD02FC20 0xAD03FC18

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 verfgen. Am Ausgang wird der gewnschte 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 fr das Betriebssystem reservierten Bereich stehen knnen, wird zur Angabe des Orts, an dem der gewnschte Befehl steht, ein 64 Bit breites Datenwort bentigt. Der Eingang des Befehlsspeichers muss also 64 Bit breite Adressen aufnehmen knnen.

4-1

Der Befehlsspeicher kann auf Mikroarchitektur-Ebene also wie folgt dargestellt werden:

BefehlsSpeicher
32 Daten 64 Adresse

Abb. 125: Befehlsspeicher

Der Befehlsspeicher funktioniert folgendermaen: 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 Befehlsspeichers 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 ausgewhlten Speicherstelle steht.

Die Grsse des Befehlsspeichers kann man wie folgt ermitteln: Textsegment: + Adresse 0x0000000000000000 bis 0x1FFFFFFFFFFFFFFF 61 + 0x2000000000000000 Byte 2 Byte 2.097.152 Terabyte Fr das Betriebssystem reserviertes Segment: + Adresse 0x8000000000000000 bis 0xFFFFFFFFFFFFFFFF 61 + 4 2 Byte 8.388.608 Terabyte Insgesamt: 10.485.760 Terabyte. Ein so grosser Speicher kann zur Zeit unmglich implementiert werden. Wie man einen so grossen Adressbereich auch mit weniger Speicher implementieren kann, werden wir in einem spteren Kapitel ( Paging) zeigen; bis nehmen wir der Einfachheit halber an, dass der Speicher in der angegebenen Grsse implementiert ist.

4.1.2 Datenspeicher Daten knnen beim MMIX nicht nur in Registern, sondern auch im Datenspeicher abgelegt werden. Vom Loader, also vor der Programmausfhrung; 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. Whrend der Programmausfhrung mit den Befehlen STO, STT, STW und STB.

Zum Auslesen der Daten aus dem Datenspeicher knnen die Befehle LDO, LDT, LDW und LDB verwendet werden.

4-2

Wie muss der Datenspeicher auf Mikroarchitektur-Ebene aussehen, damit die oben angegebenen Speicherzugriffe mglich sind? Die im Datenspeicher abgelegten Daten knnen sich sowohl im Text-, im Pool-, als auch im Stacksegment befinden. Der Datenspeicher muss also ber einen 64 Bit breiten Adresseingang verfgen, 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 mssen also maximal 64 Bit gleichzeitig in den Speicher geschrieben bzw. aus dem Speicher gelesen werden + fr Schreibzugriffe wird somit ein 64 Bit breiter Datenbus bentigt, ber den die Daten in den Speicher transportiert werden knnen + fr Lesezugriffe wird ebenfalls ein 64 Bit breiter Datenbus bentigt, ber den die Daten aus 33 dem Speicher geladen werden knnen da Zugriffe beim MMIX sowohl byte-, wyde-, tetra- als auch octaweise erfolgen knnen, sind zwei Steuerleitungen zur Bestimmung des Zugriffstyps notwendig es wird folgende Codierung verwendet:
Zugriffsart Byte Wyde Tetra Octa Codierung 00 01 10 11

um dem Speicher mitzuteilen, wenn er am Dateneingang anliegende Daten bernehmen/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:


2 ZugriffsArt 64 SchreibDaten Schreiben

64 Adresse

LeseDaten

64

DatenSpeicher

Abb. 126: Datenspeicher

33

Fr Lese- und Schreibzugriffe werden bei realen Speichern in der Regel die selben Adress- und Datenleitungen verwendet; um Zugriffe auf den Datenspeicher mglichst einfach zu gestalten, verfgt der hier verwendete Datenspeicher ber getrennte Datenleitungen zum Lesen und Schreiben.

4-3

Funktionsweise des Datenspeichers: Lesen + zum Lesen eines Datums aus dem Datenspeicher wird die Adresse des auszulesenden Datums an den Eingang Adresse angelegt + zustzlich wird an den Eingang Zugriffsart diejenige Codierung angelegt, die dem gewnschten Zugriff entspricht (z.B. 00 fr byteweisen Zugriff) + am Ausgang Lesedaten wird dann automatisch das gewnschte 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 Eingnge die gewnschten 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 Allzweckregister verfgt. Da fast jeder MMIX-Befehl Register verwendet, wird als nchstes der Registerblock, 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 ausschlielich lesend zugegriffen. Zur Realisierung der Schreibzugriffe auf $X sind drei Eingnge notwendig: Ein 64 Bit breiter Daten-Eingang (Schreibdaten $X), an den das zu speichernde Datenwort angelegt wird. Ein 8 Bit breiter Adress-Eingang (Schreiben/Lesen $X), mit dem das Register ($0$255) ausgewhlt 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 Register ablegen soll.

Zur Realisierung der Lesezugriffe auf $X, $Y und $Z wird jeweils ein Ein- und ein Ausgang bentigt: Die Eingnge (Schreiben/Lesen $X, Lesen $Y bzw. Lesen $Z) dienen zur Auswahl der Register, die ausgelesen werden sollen; da 256 Register zur Verfgung stehen, mssen die AdressEingnge jeweils 8 Bit breit sein. Die Ausgnge (Lesedaten $X, Lesedaten $Y und Lesedaten $Z) dienen zur Ausgabe des Datenworts und mssen deshalb jeweils 64 Bit breit sein.

4-4

Damit stellt sich der Registerblock auf Mikroarchitektur-Ebene wie folgt dar:

Registerblock
Schreiben $X

64 8 8

SchreibDaten $X Schreiben/ LeseLesen $X Daten $X Lesen $Y LeseDaten $Y

64 64

8
Lesen $Z

LeseDaten $Z

64

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 Adresse (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 zunchst 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 entsprechende Register $X bernommen. Lesen von Register $Y + Zum Lesen von Register $Y wird an den Eingang Lesen $Y die Adresse (ein Wert zwischen 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 zwischen 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-5

4.1.4 Register Die im Registerblock untergebrachten 256 Allzweckregister lassen sich einzeln wie folgt darstellen:
Clk D0 D1 Q0 Q1 D 64 D63 Q63 Q 64 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:
2 0 1 1 0 Clk D0 D1 Q0 Q1 1 3 5 0

0 4

1 1

D63 Q63

Abb. 129: Schreiben in ein Register

Zuerst werden Daten (Logikpegel) an die Eingangsleitungen D0D63 angelegt (1). Bei einer steigenden Flanke am Takteingang Clk (2) werden die am Eingang anliegenden Daten 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 knnen 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 verfgen ber einen Dateneingang (D), einen Datenausgang (Q) und einem Takteingang (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 Verfgung gestellt da die Daten am Dateneingang ausschliesslich bei positiven Flanken der Taktleitung bernommen werden, kann sich bei konstantem Takteingang bzw. bei fallenden Flanken am Takteingang das Datenwort am Dateneingang beliebig ndern, ohne vom Register bernommen zu werden

4-6

Clk D0 D1 D2 Q0 Q1 Q2

Clk

D
Q 64

Clk

Q neues Datenwort

D 64

neues Datenwort neues Datenwort sonst

altes Datenwort

D63 Q63
Abb. 130: Register mit 64 Bit Wortbreite

Schieberegister Schieberegister verhalten sich wie Register, knnen jedoch zustzlich das abgespeicherte Wort um eine Stelle nach links (Links-Schiebe-Register) oder nach rechts (Rechts-Schiebe-Register) schieben Beispiel fr ein 128 Bit breites Rechts-Schiebe-Register
Clk Init/>>1 D0 D1 D2 Q0 Q1 Q2 128 D126 Q126 D127 Q127 Clk Init/>>1

D neues Datenwort neues Datenwort

Init/>>1 0 0 1 1

Clk

Q neues Datenwort

sonst

altes Datenwort altes Datenwort >> 1

Q 128

X X

sonst

altes Datenwort

>> low-Pegel (0), ist die Init-Funktion ausgewhlt hat die Auswahlleitung + 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 >> high-Pegel (1), ist die Schiebe-Funktion ausgewhlt + 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 Befehlen 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 Verknpfungen mssen bitweise Operatoren auf Datenworte angewandt werden. Alle diese Berechnungen fhrt der Prozessor im sog. Rechenwerk aus, das auch kurz ALU (Arithmetic Logic Unit) genannt wird.

4-7

Nachfolgende Abbildung zeigt das Rechenwerk auf Mikroarchitektur-Ebene.


Funktionsauswahl 8 Operand 1 64 ALU 64 Operand 2 64 64 10 Divisionsrest/ Produktberhang Ergebnis

Statusinformationen

Abb. 131: ALU

Funktionsweise der ALU auf Mikroarchitektur-Ebene + an die beiden Eingangsleitungen Operand 1 und Operand 2 werden die Operanden angelegt + ber die 8 Eingangsleitungen Funktionsauswahl wird die Funktion der ALU ausgewhlt, ihr also mitgeteilt, ob sie eine Addition, eine Subtraktion, eine Multiplikation etc. ausfhren soll + nach der Ausfhrung der gewnschten Operation gibt die ALU am Ausgang Ergebnis das Ergebnis der Operation aus, bei der Addition also die Summe der Operanden, bei der Multiplikation 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/Produktberhang ausgegeben

4.1.6

Steuerung

FAQs zur bung Divisionswerk und Steuerung

4.1.7 Multiplexer Multiplexer sind Auswahl-Schalter, die einen von mehreren Eingngen auf einen Ausgang schalten der Datenfluss beschrnkt sich auf logische Signale (0 oder 1). Der Datenfluss ist dabei nur vom Eingang zum Ausgang mglich; soll ein Eingang auf mehrere Ausgnge geschaltet werden knnen, muss ein sogl Demultiplexer verwendet werden. Die Auswahl des Eingangs, der auf den Ausgang geschaltet werden soll, wird ber den Steuerungsbus festgelegt. Hat der Multiplexer 2n Eingnge, muss der Steuerungsbus n Leitungen haben, um alle Eingnge adressieren zu knnen.

Steuerungsbus 2 Eingang 0 Eingang 1 Eingang 2 Eingang 3


0 1 2 3

Steuerungsbus 00 01 10 11

Ausgang Logikpegel des Eingangs 0 Logikpegel des Eingangs 1 Logikpegel des Eingangs 2 Logikpegel des Eingangs 3

Ausgang

Abb. 132: Multiplexer

4-8

Sollen Signale, die mehr als ein Bit umfassen, vom Eingang auf den Ausgang geschaltet werden knnen, muss ein sog. Bus-Multiplexer verwendet werden
2 4 0 4 1 4 2 4 3 4

Steuerungsbus 00 01 10 11

Ausgang Wort am Eingang 0 Wort am Eingang 1 Wort am Eingang 2 Wort am Eingang 3

Abb. 133: Bus-Multiplexer fr 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.

Steuerungsbus
2 0

Steuerungsbus
2

Ausgang 0 Ausgang 1 Ausgang 2 Ausgang 3 Eingang


4

0 1 2 3

4 4 4 4

Ausgang 0 Ausgang 1 Ausgang 2 Ausgang 3

Eingang

1 2 3

Abb. 134: 1 Bit- (links) und 4 Bit- (rechts) Demultiplexer

Demultiplexer knnen einen Eingang auf einen von mehreren Ausgngen legen. Die restlichen Ausgnge werden dabei auf logisch 0 gesetzt. Dabei beschrnkt sich der Datenfluss auf logische Signale (0 oder 1), es knnen also keine analogen Spannungswerte bertragen werden.

Steuerungsbus 00 01 10 11

Ausgang 0

Ausgang 1

Ausgang 2

Ausgang 3

Eingangspegel 0 0 0 0 Eingangspegel 0 0 0 0 Eingangspegel 0 0 0 0 Eingangspegel


Abb. 135: Wertetabelle Demultiplexers

Die Auswahl des Ausgangs, auf den der Eingang gelegt werden soll, geschieht wie beim Multiplexer n ber einen Steuerungsbus. Hat der Demultiplexer 2 Ausgnge, muss der Steuerungsbus n Leitungen haben, um alle Ausgnge adressieren zu knnen.

4-9

4.1.9

Decoder

Nachfolgende Abbildung zeigt einen Decoder.


Steuerungsbus 2
0 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 Mglichkeiten:

wird am Steuerungsbus eine binre Zahl angelegt, so wird der der binren Zahl entsprechende Ausgang auf 1 gesetzt alle anderen Ausgnge werden hierbei auf Low-Pegel gehalten

Steuerungsbus Ausgang 0 Ausgang 1 Ausgang 2 Ausgang 3 00 01 10 11 1 0 0 0 0 1 0 0 0 0 1 0 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 dnne 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

keine Verbindung

Verbindung

dnne Linie, also kein Bus

Abb. 138: Verbundene und nicht verbundene Leitungen

4-10

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 Herausfhrung der entsprechenden Leitungen aus dem Bus Zusammenfhrungen von Leitungen/Bussen werden ebenfalls durch Zahlen bzw. Zahlenbereiche gekennzeichnet die Unterscheidung zwischen der Aufteilung eines breiten Busses in schmlere Busse und der Zusammenfhrung schmlerer Busse zu einem breiten Bus muss anhand der Ein- und Ausgnge der an den Bus angeschlossenen Gerte getroffen werden

keine Verbindung

Verbindung

0..15 16

dicke Linie, also Bus


16 Bus besteht aus 16 Busleitungen 0..3 die Busleitungen 0..3 werden aus dem Bus herausgefhrt der Bus wird ein zwei kleinere Busse aufgeteilt oder zwei kleine Busse werden zu einem grossen Bus zusammengefhrt (muss dem Anschluss an Ein- und Ausgnge entnommen werden) 4

16

0..7

8..15

Abb. 139: Busse

4-11

4.2 Zusammensetzen des Datenpfads Nachdem jetzt alle Bauelemente bekannt sind, die zum Aufbau des Datenpfads bentigt 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 Befehlsspeichers die Adresse des auszulesenden Befehls angelgt werden da die Adresse whrend der gesamten Abarbeitung des Befehls am Datenspeicher anliegen soll, ist es zweckmig, sie in einem Register abzulegen das zu diesem Zweck verwendete Register hat den Namen Befehlszhler (abgekrzt BZ), engl. program counter (PC)
32 Adresse des nchsten Befehls BZ bernehmen

BZ
64 Adresse

BefehlsSpeicher
Daten 32

whrend die im Befehlszhler stehende Adresse den Befehlsspeicher adressiert und dafr sorgt, dass am Ausgang Daten des Befehlsspeichers das aktuelle Befehlswort erscheint, kann an den Dateneingang des Befehlszhlers bereits die Adresse des nchsten Befehls angelegt werden soll die am Eingang des Befehlszhlers anliegende Adresse in den Befehlszhler bernommen und damit an den Befehlsspeicher angelegt werden, muss dann nur noch am Takteingang des Befehlszhlers eine positive Flanke angelegt werden
4.2.2 Auswahl des nchsten Befehls

werden stets aufeinanderfolgende Befehle ausgefhrt, so muss der Befehlszhler immer um 4 erhht werden, da ein MMIX-Befehl 4 Byte umfasst und Speicher beim MMIX byteweise adressiert wird fr diesen Zweck kann ein Addierer verwendet werden, der zum aktuellen Stand des Befehlszhlers stets die Konstante 4 addiert

4 64

Add
64

64

BZ
64 Adresse

BefehlsSpeicher
Daten 32

bei einer positiven Flanke am Befehlszhler wird jetzt also immer das nchste Befehlswort am Datenausgang des Befehlsspeichers ausgegeben

4-12

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) fr die Ausfhrung des Befehls bentigt werden gem dem Beispiel in Abb. 104 (vgl. S. 3-26), das nachfolgend als Abb. 140 noch einmal aufgegriffen ist, werden MMIX-Befehle wie folgt codiert:

Marke

ADD $1,$2,$3

Kommentar

0x20 0x01 0x02 0x03

Opcode bersetztes Befehlswort:


31 24 23

X
16 15

Y
87

Z
7

00100000 00000001 00000010 00000011

1 Byte

1 Byte

1 Byte

1 Byte

Abb. 140: Befehlscodierung

aus diesem Codierungs-Beispiel ist ersichtlich, dass + der Opcode, also die Information darber, um welchen Befehl es sich handelt, an den Bits 3124 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 darberhinaus lsst sich aus Abb. 103 (vgl. S. 3-8) erkennen, dass der 8 Bit breite Direktope34 rand Z diejenige Zahl ist, die an den Bits 70 steht die Information, welcher Befehl gerade aus dem Befehlsspeicher geladen wurde bzw. welche Operanden (welche Register bzw. welcher Direktoperand) von diesem Befehl verwendet werden, kann dann wie folgt ermittelt werden:
4 64

Add
64 3124 Opcode des Befehls (z.B.0x20 fr ADD)

64

BZ
64 Adresse 2316 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)

BefehlsSpeicher
Daten 32

158

70

34

Die 16 und 24 Bit breiten Direktoperanden YZ bzw. XYZ werden hier nicht verwendet.

4-13

4.2.4

Bereitstellen der Operanden

die auf diese Weise zur Verfgung stehenden Registeradressen knnen wie folgt direkt zur Ansteuerung des Registerblocks verwendet werden

4 64

Add
64 3124 Opcode des Befehls (z.B.0x20 fr ADD) 64

BZ
64 Adresse 64 2316

Registerblock
Schreiben $X SchreibDaten $X Schreiben/ LeseLesen $X Daten $X

64

BefehlsSpeicher
Daten 32

Datenwort, dass in Register $X steht, z.B. 0x1111111111111111 Datenwort, dass in Register $Y steht, z.B. 0x2222222222222222 Datenwort, dass in Register $Z steht, z.B. 0x3333333333333333 auf 64 Bit erweiterter 8 Bit Direktoperand Z, z.B.

158

Lesen $Y

64 LeseDaten $Y

70

64 LeseLesen $Z Daten $Z 8

0 56

64

0x0000000000000003

die Operandenbereitstellung funktioniert wie folgt: + der 8 Bit breite Direktoperand Z kann den Bits 70 des Befehlsworts entnommen werden, muss jedoch noch auf 64 Bit erweitert werden, indem die Bits 638 hinzugefgt und auf Null gesetzt werden + an den Adresseingngen Schreiben/Lesen $X, Lesen $Y und Lesen $Z wird jeweils die Nummer (Zahl zwischen 0255) des Registers angelegt, das ausgelesen werden soll + an den Ausgngen Lesedaten $X, Lesedaten $Y und Lesedaten $Z werden vom Registerblock dann automatisch die 64 Bit breiten Datenworte ausgegeben, die in den adressierten Registern stehen + in obiger Abbildung sind die bereitgestellten Operanden fr 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

35

4.2.5

Ausfhren des Befehls/Berechnung von Daten

wenn die Operanden zur Verfgung stehen, knnen sie in das Rechenwerk/die ALU geleitet werden, wo dann die entsprechende Operation ausgefhrt wird, im Falle des oben angegebenen 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 Direktoperanden Z ausgewhlt werden knnen
35 Im Rahmen der Erstellung des Datenpfads werden die Direktoperanden Y, YZ und XYZ hier nicht bercksichtigt. Es wird nur die Untersttzung fr den Direktoperanden Z implementiert, da dieser am hufigsten verwendet wird.

4-14

4 64

Add
64 3124 Opcode des Befehls (z.B.0x20 fr ADD) 64

BZ
64 Adresse 64 2316

Registerblock
Schreiben $X SchreibDaten $X Schreiben/ LeseLesen $X Daten $X

Auswahl $Z oder Z 64

Auswahl der ALU-Funktion

BefehlsSpeicher
Daten 32

158

Lesen $Y

64 LeseDaten $Y 64 ALU 0 1 64 64 Ergebnis

70

64 LeseLesen $Z Daten $Z 8

0 56

4.2.6

Steuerung der Auswahl der ALU-Funktion und des Direktoperanden

damit die ALU wei, welche Operation sie durchfhren soll, wird eine Steuerung bentigt, die anhand des Befehls-Opcodes (z.B. 0x20 bei ADD $X,$Y,$Z) die entsprechende ALUFunktion auswhlt die Auswahl zwischen dem aus dem Register ausgelesenen Parameter $Z und dem Direktoperanden Z in Abhngigkeit 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 Befehlszhlers, also die bernahme eines neuen Befehls durch die Steuerung geschehen
4 64

Add
64 3124

Steuerung

64

BZ
64 Adresse 64 2316

Registerblock
Schreiben $X SchreibDaten $X Schreiben/ LeseLesen $X Daten $X

64

BefehlsSpeicher
Daten 32

158

Lesen $Y

64 LeseDaten $Y 64 ALU 0 1 64 64 Ergebnis

70

64 LeseLesen $Z Daten $Z 8

0 56

4-15

4.2.7

Ergebnis in den Registerblock schreiben

das von der ALU berechnete Ergebnis muss in den Registerblock zurckgeschrieben werden knnen, 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 unserem Beispiel ADD $1,$2,$3 die Zahl 0x01) bestimmt

4 64

Add
64 3124

Steuerung

64

BZ
64 Adresse 64 2316

Registerblock
Schreiben $X SchreibDaten $X Schreiben/ LeseLesen $X Daten $X

64

BefehlsSpeicher
Daten 32

158

Lesen $Y

64 LeseDaten $Y 64 ALU 0 1 64 64

70

64 LeseLesen $Z Daten $Z 8

0 56

4-16

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 durchgefhrt werden es muss also lediglich alternativ zu aktueller Befehl + 4 auch ein Additions-Ergebnis als neuer Wert fr den Befehlszhler bernommen werden knnen die Auswahl zwischen den Alternativen kann mit einem Multiplexer implementiert werden + da die Steuerung den Befehl, der gerade ausgefhrt wird, genau kennt, wei sie auch, ob gerade ein Sprungbefehl ausgefhrt wird oder nicht + die Steuerung kann also auch den Multiplexer steuern, der zur Auswahl des neuen Werts fr den Befehlszhler verwendet wird

4 64

Add
64 0 1 3124

Steuerung

64

BZ
64 Adresse 64 2316

Registerblock
Schreiben $X SchreibDaten $X Schreiben/ LeseLesen $X Daten $X

64

BefehlsSpeicher
Daten 32

158

Lesen $Y

64 LeseDaten $Y 64 ALU 0 1 64 64

70

64 LeseLesen $Z Daten $Z 8

0 56

4.2.9

Lesezugriffe auf den Datenspeicher

Auch bei Lesezugriffen auf den Datenspeicher (MMIX-Befehle LDB, LDW, LDT oder LDO) werden die Operanden $Y und $Z bzw. $Y und Z zunchst addiert, was mit dem bisher implementierten Datenpfad bereits ausgefhrt 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 Adresseingang angegebenen Adresse abgespeichert ist um dem Datenspeicher mitzuteilen, ob er einen 8 Bit Wert (Byte), einen 16 Bit Wert (Wyde), einen 32 Bit Wert (Tetra) oder einen 64 Bit Wert (Octa) auslesen soll, mssen die zwei Eingangsbits Zugriffsart des Datenspeichers von der Steuerung in Abhngigkeit 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-17

4 64

Add
64 0 1 3124

Steuerung

64

BZ
64 Adresse 64 2316

Registerblock
Schreiben $X SchreibDaten $X Schreiben/ LeseLesen $X Daten $X

2 ZugriffsArt Schreiben

64

BefehlsSpeicher
Daten 32

SchreibDaten

158

Lesen $Y

64 LeseDaten $Y 64 ALU 0 1 64 64

DatenSpeicher
Adresse LeseDaten

64

70

64 LeseLesen $Z Daten $Z 8

0 56

da das ausgelesene Datum bei den Ladebefehlen LDx $X,$Y,$Z|Z in das durch $X adressierte Register bernommen werden soll, muss der zuvor eingezeichnete Pfad zum Ablegen eines Ergebnisses in den Speicher noch um die Alternative Rckschreibewert kommt aus dem Datenspeicher ergnzt werden die Auswahl einer der beiden Mglichkeiten Rckschreibewert kommt von der ALU und Rckschreibewert kommt aus dem Datenspeicher kann wie zuvor bei der Auswahl des neuen Werts fr den Befehlszhler mit einem Multiplexer realisiert werden die Steuerung des Multiplexers erfolgt wieder durch die Steuerung

36

4 64

Add
64 0 1 3124

Steuerung

64

BZ
64 Adresse 64 2316

Registerblock
Schreiben $X SchreibDaten $X Schreiben/ LeseLesen $X Daten $X

2 ZugriffsArt Schreiben

64

BefehlsSpeicher
Daten 32

SchreibDaten

158

Lesen $Y

64 LeseDaten $Y 64 ALU 0 1 64 64

DatenSpeicher
Adresse LeseDaten

64 0 64 1

70

64 LeseLesen $Z Daten $Z 8

0 56

36 Der Buchstabe x in LDx steht hier fr 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-18

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 fr die Auswahl der Zugriffsart beim Schreiben eines Werts in den Datenspeicher muss dieser am Eingang Schreibdaten angelegt werden gemss Kapitel 0 wird bei einer positiven Flanke am Takteingang Schreiben das am Eingang Schreibdaten anliegende Datum im Datenspeicher an der Adresse abgespeichert, die am Eingang Adresse anliegt die positive Flanke kann wieder von der Steuerung erzeugt werden

4 64

Add
64 0 1 3124

Steuerung

64

BZ
64 Adresse 64 2316

Registerblock
Schreiben $X SchreibDaten $X Schreiben/ LeseLesen $X Daten $X

2 ZugriffsArt Schreiben

64

BefehlsSpeicher
Daten 32

SchreibDaten

158

Lesen $Y

64 LeseDaten $Y 64 ALU 0 1 64 64

DatenSpeicher
Adresse LeseDaten

64 0 64 1

70

64 LeseLesen $Z Daten $Z 8

0 56

Abb. 141: Single-Cycle-Datenpfad

4.3 Performance des Single-Cycle-Datenpfads Im Kapitel 3 haben wir gesehen, dass die MMIX-Befehle zur Ausfhrung eine bestimmte Zeit bentigen, die sog. Ausfhrungszeit. Diese ergibt sich daraus, dass die einzelnen Signale sich durch den Datenpfad hindurch ausbreiten mssen und die einzelnen Komponenten wie z.B. Registerblock, Speicher und ALU eine bestimmte Zeit bentigen, bis sie ihre Arbeit verrichtet haben. Die Funktionseinheiten des Datenpfades bentigen also eine gewisse Durchlaufzeit. In Kapitel 5 werden wir sehen, dass sich diese Durchlaufzeit aus der Aufsummierung sog. Gatterlaufzeiten ergibt.

4-19

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

Schreiben

255

2 1 0

C
0 1 2

D0 D1 D2

Q0 Q1 Q2

0 1 2 64 63

0 1 2
64

LeseDaten $X
64

SchreibDaten $X
64

63

D63 Q63 C

255
8 64

0 1 2

D0 D1 D2

Q0 Q1 Q2

0 1 2

Schreiben/ Lesen $X
8

63

0 1 2

D63 Q63 C D0 D1 D2 Q0 Q1 Q2

63

0 1 2
64

LeseDaten $Y
64

1 2

64

255
8

63

Lesen $Y
8

D63 Q63

63

C Lesen $Z
8 63 0 1 2

0 1 2
64

LeseDaten $Z
64

D0 D1 D2

Q0 Q1 Q2

1 2 64 63 8

255

D63 Q63

Abb. 142: Aufbau des Registerblocks aus Registern, Multiplexern und einem Demultiplexer

4-20

4.4.3

Register

Aufbau aus Flipflops

C D0 D

Q Q0 Q

C D1 D

Q Q1

C D63 D

Q Q63

Abb. 143: Realisierung eines 64 Bit-Registers aus 64 einzelnen flankengesteuerten Flipflops

Flipflop Vorlesungsfolien

4-21

Schieberegister Schieberegister, deren Inhalt nur um eine Stelle verschoben werden kann, knnen sehr leicht mit einem Multiplexer realisiert werden

Clk Init/>>1

Clk Init/>>1 D0 D1 D2 Q0 Q1 Q2 128 0 Clk D0 D1 D2 Q0 Q1 Q2

Dateneingang fr die Initialisierung

128

D126 Q126 D127 Q127 1

D126 Q126 D127 Q127

Datenausgang

Abb.: Symbol und Aufbau des Produkt-Schieberegisters

wird am Takteingang des verwendeten Registers 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 also eine Null an, wird die Funktion Init, also die Initialisierung des Schieberegisters ausgewhlt; 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 bernommen, 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 knnen, muss an das MSB des Eingangs 1 des Multiplexers anstelle der Null der Register-Ausgang Q0 angeschlossen werden

37

37

Mit Register ist hier stets das innerhalb des Schieberegisters verwendete Register gemeint.

4-22

4.4.4

Rechenwerk
Funktionsauswahl 8

$Y|Y
Art k E 64

05 6 64 UNDEinheit 64 64 64 64 ODEREinheit

<< A >>

64

0 1 2 3

$X

sub/add b 64 CLAAddierer/ Subtrahie- 64 rer a C O 64 MULU

0...63 64 DIVU 128 64127 64 64 64 64127 0...63

4 5 6

$Z|Z

64

64
0 1

CMPErweiterung

64

StatusEinheit

64

10

64 10 Statusinformationen
Abb. 144: MMIX-Rechenwerk

Rest der Division bzw. Bit 64127 des Produkts

die Auswahl-Leitung dient zur Auswahl der gewnschten Funktion (Addieren, Schieben etc.) die Statusinformationen geben beispielsweise Auskunft darber, 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-23

+ wird beim MMIX durch die Befehle SLU[I] und SRU[I] ausgefhrt arithmetisches Schieben + beim Linksschieben werden Nullen nachgezogen + beim Rechtsschieben wird das Vorzeichen nachgezogen + wird beim MMIX durch die Befehle SL[I] und SR[I] ausgefhrt Beispiel: Kombinatorischer Schieber fr n = 8
00 01 10 11 SL[I] SLU[I] SR[I] SRU[I] 0 1 3 3 3
0

k
3

berlauf

Eingang
8 7

Art k
8

<< A >>

Ausgang
8

1 3 2

Abb. 145: Symbol und Realisierung eines kombinatorischen Schiebers

Rechenwerk: Addition und Subtraktion wird auf Logik-Ebene durchgefhrt (bottom up)

4-24

Multiplikations-Werk
Allgemein

Nomenklatur: Produkt = Multiplikand Multiplikator bei Prozessoren ist die Wortbreite von Multiplikand und Multiplikator stets gleich Annahme: die Wortbreite der Operanden betrgt n Bit n + Wertebereich der Operanden maximal 0 2 1 + Ergebnis hat maximal ld[(2n 1) (2n 1)] 2n Stellen kein berlauf mglich
+ grtmgliches Ergebnis:

Zahl im 2er-Komplement wird zunchst in die Darstellung Vorzeichen und Betrag umgewandelt + 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 gehrige TeilProdukt entweder den Wert Null oder den Wert des Multiplikanden Beispiel (n = 4 Bit)
Multiplikand Multiplikator

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

Teilprodukte

bertrag

Produkt:

1 0 0 0 1 1 1 1
max. 2n Stellen

Hardware-Aufbau
links schieben

Multiplikand (2n Bit)


links schieben 2n Bit rechts schieben rechts schieben

2n Bit

2n-Bit Addierer
2n Bit

Multiplikator (n Bit)
LSB

Produkt (2n Bit)


bernehmen

Steuerung

Abb. 146: Prinzip-Darstellung des Multiplizierers nach dem ersten Verfahren

4-25

das Produkt befindet sich in einem 2n Bit breiten Register (vgl. Kap. 0.0) der Multiplikand und der Multiplikator befinden sich in sog. Schieberegistern Schieberegister sind Register, deren Inhalt nach links oder rechts geschoben werden kann (vgl. Kap. 0.0)
Nachfolgende Abbildung beschreibt das Verfahren, mit dem die oben angegebene Hardware-PrinzipSchaltung eine Multiplikation ausfhren kann. Hierbei meint Multiplikator[0] das LSB (least significant bit) des Multiplikators, also das Bit ganz rechts im Multiplikator-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

Start

Multiplikand im Multiplikand-Register ablegen

Multiplikator im Multiplikator-Registers ablegen

Produkt-Register mit 0 initialisieren

Multiplikator[0] Multiplikator[0] == 1 Produkt = Produkt + Multiplikand Multiplikator[0] == 0

Multiplikand = Multiplikand << 1

Multiplikator = Multiplikator >> 1 nein n Runden? ja Ende


Abb. 147: Erstes Multiplikationsverfahren

4-26

Beispiel: 3 4 = 12 (Wortbreite n = 4)
Multiplikand Initialisierung

0 0 0 0 0

0 0 0 0 0

0 0 0 0 1

0 0 0 1 1

0 0 1 1 0

0 1 1 0 0

1 1 0 0 0

1 0 0 0 0

1. Runde 2. Runde 3. Runde 4. Runde

Produkt = Multiplikand Multiplikator

Addierer
Initialisierung Produkt

Multiplikator

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

Initialisierung 3. Runde

0 0 0 0 0

1 0 0 0 0

0 1 0 0 0

0 0 1 0 0

1. 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 geschoben + 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 durchgefhrt werden kann (vgl. Kap. 4.4.3 und 4.4.4)

4-27

Multiplikand (n Bit)
n Bit rechts schieben rechts schieben

n-Bit Addierer
n Bit rechts schieben

Multiplikator (n Bit)
LSB

Produkt (2n Bit)


bernehmen n Bit rechts schieben Produkt rechts

Steuerung

Produkt links

Abb. 149: Prinzip-Darstellung des Multiplizierers nach dem zweiten Verfahren

Das Produktregister muss hier nach rechts geschoben werden knnen, also als Schieberegister ausgefhrt sein
Start

Multiplikand im Multiplikand-Register ablegen

Multiplikator im Multiplikator-Registers ablegen

Produkt-Register mit 0 initialisieren

Multiplikator[0] Multiplikator[0] == 1 Produkt links = Produkt links + Multiplikand Multiplikator[0] == 0

Produkt = Produkt >> 1

Multiplikator = Multiplikator >> 1 nein n Runden? ja Ende


Abb. 150: Zweites Multiplikationsverfahren

4-28

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)
n Bit

n Bit

n-Bit Addierer
n Bit rechts schieben

Produkt (2n Bit) bernehmen


LSB rechts schieben Produkt links (mit 0 initialisiert) Produkt rechts (mit Multiplikator initialisiert)

Steuerung

Abb. 151: Prinzip-Darstellung des Multiplizierers nach dem dritten Verfahren

4-29

Start

Multiplikand im Multiplikand-Register ablegen Multiplikator im rechten Teil des Produkt-Registers ablegen Linken Teil des Produkt-Registers mit 0 initialisieren

Produkt[0] Produkt[0] == 1 Produkt links = Produkt links + Multiplikand Produkt[0] == 0

Produkt = Produkt >> 1 nein n Runden? ja Ende


Abb. 152: Drittes Multiplikationsverfahren

4-30

Hardware-Multiplizierer nach dem 3. Verfahren


Nachdem nun die Verfahren zur Multiplikation dargestellt wurden, wird das 3. Multiplikationsverfahren als Schaltung implementiert.

Steuerung
0

Multiplikator n n 0 0..n-1 1 n..2n-1

Clk Init/>>1 0..n-1 Produkt >>1 n..2n-1 0 n 0 1 n n Bit Add n 2n Produkt 2n

MULU
2n

Clk Multiplikand n Multiplikand n

Abb. 153: Symbol und Aufbau des Multiplizierers nach dem 3. Verfahren

4-31

Divisions-Werk
Allgemein: Nomenklatur: Dividend / Divisor = Quotient + Rest Kein berlauf mglich Zahl im 2er-Komplement wird zunchst in die Darstellung Vorzeichen und Betrag umgewandelt + es werden nur vorzeichenlose Zahlen dividiert + das Vorzeichen wird separat betrachtet das Vorzeichen des Quotienten entspricht der XOR-Verknpfung von Dividend und Divisor 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 Dividend Divisor

9 8 7 6 : 0 0 5 4 =
1. Teildividend = 9
Passt 54 in 9? Nein nchsten Teildividenden probieren

Dividend

Divisor

9 8 7 6 : 0 0 5 4 = 1
2. Teildividend = 98
Passt 54 in 98? Ja Wie oft? 98 54 = 44 (1 mal) 44 54 = 10 (negativ bleibt bei 1 mal)

Dividend

Divisor

4 4 7 6 : 0 0 5 4 = 1 8
3. Teildividend = 447
Passt 54 in 447? Ja Wie oft? 447 54 = 393 (1 mal) 393 54 = 339 (2 mal) 339 54 = 285 (3 mal) 285 54 = 231 (4 mal) 231 54 = 177 (5 mal) 177 54 = 123 (6 mal) 123 54 = 069 (7 mal) 069 54 = 015 (8 mal) 015 54 = 39 (negativ bleibt bei 8 mal)

Dividend

Divisor

0 1 5 6 : 0 0 5 4 = 1 8 2 Rest 48
4. Teildividend = 156
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-32

selbes Prinzip bei Division in der Basis 2, Divisor kann hier jedoch maximal einmal in den Teildividenden 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 gepasst Hardware-Aufbau
rechts schieben

Divisor (2n Bit)


rechts schieben 2n Bit links schieben links schieben

2n Bit

2n Bit-ALU
2n Bit

Quotient (n Bit)
LSB

Rest (2n Bit)


bernehmen MSB

Steuerung

Abb. 154: Prinzip-Darstellung des Dividierers nach dem ersten Verfahren

Verfahren
Start

Dividend im Rest-Register ablegen

Divisor in linker Hlfte des Divisor-Registers ablegen

Divisor = Divisor >> 1

Quotient = Quotient << 1

Rest = Rest - Divisor

Rest 0

Rest < 0 Rest

Quotient = Quotient | 1

Rest = Rest + Divisor

n Runden? nein ja Ende

Abb. 155: Erstes Divisionsverfahren

4-33

Quotient = Quotient | 1 meint hier die logische ODER-Verknpfung der Zahl Eins mit dem Wert in Register Quotient und die anschliessende Abspeicherung des Ergebnisses im Register Quotient, also das Setzen des niederwertigsten Bits im Register Quotient da bei der Division nicht nur addiert, sondern auch subtrahiert werden muss, ist hier die Verwendung einer ALU (Arithmetic Logic Unit) notwendig, die sowohl addieren als auch subtrahieren 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 arithmetischen 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 2erKomplements 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 verzweigt werden
Divisor Init. 1. Runde 2. Runde 3. Runde 4. Runde 1er-Kompl. des Divisors 2er-Kompl. des Divisors

0 0 0 0 0

0 0 0 0 0

1 0 0 0 0

1 1 0 0 0

0 1 1 0 0

0 0 1 1 0

0 0 0 1 1

0 0 0 0 1

1 1 1 1

1 1 1 1

1 1 1 1

0 1 1 1

0 0 1 1

1 0 0 1

1 1 0 0

1 1 1 0

1 1 1 1

1 1 1 1

1 1 1 1

0 1 1 1

1 0 1 1

0 1 0 1

0 0 1 0

0 0 0 1

Quotient = Dividend : Divisor

Addierer

Quotient

Rest

X X X X 0

X X X 0 0

X X 0 0 1

X 0 0 1 0

1. Runde 2. Runde 3. Runde 4. Runde positiv negativ negativ

0 1 0 1 0 0 1 0

0 1 0 1 0 0 1 0

0 1 0 1 0 0 1 0

0 0 0 1 0 0 1 0

0 1 0 1 0 0 1 0

1 1 1 0 1 0 1 0

1 1 1 1 1 0 1 0

1 1 1 1 1 1 0 1

Initialisierung 1. Runde

2. Runde 3. Runde 4. Runde

Abb. 156: Beispiel zur Division nach dem ersten Verfahren

4-34

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 Hardware 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 durchgefhrt 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)
n Bit links schieben links schieben

n Bit

n Bit-ALU
n Bit Rest links bernehmen links schieben

Quotient (n Bit)
LSB

Steuerung

Rest (2n Bit)


MSB links schieben

Rest links

Rest rechts

Abb. 157: Prinzip-Darstellung des Dividierers nach dem zweiten Verfahren

das zur Hardware gehrige Verfahren ist in nachfolgender Abbildung angegeben

4-35

Start

Dividend im Rest-Register ablegen

Divisor im Divisor-Register ablegen

Rest = Rest << 1

Quotient = Quotient << 1

Rest = Rest - Divisor

Rest 0

Rest < 0 Rest

Quotient = Quotient | 1

Rest = Rest + Divisor

n Runden? nein ja Ende

Abb. 158: Zweites Divisionsverfahren

4-36

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 aufzubauen Vorteil: Das Quotientenregister kann eingespart werden

Divisor (n Bit)
n Bit

n Bit

n Bit-ALU
n Bit Rest links bernehmen links schieben LSB

Steuerung

Rest (2n Bit)


MSB links schieben

Rest links

Rest rechts

Abb. 159: Prinzip-Darstellung fr das dritte Divisions-Verfahren

Start

Dividend im Rest-Register ablegen

Divisor im Divisor-Register ablegen

Rest = Rest << 1

Rest = Rest - Divisor

Rest 0

Rest < 0 Rest

Rest = Rest | 1

Rest = Rest + Divisor

n Runden? nein ja Ende

Abb. 160: Drittes Divisionsverfahren

4-37

Hardware-Dividierer nach dem 3. Verfahren

nachfolgende Abbildung zeigt das Symbol und den Aufbau eines Dividierers, der nach dem 3. Verfahren arbeitet

Steuerung
Dividend n 0 n n 1 0 1 0 1..n-1 Clk Init/<<1 0..n-1 Rest <<1 n 0..n-1 n..2n-1 n..2n-1 Multiplexer neg n n Divisor n Divisor n b Clk n Bit Sub a n 0 n 1 0 2n Rest und Quotient 2n

DIVU
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 bertragen, wodurch das Wiederherstellen des zuvor im Rest-Register abgespeicherten Werts durch Rest = Rest + Divisor entfllt; 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

bercksichtigt man diesen Umstand, muss der dritte Divisionsalgorithmus leicht abgewandelt werden (vgl. nachfolgende Abbildung)

4-38

Start

Dividend im Rest-Register ablegen

Divisor im Divisor-Register ablegen

Rest = Rest << 1

Ergebnis = Rest - Divisor

Rest 0

Rest < 0 Rest

Rest = Ergebnis

Rest = Rest | 1

n Runden? nein ja Ende

Abb. 162: Auf die Hardware-Schaltung angepasster 3. Divisionsalgorithmus

4.4.5

Steuerung

Zustandsautomat Mit Multiplexern Mit PLA Mit (P)ROM

FAQs

4-39

5 Ebene der Digitalen Logik


5.1 Logikgatter
5.1.1 UND-Verknpfung (AND)

Eingang 1

Eingang 2 0 1 0 1

Ausgang 0 0 0 1

Eingang 1 Ausgang Eingang 2

0 0 1 1

5.1.2

ODER-Verknpfung (OR)

Eingang 1

Eingang 2 0 1 0 1

Ausgang 0 1 1 1

Eingang 1 Ausgang Eingang 2

0 0 1 1

5.1.3

NICHT-Verknpfung (NOT)
Eingang Ausgang 1 0

Eingang

Ausgang
0 1

5.1.4

NICHT-UND-Verknpfung (NAND)
Eingang 1 Eingang 2 0 1 0 1 Ausgang 1 1 1 0

Eingang 1 Ausgang Eingang 2

0 0 1 1

5-1

5.1.5

NICHT-ODER-Verknpfung (NOR)

Eingang 1

Eingang 2 0 1 0 1

Ausgang 1 0 0 0

Eingang 1 Ausgang Eingang 2

0 0 1 1

5.1.6

Exklusiv-ODER-Verknpfung/Antivalenz (XOR)

Eingang 1

Eingang 2 0 1 0 1

Ausgang 0 1 1 0

Eingang 1 Eingang 2

Ausgang

0 0 1 1

Die Exklusiv-Oder-Verknpfung lsst sich mit den bereits kennengelernten Gattern wie folgt implementieren:
Eingang 1 Eingang 1 Eingang 2 Eingang 2
Abb. 163: Symbol und Aufbau eines XOR-Gatters

Ausgang

Ausgang

5.2 Performance auf Logik-Ebene: Gatterlaufzeiten


5.2.1 Ein- und Ausgangspegel bei Logikschaltungen

wie aus den vorausgehenden Wertetabellen ersichtlich ist, bentigen die hier betrachteten Bauelemente an ihren Eingngen digitale Logik-Pegel (0 oder 1 bzw. low und high) und stellen an ihren Ausgngen wiederum digitale Logik-Pegel bereit Strom und Spannung sind jedoch analoge Grssen 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. nachfolgende Abbildung) liegt; UeLmax kann hierbei von Bauelement zu Bauelement verschieden sein und muss dem Datenblatt des Bauelements entnommen werden

5-2

+ ein Bauelement mit digitalem Eingang interpretiert eine Eingangsspannung genau dann als high-Pegel, wenn diese zwischen UeHmin und der Versorgungsspannung VCC (Voltage Collector 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 Eingangsspannung interpretiert
Eingangsspannungen, die als high-Pegel erkannt werden Vom Hersteller garantierter Ausgangs-Spannungs-Bereich fr high-Pegel SH = oberer Strspannungsabstand

U VCC UaHmin UeHmin

undefinierter Bereich
UeLmax UaLmax GND Eingangsspannungen, die als low-Pegel erkannt werden SL = unterer Strspannungsabstand

Vom Hersteller garantierter Ausgangs-Spannungs-Bereich fr low-Pegel

Abb. 164: Spannungspegel an Ein- und Ausgngen von Gattern

Damit Ausgnge von Logik-Bauelementen wieder an die Eingnge anderer Bauelemente geschaltet werden knnen ohne Gefahr zu laufen, Eingangspegel im undefinierten Bereich zu liefern liegt die maximale Ausgangsspannung UaLmax fr einen Low-Pegel deutlich unter demjenigen 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-Eingnge angeschlossen, so wird der Ausgang im Vergleich zum Anschluss nur eines Gatters strker belastet, was zu einem Absinken der Ausgangsspannung des Gatter-Ausgangs fhrt die maximale Anzahl der (Standard-) Gatter-Eingnge, die an einen Gatter-Ausgang angeschlossen 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 grsser der Eingangsstrom eines bestimmten Gatters grsser 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 mssen an einen Gatterausgang trotzdem mehr Gatter angeschlossen werden, als der Fan-Out zulsst, mu die Last auf mehrere Treiberbausteine verteilt werden

5-3

Treiberbausteine, die sich die Last teilen

Ausgangsgatter mit bestimmtem Fan-Out

mehrere Eingangs-Gatter

Abb. 165: Verteilung grosser Lasten auf mehrere Treiberbausteine

Durch das Einfgen zustzlicher Treiberbausteine verlngert sich die Zeit, die ein Signal vom Eingang bis zum Ausgang einer Schaltung bentigt. Man sagt auch die Anzahl der von der Schaltung bentigten Gatterlaufzeiten wird grsser. Was Gatterlaufzeiten genau sind und wie sie entstehen, behandelt der nchste Abschnitt.

5-4

5.2.2

Entstehung von Gatterlaufzeiten

in nachfolgender Abbildung ist ein Beispiel fr 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
U

VCC

GND t0 t1
Abb. 166: Idealer Spannungsverlauf an einem Gattereingang

aufgrund parasitrer Kapazitten an/in den Transistoren, mit denen Logik-Bauelemente realisiert werden, ergeben sich an den Ein- und Ausgngen von Logik-Bauelementen bei einem Wechsel des Logik-Pegels jedoch keine unendlich steilen Flanken, sondern Flanken mit exponentiellem An- bzw. Abklingen (vgl. Lade- bzw. Entladekennlinie eines Kondensators), wie in nachfolgender Abbildung angedeutet
U

VCC

GND t0 t1
Abb. 167: Realer Spannungsverlauf an einem Gattereingang

zeichnet man in den realen Spannungsverlauf die fr high- und low-Pegel erlaubten Spannungsbereiche ein, so ergeben sich nach den Zeitpunkten t0 und t1 Zeitverzgerungen

5-5

VCC UeHmin

UeLmax GND t0 LogikPegel high t1 t

undefiniert

undefiniert

low

Zeitverzgerung

Zeitverzgerung
Abb. 168: Zeitverzgerungen durch parasitre Kapazitten

diese Zeitverzgerungen fhren dazu, dass Logik-Bauelemente ber sogenannte Gatterlaufzeiten (propagation delay time) verfgen, im Folgenden auch Glz abgekrzt allgemein beschreibt die Gatterlaufzeit die Verzgerung, die zwischen einem Eingangssignal und seiner Wirkung am Ausgang des betrachteten Bauelements liegt
Logikpegel Eingang 1 Glz high low Logikpegel Ausgang high low
Abb. 169: Gatterlaufzeit

1 Glz

ergeben sich fr low-high- und high-low-bergnge unterschiedliche Verzgerungen, so wird die Gatterlaufzeit als Mittelwert der Verzgerungszeiten der beiden bergnge definiert

5-6

Logikpegel Eingang

high low Logikpegel Ausgang high low


Abb. 170: Ungleiche Verzgerungen fr fallende und steigende Flanken

5-7

5.2.3

Kritischer Pfad

bei Logik-Schaltungen spielt oft die Durchlaufzeit der Eingangssignale durch die Schaltung eine 38 grosse Rolle, da sie die Ausfhrungszeit der von der Schaltung implementierten Funktion bestimmt die Ausfhrungszeit 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 lngster Pfad genannt betrachtet man beispielsweise nachfolgende Zusammenschaltung elementarer LogikBausteine, deren Verzgerung je eine Gatterlaufzeit betrgt, so ergibt sich der kritische Pfad wie folgt:
Eingang 1 Eingang 2 Ausgang 5 Glz

kritischer Pfad
Abb. 171: kritischer Pfad

die Ausfhrungszeit der Schaltung ergibt sich zu 5 Glz, da auf dem kritischen Pfad 5 Gatter liegen und jedes Gatter (nach obiger Annahme) genau 1 Glz bentigt der Begriff Ausfhrungszeit bedeutet hierbei: 5 Glz, nachdem die Eingangssignale an die Schaltung angelegt wurden, liegt am Ausgang das gltige Ergebnis an zur Analyse einer aus mehreren Teilschaltungen zusammengesetzten Schaltung kann es sinnvoll sein, zunchst die Gatterlaufzeiten der Teilschaltungen zu bestimmen (vgl. z.B. Kap. 0.0 ) 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 Eingang 1 Eingang 2 Ausgang 4 Glz nach Eingang 1 5 Glz nach Eingang 2

kritischer Pfad nach Eingang 2


Abb. 172: kritischer Pfad nach Eingngen 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 bentigt, vor den Eingang 2 jedoch eine Schaltung, die nur 6 Glz bentigt, 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 binr kodierte Zahlen addiert, meint der Ausdruck von der Schaltung implementierte Funktion die Addition.

5-8

5.2.4

Verkrzung des kritischen Pfads durch Verwendung zustzlicher Hardware

durch zustzliche Hardware kann die Ausfhrungszeit einer Schaltung zu einem bestimmten Grad verringert werden nachfolgende Abbildung zeigt zwei logisch quivalente Mglichkeiten, Signale C1, C2 und C3 zu berechnen und die zugehrige Schaltungsrealisierung (vgl. hierzu auch Kapitel 0.0 )
C1 = G0 (P0 C0) C2 = G1 (P1 C1) C3 = G2 (P2 C2)
G2 P2 G1 P1 G0 P0 C0

C1 = G0 (P0 C0) C2 = G1 (P1 G0) (P1 P0 C0) C3 = G2 (P2 G1) (P2 P1 G0) (P2 P1 P0 C0)
G2 P2 G1 P1 G0 P0 C0

C1

C1

C2

C2

C3

C3

Abb. 173: Unterschiedliche Mglichkeiten zur Berechnung der Signale C1, C2 und C3

bestimmt man den kritischen Pfad beider Realisierungen, so ergibt sich fr die + linke Realisierung: 6 Gatterlaufzeiten + rechte Realisierung: 2 Gatterlaufzeiten dass die Annahme von nur 1 Gatterlaufzeit zum Durchlaufen eines Gatters mit vielen Eingngen gerechtfertigt ist, zeigt nachfolgende Open-Collector-Realisierung eines Mehrfach-ODERGatters

5-9

Abb. 174: Open-Collector-Realisierung eines Mehrfach-ODER-Gatters

der oben angegebenen Open-Collector-Realisierung (Fehler! Verweisquelle konnte nicht gefunden werden.) kann man entnehmen, dass die Anzahl der bentigten Transistoren direkt proportional zur Anzahl der Eingnge ist, weshalb im Folgenden zur Abschtzung des Hardwareaufwands einer Gatterschaltung die Summe der Daten-Eingnge der Elementargatter mit der Anzahl der zur Realisierung bentigten Transistoren gleichgesetzt wird bestimmt man nun mit diesem Ma den Hardwareaufwand fr die beiden in Fehler! Verweisquelle konnte nicht gefunden werden. angegebenen Realisierungen, so ergibt sich nherungsweise fr die + linke Realisierung: 12 Transistoren + rechte Realisierung: 25 Transistoren
Hardwareaufwand [Transistoren] rechte Realisierung 25 linke Realisierung

12

Ausfhrungszeit [Gatterlaufzeiten] 2 6
Abb. 175: Hardwareaufwand und Ausfhrungszeit

man erkennt leicht, das zur Reduzierung der Ausfhrungszeit auf ein Drittel nur knapp die doppelte Menge an Transistoren notwendig war

5-10

ein Ma dafr, wieviel mehr Hardware fr einen bestimmten relativen Gewinn an Ausfhrungszeit aufgewendet werden muss, ist der Vergleich der beiden Rechtecksflchen, die das Produkt Hardwareaufwand x Ausfhrungszeit darstellen

in der Schaltungssynthese wird hierfr im Allgemeinen der Ausdruck AT verwendet, wobei AT fr das Produkt aus Halbleiterflche (Area) und Ausfhrungszeit (Time) steht Abschtzungen fr die Beziehung Hardwareaufwand Ausfhrungszeit haben im AT-Ma dort 2 oft die Form A = const, AT = const oder AT = 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 Verknpfung der Eingangssignale ergeben. Im Gegensatz zu sequentiellen Schaltungen sind die Ausgangssignale kombinatorischer Schaltungen niemals auf Eingangssignale rckgekoppelt

Eingang 1 Eingang 2

kombinatorische Schaltung

Ausgang 1 Ausgang 2

f
Abb. 176: Kombinatorische Schaltung

Eingang n

Ausgang m

Die Schaltfunktion f bildet die Eingnge auf die Ausgnge ab. Dabei gilt: Ausgang i = f(Eingang 1, Eingang 2, , Eingang n)

5.3.2

Rechenwerk: Logik-Einheiten

NICHT-Einheit (NOT unit)

0 1

0 1

64

64

64 63 63

64

Abb. 177: Symbol und Aufbau der NICHT-Einheit (NOT unit)

ODER-Einheit (OR unit)

64

64

0 0 1 1

0 1 64

64 63 63 64 64 63

Abb. 178: Symbol und Aufbau der ODER-Einheit (OR unit)

5-12

UND-Einheit (AND unit)

64

64

0 0 1 1

0 1 64

64 63 63 64 64 63

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 0 0 1 1 Operand 2 0 1 0 1 bertrag in nchste Stelle 0 0 0 1 Ergebnis 0 1 1 0

Abb. 180: Wertetabelle 1-Bit Halbaddierer

bertrag entspricht UND-Verknpfung der Operanden Ergebnis entspricht XOR-Verknpfung der Operanden
1 Gatterlaufzeit

HA

Cout

Operand 1 Ergebnis bertrag (Carry Out)

Operand 2

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 NICHTGattern aufgebaut wurde, sondern als echtes Hardware-Gatter zur Verfgung steht, dann betrgt 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 bertrag aus der Stelle i zur Stelle i+1 dazuaddiert werden Halbaddierer muss um einen weiteren Eingang erweitert werden, der noch zu den anderen Eingnge 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 0 0 0 0 1 1 1 1 Operand 1 0 0 1 1 0 0 1 1 Operand 2 0 1 0 1 0 1 0 1
Abb. 182: Wertetabelle 1-Bit Volladdierer

bertrag in nchste Stelle 0 0 0 1 0 1 1 1

Ergebnis 0 1 1 0 1 0 0 1

5-14

Im Folgenden wird untersucht, wie sich der Volladdierer implementieren lsst.

fr den Fall, dass der bertrag aus der vorhergehenden Stelle Null ist, verhlt sich der Volladdierer wie ein Halbaddierer (in nachfolgender Abbildung grau unterlegt)
bertrag vorhergehender Stelle 0 0 0 0 1 1 1 1 Operand 1 0 0 1 1 0 0 1 1
Operand 1

Operand 2 0 1 0 1 0 1 0 1
Operand 2

bertrag in nchste Stelle 0 0 0 1 0 1 1 1


bertrag aus vorhergehender Stelle (Carry In)

Ergebnis 0 1 1 0 1 0 0 1

HA Co

bertrag in nchste Stelle (Carry Out)

Ergebnis (Summe)

ist der bertrag aus der vorhergehenden Stelle Eins, so sind die Werte des Ergebnisses im Vergleich zu den Werten des Ergebnisses fr den Fall bertrag aus vorhergehender Stelle ist Null genau invertiert die Invertierung des Ergebnisses in Abhngigkeit des Eingangs bertrag aus vorhergehender Stelle lsst sich sehr einfach mit dem XOR-Gatter eines weiteren Halbaddierers erreichen
bertrag vorhergehender Stelle 0 0 0 0 1 1 1 1 Operand 1 0 0 1 1 0 0 1 1
Operand 1

Operand 2 0 1 0 1 0 1 0 1
Operand 2

bertrag in nchste Stelle 0 0 0 1 0 1 1 1


bertrag aus vorhergehender Stelle (Carry In)

Ergebnis 0 1 1 0 1 0 0 1
1

HA Co HA Co

bertrag in nchste Stelle (Carry Out)

Ergebnis (Summe)

5-15

ist der bertrag aus der vorhergehenden Stelle Null, leitet das XOR-Gatter den ErgebnisAusgang des ersten Halbaddierers einfach an den Ausgang des Volladdierers weiter (vgl. Wertetabelle fr 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 fr 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 vorherigen Stelle stattfand (3)
bertrag vorhergehender Stelle 0 0 0 0 1
3

Operand 1 0 0 1 1 0 0 1 1
2 2

Operand 2 0 1 0 1 0 1 0 1

bertrag in nchste Stelle 0 0 0


1

Ergebnis 0 1 1 0 1 0 0 1

1 0 1 1

1 1 1

da Operand 1 und Operand 2 genau dann unterschiedliche Werte haben, wenn der ErgebnisAusgang des ersten Halbaddierers den Wert Eins hat (XOR-Verknpfung), kann der Volladdierer unter Verwendung des noch freien UND-Gatters des zweiten Halbaddierers wie folgt implementiert werden:
Operand 1 Cin Operand 2 bertrag aus vorhergehender Stelle (Carry In) 3 Glz (Gatterlaufzeiten)

HA Co

VA
Cout

HA Co

bertrag in nchste Stelle (Carry Out) Ergebnis (Summe)

Abb. 183: Symbol und Realisierung eines Volladdierers

da sowohl jeder Halbaddierer als auch die ODER-Verknpfung genau eine Gatterlaufzeit bentigt, 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
an-1 bn-1 an-2 bn-2 a2 b2 a1 b1 a0 b0 0 c0 Cin Cin Cin Cin Cin

VA
Cout cn-1 CarryOut Summen-1

VA

Cout cn-2 Summen-2

VA

c3 Summe2 Cout

VA

c2 Summe1 Cout

VA

c1 Summe0 Cout

C
Status-Register

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, indem b zuerst negiert und anschliessend zu a addiert wird, lsst sich der Ripple-Carry Addierer sehr einfach um die Subtraktion erweitern
an-1 bn-1 an-2 bn-2 a2 b2 a1 b1 a0 b0 sub/add

je 3 Glz
0 1 0 1 0 1 0 1 0 1

c0

Overflow Detection Unit

Cin

Cin

Cin

Cin

Cin

VA
Cout cn-1

VA

Cout

VA

c3 Cout

VA

c2 Cout

VA

c1 Cout

je 3 Glz (Gatterlaufzeiten)

Overflow

cn-2 Summen-1 Summen-2 bzw. Differenzn-1 bzw. Differenzn-2 CarryOut Summen-1 bzw. Differenzn-1

Summe2 bzw. Differenz2

Summe1 bzw. Differenz1

Summe0 bzw. Differenz0

O C
Status-Register

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 zugefhrt + es gilt c0 = 0 + Schaltung verhlt sich wie zuvor der Addierer Fall 2: Steuerleitung sub/add ist logisch 1 + den Volladdierern werden die invertierten Signale zugefhrt Bildung des 1erKomplements + c0 = 1 Addition des Wertes 1 umwandeln des 1er-Komplements in das 2erKomplement
5-17

+ Schaltung verhlt sich wie ein Subtrahierer die sog. Overflow Detection Unit berprft, ob sich bei einer vorzeichenbehafteten Interpretation der Operanden und des Ergebnisses ein berlauf ergeben wrde und zeigt diesen durch Setzen des Bits O (Overflow) in einem Status-Register an einfach und flchengnstig, jedoch sehr lange Ausfhrungszeit 39 + Summe: 6 + 2(n-2) + 1 Glz 40 + Carry Out: 6 + 2(n-1) Glz 41 + Overflow: 6 + 2(n-2) +3 Glz 64-Bit Carry-Look-Ahead (CLA) Addierer Idee: Berechnung der bertrge der einzelnen Volladdierer durch zustzliche Logik Verringerung der Ausfhrungszeit 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 bertrge ci (vgl. vorausgehende Abbildung): ci+1 = (ai bi) [(ai bi) ci] = gi (pi ci) gi = generate = ai bi Volladdierer i erzeugt einen bertrag (engl. to generate erzeugen) pi = propagate = ai 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 bernommen werden; aus Sicht der Sammelleitung wird also an der Stelle i kein Wasser generiert
Wasserspeicher i
42

gi-1 = 1 pi-1 = 0 gi = 0 pi = 1 gi+1 = 1 pi+1 = 1 Sammelleitung

Abb. 186: Wasserrohr-Analogie zu generate und propagate

39 40 41

6 Glz fr c1 + 2(n-2) Glz fr c2 cn-2 + 1 Glz fr den zweiten Halbaddierer des letzten Volladdierers. 6 Glz fr c1 + 2(n-1) Glz fr c2 cn-1 6 Glz fr c1 + 2(n-2) Glz fr c2 cn-2 + 3 Glz fr die Overflow Detection Unit 42 Die in diesem Kapitel betrachteten Carry-Look-Ahead Addierer knnen aufgrund der Invertierung der bi und aufgrund des Setzens von c0 auf den Wert eins natrlich auch subtrahieren. Der Einfachheit halber werden sie jedoch auch weiterhin einfach nur CLA-Addierer genannt. Der Hinweis auf die ebenfalls mgliche Subtraktion entfllt somit.

5-18

konkret ergibt sich fr die bertrge ci des einstufigen CLA-Addierers durch Auswertung obiger rekursiver Formel
c1 = g0 (p0 c0) c2 = g1 (p1 c1) = g1 (p1 g0) (p1 p0 c0) c3 = g2 (p2 c2) = g2 (p2 g1) (p2 p1 g0) (p2 p1 p0 c0) c4 = g3 (p3 c3) = g3 (p3 g2) (p3 p2 g1) (p3 p2 p1 g0) (p3 p2 p1 p0 c0) c5 = .
a3 b3 a2 b2 a1 b1 a0 b0 sub/add

g3 c4

p3 c3

g2

p2 c2

g1

p1 c1

g0

p0 c0

Cin

Cin

Cin

Cin

VA
Cout

VA

Cout

VA

Cout

VA

Cout

Summe3 g3 p g2 3 p g1 2 p g0 1 p c0 0

Summe2

Summe1

Summe0

Abb. 187: Einstufige Carry-Look-Ahead Technik

da der Hardwareaufwand mit zunehmender Wortbreite stark anwchst, liegt es nahe, anstelle eines einstufigen CLA-Addierers mit grosser Wortbreite mehrere einstufige CLA-Addierer mit kleinerer Wortbreite zu verwenden fr die Menge der kleineren einstufigen CLA-Addierer werden dann wesentlich weniger Gatter bentigt als fr einen entsprechend grossen einstufigen CLA-Addierer wenn die CLA-Addierer analog zu den einzelnen VA-Stufen ber die Signale Carry-In, Generate und Propagate verfgen, 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 zusammen, so ergeben sich dessen Signale G und P wie folgt:
c4 = g3 (p3 g2) (p3 p2 g1) (p3 p2 p1 g0) (p3 p2 p1 p0 c0) G ( P c0 )

nachfolgende Abbildung zeigt das Symbol fr einen solchen einstufigen CLA-Addierer mit der Wortbreite n = 4 Bit
5-19

4 a G P b

einstufig CLA
4

Bi C

Abb. 188: Symbol eines einstufigen CLA Addierers

die Steuerleitung Bi dient hier zur Auswahl der invertierten Eingnge Carry-In, also dem bertrag aus der vorhergehenden Stelle

, C entspricht dem

der Aufbau eines einstufigen CLA-Addierers mit n = 4 ergibt sich wie nachstehend angegeben:
a 4 b 4

Bi a3 b3 a2 b2 a1 b1 a0 b0

g3 G

p3 c3 Cin

g2

p2 c2 Cin

g1

p1 c1 Cin

g0

p0 c0 Cin C

VA
Cout P g2 p g1 2 p g0 1 p c0 0

VA

Cout Summe2

VA

Cout

VA

Cout Summe0

Summe3

Summe1

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 fr die einzelnen Addierer die Signale P und G wie folgt
pi = ai bi je 1 Gatterlaufzeit nach ai bzw. bi P0 P1 P2 P3 P4 = = = = = p3 p7 p11 p15 p2 p6 p10 p14 p1 p5 p9 p13 p0 p4 p8 p12

2 Glz

pi = ai bi bzw. gi = ai bi je 1 Gatterlaufzeit nach ai bzw. bi

G0 G1 G2 G3 G4

= = = = =

g3 g7 g11 g15

(p3 (p7 (p11 (p15

g2) g6) g10) g14)

(p3 (p7 (p11 (p15

p2 p6 p10 p14
2 Glz

g1) g5) g9) g13)

(p3 (p7 (p11 (p15

p2 p6 p10 p14

p1 p5 p9 p13

g0) g4) g8) g12)

2 Glz

2 Glz

3 Glz

als Ausfhrungszeit 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 fr Auswahl Addition/Subtraktion) + P: 5 Glz nach a, b (2 Glz nach ai, bi + 3 Glz fr Auswahl Addition/Subtraktion)

5-21

Zweistufiger Carry-Look-Ahead Addierer nachstehende Grafik zeigt, wie vier einzelne je vier Bit breite CLA-Addierer zu einem zweistufigen 16 Bit breiten CLA-Addierer zusammengeschaltet werden

Operand 1
1512 1512 4 a einstufig CLA 4 1512 G3 P3 C3 G2 P2 b 4 Bi a einstufig CLA 4 118 C2 G1 P1 118 4 b 4 Bi a einstufig CLA 4 74 C1 G0 P0 118 74 4 b 4 Bi a einstufig CLA 4 30 C0 74 30 4 b 4 Bi 30

Operand 2 Bi (fr Subtraktion)

Summe bzw. Differenz

Carry-Look-Ahead-Einheit

GG0

PP0

CC0

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 (P0 C0) C2 = G1 (P1 G0) (P1 P0 C0) C3 = G2 (P2 G1) (P2 P1 G0) (P2 P1 P0 C0)
5 Glz 6 Glz nach a, b nach 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 eine Menge zweistufiger CLA-Addierer zu einem dreistufigen CLA-Addierer zusammengeschaltet wird, ist die Berechnung des bertrags C4 hier nicht notwendig bei Bedarf knnte C4 jedoch analog zu c4 wie folgt berechnet werden:
C4 = G 3 (P3 G2) (P3 P2 G1) (P3 P2 P1 G0) (P3 P2 P1 P0 C0)

die Eingnge CC0, G3 und P3 werden von der Carry-Look-Ahead-Einheit ohne nderung auf die Ausgnge C0, GG0 und PP0 weitergeleitet fr die Ausfhrungszeit ergibt sich hier + Ci: 8 Glz nach a, b bzw. 2 Glz nach CC0 (s.o.) + Summe: 11 Glz nach a, b (3 Glz fr Summe nach Ci + 8 Glz fr Ci nach a, b) bzw. 5 Glz nach CC0 (5 Glz fr Summe nach Ci + 2 Glz fr Ci nach CC0) + GG0: 6 Glz nach a, b (GG G) + PP0: 5 Glz nach a, b (PP P)

5-22

Dreistufiger Carry-Look-Ahead Addierer zur Erweiterung des Addierers von 16 auf 64 Bit knnen vier zweistufige 16 Bit breiten CLAAddierer zu einem dreistufigen 64 Bit breiten CLA-Addierer wie folgt verschaltet werden:

64 a

64 b

Carry-Look-Ahead-Einheit
GG3 PP3

Carry-Look-Ahead-Einheit

Carry-Look-Ahead-Einheit

Carry-Look-Ahead-Einheit
CC0

CC3 GG2 PP2

CC2 GG1 PP1

CC1 GG0 PP0

Carry-Look-Ahead-Einheit
CC4

Carry out Overflow

c63

Overflow Detection Unit

sub/ add

64

die bertrge CC1 bis CC4 werden von der grossen CLA-Einheit analog zu C1 bis C4 bzw. c1 bis c4 erzeugt:
6 Glz nach a, b 5 Glz nach a, b

CC1 = GG0 (PP0 CC0) CC2 = GG1 (PP1 GG0) (PP1 PP0 CC0) CC3 = GG2 (PP2 GG1) (PP2 PP1 GG0) (PP2 PP1 PP0 CC0) CC4 = GG3 (PP3 GG2) (PP3 PP2 GG1) (PP3 PP2 PP1 GG0) (PP3 PP2 PP1 PP0 CC0)
7 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 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 Ausfhrungszeit + Carry Out: 8 Glz nach a, b + Overflow: 15 Glz nach a, b (3 Glz fr Overflow nach c63 + 2 Glz fr c63 nach C15 + 2 Glz fr C15 nach CC3 + 8 Glz fr CC3 nach a, b) + Summe: 13 Glz nach a, b (5 Glz fr Summe nach CCi + 8 Glz fr 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 bentigt zwar doppelt so viele Transistoren wie der Ripple-Carry-Addierer, ist dafr aber 10 mal schneller
43

5.3.4 Status-Einheit Die in Kap. 2.8.8 und 2.8.9 aufgefhrten MMIX-Befehle fhren bestimmte Operationen in Abhngigkeit 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 berprft und das Ergebnis als Statusinformation am Ausgang bereitstellt
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

63 64

StatusEinheit

64

Abb. 191: Symbol und Aufbau der Status-Einheit

5.3.5

Multiplexer

Nachfolgende Abbildung zeigt den Aufbau eines 4:1 Multiplexers aus Logikgattern.

43

Berechnung der Anzahl der Transistoren gem Kap. Fehler! Verweisquelle konnte nicht gefunden werden..

5-24

Steuerungsbus 2

Eingang 0 Eingang 1 Eingang 2 Eingang 3

Ausgang

Abb. 192: Aufbau eines Multiplexers

Im Folgenden wird am Beispiel der Wortbreite n = 4 gezeigt, wie sich ein Bus-Multiplexer aus mehreren parallelen 1-Bit Multiplexern zusammensetzen lsst:
2

Steuerung

Bus-Eingang 0

0 1 2 3

Bus-Eingang 1

0 1 2 3

Bus-Ausgang Bus-Eingang 2
0 1 2 3

Bus-Eingang 3

0 1 2 3

Abb. 193: Aufbau eines Bus-Multiplexers

5-25

5.3.6

Demultiplexer/Decoder

5.4 Aufbau der Sequentiellen Funktionseinheiten


5.4.1 5.4.2 5.4.3 Was bedeutet sequentiell? Speicher Register

5.4.4

Additions- und Subtraktions-Werk

5-26

5.4.5 Verwendung des Subtraktionswerks fr 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 1111) + die Null als Ergebnis lassen (0 entspricht 0000) + jedes positive Ergebnis in 1 wandeln (1 entspricht 0001) nachfolgend angegebene Schaltung fhrt diese Operationen durch:

CMP-Erweiterung
64 sub/add = 1 64 b CLAAdd/ Sub a 64 012 002 112 002 hat high-Pegel, wenn das Ergebnis negativ ist 63 1
0 1 2 3

hat high-Pegel, wenn das Ergebnis den Wert Null hat 0 2 64 2 0 1 0 1 2 3 4 63

64

64

Abb. 194: Subtrahierer mit CMP-Erweiterung

Bit 0 des Multiplexer-Ausgangs wird direkt an den Ausgang der CMP-Erweiterung weitergereicht, Bit 1 wird zuvor auf die Bits 163 erweitert, so dass am 64 Bit breiten Ausgang der CMP-Erweiterung die Bits 163 alle dem Bit 1 des Multiplexer-Ausgangs entsprechen die NOR-Einheit berprft 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 163 liegt am Ausgang dann der Wert 00002 (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 163 erweitert Bit 163 haben den Wert 0 am Ausgang der CMP-Erweiterung liegt also der Wert 00012 (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 163 erweitert Bit 163 haben den Wert 1 am Ausgang der CMP-Erweiterung liegt also der Wert 111112 (also -110) an
5-27

6 Performance-Erhhung auf Mikroarchitektur-Ebene


6.1 Multi-Cycle-Datenpfad

In einem vorangegangenen Kapitel wurde gezeigt, dass die Taktung des Befehlszhlers durch die Steuerung erfolgt. Die Steuerung wiederum verwendet zur Erzeugung des bentigten 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 Befehlszhlers ein neuer Befehl aus dem Befehlsspeicher geladen und dann vom Datenpfad ausgefhrt da beim Single-Cycle-Datenpfad immer nur ein Befehl im Datenpfad verarbeitet werden kann, darf jeder Befehl zur Ausfhrung maximal die Zeit zwischen zwei positiven Taktflanken, also maximal die Zeit eines Taktzyklusses bentigen das gilt sowohl fr Befehle, die schnell ausgefhrt werden knnen (z.B. eine ODERVerknpfung), als auch fr Befehle, die zur Ausfhrung viel Zeit bentigen (z.B. eine Division)

Im Umkehrschluss muss die Taktzykluszeit also mindestens so lang sein, dass auch der lngste Befehl vollstndig abgearbeitet werden kann.

die minimale Dauer eines Taktzyklus (und damit die Ausfhrungszeit jedes Befehls) ergibt sich damit aus der Ausfhrungszeit des lngsten 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 Befehlsausfhrung (grau markiert) bei kurzen Befehlen folglich nur den Bruchteil eines Taktzyklus dauert, der Datenpfad fr den Rest des Taktzyklus also ungenutzt bleibt:

Takt Befehlsausfhrung Datenpfad luft leer


Abb. 196: Leerlaufen des Datenpfads

6-1

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 krzere Befehle sehr hufig ausgefhrt werden. Quantitative Untersuchungen zeigen, dass gerade dieser Fall sehr hufig vorkommt. Das trifft auch auf unsere bisher kennengelernten MMIX-Programme zu

die am hufigsten auftretenden Befehle sind ADD, SUB, OR, AND, SL, SR etc., also Befehle, die 44 sehr schnell (im MMIX-Simulator in 1 , also in 1 Takt) ausgefhrt werden knnen der lngste MMIX-Befehl, der DIV-Befehl, der beim MMIX-Simulator 60 Takte dauert, wird fast nie verwendet, bremst jedoch aufgrund seiner Lnge die anderen Befehle aus

Da bei einem Single-Cycle-Datenpfad die Ausfhrungszeit jedes Befehls auf die Ausfhrungszeit des lngsten Befehls gestreckt wird, wrde der MMIX-Simulator in Single-Cycle-Realisierung zur Ausfhrung unserer Programme (bei Vernachlssigung der Speicherzugriffe) bis zu 60 mal lnger zur Ausfhrung bentigen. Wie man diese stark erhhte Ausfhrungszeit umgehen kann, wird im nchsten Kapitel beim Multi-Cycle-Datenpfad aufgezeigt.

44 Bei unseren Programmen kommen auch die Speicher- und Ladebefehle STO und LDO sehr hufig vor. Diese Befehle dauern aufgrund des Speicherzugriffs zwar sehr lange, die vom Prozessor auszufhrende Arbeit beschrnkt 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 ausfhrbaren Operation entspricht.

6-2

6.2 Pipelining

Gleichzeitige Nutzung der Ressourcen unterschiedlicher Multi-Cycle-Datenpfad-Stufen Erhhung des Befehls-Durchsatzes durch Parallelisierung
6.2.1 Implementierung

Erweiterung des Multi-Cycle-Datenpfades um Pipeline-Register, welche die komplette Steuerinformation fr jede Stufe enthalten.

Sp.-Puls Reg.-Schreiben Ergebnisauswahl ES Sp.-Schreiben Zugriffs-Art 2 SP

4 64 Add 64 64 Clk1

Reg.-Puls

ES SP
Clk3 2 Clk4
Zugriffs- SchreiArt ben

Steuerung ALU-Funktion 8
24..31 X-Auswahl
Direktoperand Clk2

AF

ES

32

BZ
64 64 Adresse

Registerblock
Schreiben Schreib64 Daten $X LeseDaten $X Schreiben/ LeseLesen $X Daten $Y LeseDaten $Z Lesen $Y Lesen $Z

64

16..23 0 32

$X
64

$X
64

64

SchreibDaten

BefehlsSpeicher
Daten 32

BR
1

$Y
64

$Z
Dir Op.

0 1

ALU 64

Erg ALU

Adr.

LeseDaten

Lese Dat. Erg ALU

0 1

8..15 0..7

DatenSpeicher
64

64 56

16..23
8

8 8 64

6-3

Funktion der Pipeline-Stufen + BH: Befehl holen Auslesen des durch den Befehlszhler BZ adressierten Befehls aus dem Befehlsspeicher Ablegen des ausgelesenen Befehls in das Befehlsregister BR Inkrememtieren des Befehlszhlers + BD: Befehl dekodieren und Operanden bereitstellen Interpretation des Opcodes des im Befehlsregister stehenden Befehls durch die Steuerung Generierung der fr die weiteren Pipeline-Stufen bentigten Steuersignale durch die Steuerung Ablegen der generierten Steuersignale im nchsten Pipelineregister Auslesen der Operanden ($X, $Y und $Z) aus dem Registerblock Ablegen der ausgelesenen Operanden im nchsten Pipelineregister Abspeichern des Z-Operanden im nchsten Pipelineregister + AF: Befehl ausfhren Weiterleitung des $X-Operanden ins nchste Pipeline-Register ALU-Funktion aus Pipelineregister auslesen und der ALU zufhren Operanden aus Pipelineregister mit ALU-Funktion verknpfen Ergebnis im nchsten Pipelineregister abspeichern + SP: Speicherzugriff Weiterleitung des Ergebnisses der vorhergehenden Stufe in das nchste Pipelineregister Adressierung des Datenspeichers mit dem Ergebnis der vorangegangenen PipelineStufe Im Falle eines Ladebefehls Auslesen des adressierten Wortes aus dem Datenspeicher und Ablegen des aus dem Datenspeicher ausgelesenen Wortes im nchsten Pipelineregister Im Falle eines Speicherbefehls Abspeichern des $X-Wertes im Datenspeicher + ES: Ergebnis (zurck-) schreiben Adressierung des Zielregisters durch die im Pipelineregister stehende Adresse (X) Abspeichern des Ergebnisses im adressierten Zielregister

6.2.2

Auswirkung auf die Ausfhrungszeit

Maximal erreichbare Durchsatz-Erhhung entspricht der Anzahl der Pipeline-Stufen Maximale Taktrate entspricht dem Kehrwert der Ausfhrungszeit der langsamsten PipelineStufe Erhhung der Ausfhrungszeit von Einzelbefehlen durch Anpassung der Ausfhrungszeit der Pipeline-Stufen an die langsamste Pipeline-Stufe Minimierung der Erhhung der Ausfhrungszeit der Einzelbefehle durch hardwareseitig zeitlich gleichlange Pipeline-Stufen

6-4

6.2.3

Pipeline-Stufen-Fll-Diagramm

Befehlsfolge:

LDO LDO ADD OR STO ADD STO ADD STO SUB ...

$1,P1 $2,P2 $4,$2,$1 $4,$4,#F0 $4,ERG1 $4,$1,$1 $4,ERG2 $4,$2,$2 $4,ERG3 $5,$6,7 ...

Pipelinefllung (Idealfall ohne Pipeline-Konflikte)

BH LDO

BD LDO

AF LDO

SP LDO

ES LDO

BH ADD

BD ADD

AF ADD

SP ADD

ES ADD

BH LDO

BD LDO

AF LDO

SP LDO

ES LDO

BH STO

BD STO

AF STO

SP STO

BH ADD

BD ADD

AF ADD

SP ADD

ES ADD

BH ADD

BD ADD

AF ADD

BH OR

BD OR

AF OR

SP OR

ES OR

BH STO

BD STO

BH STO

BD STO

AF STO

SP STO

ES STO

BH SUB

6-5

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 zurckgeschrieben wurde Beispiel:

LDO LDO ADD


Lsung

$1,P1 $2,P2 $4,$2,$1

+ Forwarding-Pfade Zustzliche Datenleitungen im Datenpfad, die Ergebnis weiterleiten knnen Vor ALU Quellauswahl durch Multiplexer

AF
Befehlsausfhrung

SP
Speicherzugriff

ES
Ergebnis (zurck-) schreiben

Konflikt-Steuer-Einheit

64

64

Zugriffs- SchreiArt ben

$X
64 64

$X
0 1 2 64 ALU 64

SchreibDaten

$Y
64

$Z
Dir Op.

0 1

64

Erg ALU

Adr.

LeseDaten

Lese Dat. Erg ALU

0 1

DatenSpeicher
64 0 1 2 64

6-6

+ Stalls: Einfgen von nop-Befehlen (nop = no operation), die ausser einer Zeitverzgerung keine Funktion haben, also nicht schreibend auf Register oder Speicher zugreifen

BH LDO

BD LDO

AF LDO

SP LDO

ES LDO Forwarding-Pfad

BH LDO

BD LDO

AF LDO

SP LDO

ES LDO

Stall

Stall

Stall

Stall

Stall

Stall (eingefgter NOP-Befehl)

BH ADD

BD ADD

AF ADD

SP ADD

ES ADD

+ Alternative

BH LDO

BD LDO

AF LDO

SP LDO

ES LDO

Stall

BH ADD

BD ADD

BH LDO

BD LDO

AF LDO

SP LDO

ES LDO

Stall

BH STO

BH ADD

BD ADD

Stall

AF ADD

SP ADD

ES ADD

BH OR

Stall

BD OR

AF OR

SP OR

Stall

BH STO

BD STO

AF STO

6-7

+ Befehlsumstellung (code movement) Umstellung der Befehlsreihenfolge Vorziehen von Befehlen, deren Quell-Operanden nicht durch vorhergehende Operationen beeinflusst werden Sinnvolle Nutzung der Stall-Zeit (keine nops)

LDO LDO ADD OR STO ADD STO ADD STO SUB ...

$1,P1 $2,P2 $4,$2,$1 $4,$4,#F0 $4,ERG1 $4,$1,$1 $4,ERG2 $4,$2,$2 $4,ERG3 $5,$6,7 ...

LDO LDO ADD OR STO ADD STO ADD STO SUB ...

$1,P1 $2,P2 $4,$2,$1 $4,$4,#F0 $4,ERG1 $4,$1,$1 $4,ERG2 $4,$2,$2 $4,ERG3 $5,$6,7 ...

LDO LDO SUB ADD OR STO ADD STO ADD STO ...

$1,P1 $2,P2 $5,$6,7 $4,$2,$1 $4,$4,#F0 $4,ERG1 $4,$1,$1 $4,ERG2 $4,$2,$2 $4,ERG3 ...

6-8

Struktur-Konflikte (structural hazards) Gleichzeitiger Zugriff auf nur einmal verfgbare Ressourcen Beispiel

BH LDO

BD LDO

AF LDO

SP LDO

ES LDO

BH ADD

BD ADD

AF ADD

SP ADD

ES ADD

BH LDO

BD LDO

AF LDO

SP LDO

ES LDO

BH STO

BD STO

AF STO

SP STO

BH ADD

BD ADD

AF ADD

SP ADD

ES ADD

BH ADD

BD ADD

AF ADD

LDO LDO ADD OR STO

$1,P1 $2,P2 $4,$1,$2 $4,$4,#F0 $4,ERG1

BH OR

BD OR

AF OR

SP OR

ES OR

BH STO

BD STO

BH STO

BD STO

AF STO

SP STO

ES STO

BH SUB

LDO-Befehl schreibt Ergebnis in Registerblock zurck und muss dafr $X adressieren STO-Befehl will $X auslesen und muss es dazu ebenfalls adressieren

Lsung + Wenn mglich, Befehlsumstellung, so dass 3. Befehl nach LDO-Befehl wieder LDO-Befehl + Stalls

6-9

Steuerungs-Konflikte (control hazards) Treffen von Entscheidungen, die auf Ergebnissen vorhergehender Befehle beruhen Beispiel: Bedingter Sprung in einer Schleife

START

... ... SETL ... ... ... ... SUB PBNZ ...

... ... $1,30 ... ... ... ... $1,$1,1 $1,START ...

BH

BD

AF

SP

ES

BH

BD

AF

SP

ES

Aussage ber Sprungdurchfhrung frhestens hier mglich

BH SUB

BD SUB

AF SUB

SP SUB

ES SUB

Welchen Befehl holen?

BH PBNZ

BD PBNZ

AF PBNZ

SP PBNZ

ES PBNZ

BH ???

BD

AF

SP

ES

t1

t2

Problem: t1 < t2

Lsungen + Befehlsumstellung

START

... ... SETL SUB ... ... ... ... PBNZ ...

... ... $1,30 S1,S1,1 ... ... ... ... $1,START ...

+ Stalls + Sprungvorhersage (branch prediction): es wird ein bestimmtes Sprungziel angenommen


6-10

Konstante Vorhersage: Immer dasselbe Ergebnis vorhersagen 50 % Trefferquote Kontextabhngige Vorhersage Wahrscheinliche Verzweigung

do { ... } while(...)
Unwahrscheinliche Verzweigung

while(...) { ... }
MMIX-Befehlssatz: + BZ fr niedrige Sprungwahrscheinlichkeit + PBZ fr hohe Sprungwahrscheinlichkeit

6-11

6.3 Cache

6.3.1

Problemstellung

Leistungssteigerung Prozessoren >> Leistungssteigerung Speicherbausteine Stndig steigende Leistungsdifferenz (performance gap)
Leistung
Prozessor

performance gap

Speicher

Schnelle Speicher (z.B. SRAM) sehr teuer Billige Speicher (z.B. DRAM) sehr langsam
Kosten

1 Zugriffszeit

Kostenursache: Anzahl der Bauelemente pro Speicherzelle

SRAM
Adressleitung UB P N N N P N

DRAM
Adressleitung

Datenleitung

Datenleitung

Datenleitung

6-12

6.3.2

Speicherhierarchie

Ziel: Speichersystem mit dem


der schnellsten Technologie

Preis -Verhltnis der billigsten Technologie mit der Zugriffszeit Byte

Prinzip: + Zeitliche Lokalitt: Verwendete Daten werden bald wieder verwendet + rtliche Lokalitt Sequentielle Befehlsfolge, Schleifen Befehle in der Umgebung der verwendeten Befehle werden auch verwendet Analog bei Daten Realisierungsbeispiel

sehr schnell sehr klein sehr teuer

Register

Prozessor
1st level
sehr schnell sehr klein sehr teuer

CacheController

ArbeitsSpeicher

langsam gro billig

CacheSpeicher
2nd level

schnell klein teuer

+ 1st level cache Im Prozessor integriert Mit Prozessortakt getaktet SRAM Sehr schnell Hoher Verbrauch an Chipflche, da viele Transistoren + 2nd level cache Extern Niedrigerer Takt als Prozessortakt SRAM + Arbeitsspeicher Niedriger Takt DRAM

6-13

Ebenenmodell + Je schneller die Technologie, desto nher am Prozessor + Speicherzugriffszeit von der Hierarchie-Ebene des Datums abhngig + Datenaustausch nur zwischen benachbarten Ebenen (Austausch von Cache-Rahmen cache lines)

Register

1st level cache

2nd level cache

Arbeitsspeicher

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 vorrtig Hit time: Zugriffszeit fr die oberste Hierarchie-Ebene bei einem Hit, inklusive des Tests auf Hit oder Miss Miss-Penalty: Zugriffszeit fr 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
Fehlrate [%] 100 % unterschiedliche Programme 50 %

16

64

256

1k

4k

16 k

Cachegrsse [Byte]

6-14

Abhngigkeit der Treffer- bzw. Fehlrate + Cachegrsse + Art des Programms + Verdrngungsalgorithmus + Grsse der Nachladeeinheit + Cacheorganisation

6.3.3

Cacheorganisationen

Direktabgebildeter Cache (direct mapped cache)

ASP-Adresse Schlssel Rahmen-Nr. ByA 4 0 1 2 3 4 5 Tag Tag Tag Tag Tag Tag v v v v v v 15 15 15 15 15 15 14 14 14 14 14 14 Byteauswahl Byte 4 4 4 4 4 4 3 3 3 3 3 3 2 2 2 2 2 2 1 1 1 1 1 1 0 0 0 0 0 0

Rahmen, cache line

n-1

Tag

15 14

4 3

2 1

Tag-RAM beinhaltet den Schlssel derjenigen ASP-Adresse, deren Daten im Cache liegen Valid-Bit zur Kennzeichnung gltiger Cache-Eintrge Aufteilung der ASP-Adresse in + Byteauswahl: Dient bei Lesezugriffen der Auswahl der zu lesenden Byte + Rahmennummer: Whlt den zur ASP-Adresse gehrigen Rahmen aus + Schlssel Wird beim Schreibzugriff im Tag-RAM abgelegt Wird bei Lesezugriffen zur Hit-Erkennung verwendet Cachegrsse = (Rahmengrsse) Anzahl der Rahmen Anzahl der Rahmen = 2 Rahmengrsse = 2
Anzahl der Bits fr die Rahmennummer

Anzahl der Bits fr die Byteauswahl

Anzahl der Bits fr den Schlssel = Anzahl der Tag-Bits Anzahl der Tag-Vergleicher entspricht der Schlsselbreite

6-15

Feste Abbildung der Arbeitsspeicher-Adressen auf einen Cache-Rahmen Jeder Rahmen ist fr mehrere ASP-Adressen zustndig
ASP
0x00...00 0x00...01 0x00...02 0x00...03 0x00...04 0x00...05 0x00...06 0x00...07 0x00...08 0x00...09 0x00...0A 0x00...0B 0x00...0C 0x00...0D 0x00...0E 0x00...0F 0x00...10 0x00...11

Cache

0xFF...FF

Vorteile: Einfache Adressumsetzung, wenige Tag-Vergleicher Nachteil: Sehr frhe Verdrngung der Daten

Vollassoziativer Cache (fully associative cache)


ASP-Adresse Schlssel ByA 4 Tag Tag Tag Tag Tag Tag v v v v v v 15 15 15 15 15 15 14 14 14 14 14 14 Byteauswahl 4 4 4 4 4 4 3 3 3 3 3 3 2 2 2 2 2 2 1 1 1 1 1 1 0 0 0 0 0 0

Tag

15 14

4 3

Daten knnen unabhngig von der ASP-Adresse in jedem Rahmen abgelegt werden Vorteil: Flexibilitt Nachteil: Anzahl der Tag-Vergleicher = Rahmenanzahl Schlsselbreite

6-16

Set-Assoziativer Cache (set associative cache)


ASP-Adresse Schlssel Set-Nr. ByA 4 Tag Tag Tag Tag Tag Tag v v v v v v 15 15 15 15 15 15 14 14 14 14 14 14 Byteauswahl 4 4 4 4 4 4 3 3 3 3 3 3 2 2 2 2 2 2 1 1 1 1 1 1 0 0 0 0 0 0

Set

n-2

n-1

Tag Tag Tag Tag Tag Tag

v v v v v v

15 15 15 15 15 15

14 14 14 14 14 14

4 4 4 4 4 4

3 3 3 3 3 3

2 2 2 2 2 2

1 1 1 1 1 1

0 0 0 0 0 0

Kompromiss zwischen direkt-abgebildetem und Set-assoziativem Cache Set-Nr. whlt Rahmenbereich aus, in dem der Rahmen abgelegt werden kann HW-Aufwand und Flexibilitt skalierbar Anzahl der Tag-Vergleicher = Assoziativitt Schlsselbreite Set-Grsse = Assoziativitt Rahmengrsse Assoziativitt = Anzahl der Rahmen pro Set Anzahl der Rahmen = Assoziativitt Anzahl der Sets Anzahl der Sets = 2
Anzahl der Bits fr die Set-Nr.

6-17

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 bewltigen knnen Write-Back Geschriebene Daten werden erst erst bei Verdrngung des Cache-Rahmens auf den ASP geschrieben ASP und Cache nach Schreibzugriffen inkonsistent Vorteilhaft bei hoher Schreibrate Steigerung der Performance Komplexe Implementierung

6.3.5

Verdrngungsalgorithmen

LRU (least recently used) Verdrngung desjenigen Rahmens, der am lngsten nicht mehr genutzt wurde Fr die Praxis im Allgemeinen zu aufwndig Zyklische Verdrngung Rahmen werden unabhngig von Ihrer letzten Verwendung der Reihe nach verdrngt relativ einfache Implementierung Starke Verminderung der Performance, wenn in Schleifen immer gerade derjenige Eintrag verdrngt wird, der als nchstes bentigt wird Zufllige Verdrngung Rahmen werden nach dem Zufalls-Prinzip verdrngt Insbesondere bei Schleifen (s.o.) nicht die schlechteste Wahl

6-18

6.3.6

Verfahren zur Verringerung der Transfer-Zeit

Early Restart: Fortfahren mit der Befehlsausfhrung, 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

Cache
5 6 7 CacheBlock 8
gesucht

ASP

1 2 3 4

gesucht

6.3.7

Prefetching

Beim Laden des gesuchten Datums zustzlich Laden nachfolgender Daten Grosser Vorteil beim Befehls-Cache, da hier oft sequentieller Zugriff auf konsekutive (aufeinanderfolgende) Adressen nchster Befehl steht schon im Cache

6-19

6.3.8

Abhngigkeit der Miss-Rate von der Rahmengrsse


MissRate Bereich 1 Bereich 2

Rahmengrsse

Bereich 1: Miss-Rate sinkt mit steigender Rahmengrsse, da mit steigender Rahmengrsse auch die Anzahl der im Cache befindlichen Daten steigt Bereich 2: Miss-Rate steigt mit steigender Rahmengrsse + Rahmen werden nach dem Laden schnell verdrngt, wenn sie knapp werden + "Konkurrenzkampf" um die Rahmen

6-20

6.3.9

Abschtzung des Performance-Gewinns

Performance ~

1 Ausfhrungszeit

Ausfhrungszeit = (CPU-Taktzyklen + Speicherzugriffs-Taktzyklen) Taktzyklusdauer Speicherzugriffs-Taktzyklen = Schreib-Taktzyklen + Lese-Taktzyklen


Schreib-Zeit Schreib-Taktzyklen = Zyklusdauer

Schreib-Zeit = Anzahl der Schreibzugriffe [ (Schreib-Hit-Rate Schreib-Hit-Time + Schreib-Miss-Rate Schreib-Miss-Penalty) ]


Lese-Zeit Lese-Taktzyklen = Zyklusdauer

Lese-Zeit = Anzahl der Lesezugriffe [ (Lese-Hit-Rate Lese-Hit-Time + Lese-Miss-Rate Lese-Miss-Penalty)

Durchschnittliche Speicherzugriffszeit AMAT (Average Memory Access Time):


AMAT = Hit-Time + (Miss-Rate Miss-Penalty)

6-21

A Komponenten eines Computers

A-1

B Bootvorgang eines Computers

B-1

C Zahldarstellung
C.1 Allgemein

B = Basis a: Koeffizienten zur Basis B

Zahl = ( a1B1 +

+ a1B1 + a0B0 + a 1B1 +

+ a B )

ganze Zahl

echt gebrochene Zahl

gebrochen rationale Zahl


C.2 Integerzahlen
C.2.1 Vorzeichenlose Zahlen

Darstellung zur Basis 2 n Darstellbarer Wertebereich: 0 2 1


Zahl = a 1 2
1

+ a 2 2

+ a1 2 + a0 2

Speicherwort:

a1 a2

a1

a0

C.2.2 Vorzeichenbehaftete Zahlen

Darstellung als Vorzeichen und Betrag MSB entspricht dem Vorzeichen der Zahl Rest entspricht dem Betrag der Zahl n-1 n-1 Darstellbarer Wertebereich: (2 1) 0, 0, +(2 1)

Vorteil: einfache Multipliplikation und Division + Vorzeichen kann einfach aus der XOR-Verknpfung der MSBs bestimmt werden + Betrge knnen mit einfachen Algorithmen multipliziert/addiert werden Nachteil: schwierige Addition und Subtraktion + Wird im Bereich 000 bis 011 im Binrsystem 1 addiert, wird auch im Zehnersystem 1 addiert (so solls auch sein) + Wird im Bereich 100 bis 111 im Binrsystem 1 addiert, wird im Zehnersystem 1 subtrahiert Problem! + Doppelte Darstellung der Null + Da Addition/Subtraktion in Programmen wesentlich hufiger verwendet (z.B. Schleifenzhler inkrementieren, Adressen berechnen etc.) wird als Multiplikation/Divison, wird diese Zahldarstellung in Computersystemen nicht verwendet

C-1

Beispiel mit Wortbreite n = 4


Bitmuster 0000 0001 0010 0011 0100 0101 0110 0111 1000 1001 1010 1011 1100 1101 1110 1111 Wert 0 1 2 3 4 5 6 7 -0 -1 -2 -3 -4 -5 -6 -7

Darstellung im 1er-Komplement
C.3 Gleitkommazahlen

NaN unendlich

C-2

D Spezialregister des MMIX-Prozessors


rA = Arithmetic status register (fr 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

Interrupt Enable Bits


0 0 R1 R0 D V W I O U Z X D

Interrupt Event Bits


V W I O U Z X

nicht verwendet

GK-Zahl ungenau (z.B. 1.0/3.0) GK-Division durch 0 GK-Unterlauf GK-berlauf Ungltige GK-Operation (z.B. 1.0 ) berlauf bei GK-FK-Wandlung Integer-berlauf Integer-Division durch 0 00: nhester Wert (default) 01: abrunden (gegen 0) 10: aufrunden (gegen pos. unendl.) 11: abrunden (gegen neg. unendl.)

GK-Rundungsmodus

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: Enthlt die Anzahl der bisher ausgefhrten Taktzyklen. rD = Dividend register: Dient bei einer Integer-Division zur Aufnahme der oberen 64 Bit des Dividenden. rE = Epsilon register: Dient der Bereitstellung der bei GK-Vergleichen verwendeten Umgebung. rF = Failure location register: Enthlt im Falle eines Paritts-Fehlers oder eines sonstigen Speicher-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: Ermglicht das automatische Anhalten des Programms nach einer bestimmten Anzahl vergangener Taktzyklen. Hierzu wird der Inhalt von rI bei jedem Taktzyklus um 1 verringert. Erreicht rI den Wert 0, so wird die Programmausfhrung gestoppt und rI der Wert 0xFFFFFFFFFFFFFFFF zugewiesen. rJ = Return-jump register: Enthlt nach der Ausfhrung eines Registerstack-gesttzten Sprungbefehls die Rcksprungadresse.

D-1

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 rK

24 Bits E/A mit niedriger Prioritt


r w

Programm-Bits
x n k b s p

24 Bits E/A mit hoher Prioritt

Maschinen-Bits

Neustart Speicher nicht vorhanden Speicher-Parittsfehler Stromausfall Befehl kommt von BS-Segment Befehl verletzt Sicherheitsrichtlinien (Ausfhren von Befehlen an negativen Adressen, ohne dass alle Bits rwxnkbsp gesetzt sind) Befehl ist gegen die MMIX-Regeln Privilegierter Befehl (Kernel-Modus) Befehl bezieht sich auf Adresse im BS-Segment Befehl steht auf Seite ohne Ausfhrungsrecht Schreiben auf Seite ohne Schreibrecht Lesen von Seite ohne Leserecht
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: Enthlt die Seriennummer des Prozessors. Im Simulator wird die Seriennummer bei der Assemblierung aus Datum und Uhrzeit generiert. rO = Register stack offset: Legt fest, an welcher Speicheradresse im Stack-Segment im Falle einer Verdrngung das erste sichtbare lokale Register abgespeichert wird. rP = Prediction register: Wird bei der Ausfhrung 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 Verdrngung das erste verborgene Register abgespeichert wird. rT = Trap address register: Beinhaltet beim Auftreten eines erzwungenen Traps die Anfangsadresse des Trap-Handlers. rU = Usage counter: Zhlt, wie oft ein bestimmter Befehl ausgefhrt wurde. rV = Virtual translation register: Ermglicht Einstellungen zur Adressierung des virtuellen Speichers.

D-2

4
b1

4
b2

4
b3

4
b4

8
s

27
r

10
n

3
f

root location page size: Legt die Seitenge zu 2s Byte fest bi: Festlegung der Gre der einzelnen Bereiche des Anwenderspeichers. Mit b b0=0 gilt: Segment i hat hchstens 1024 Seiten.

function: 0: Adr.-Umsetzung durch HW 1: Adr.-Umsetzung durch SW (BS) sonst: Speicherzugriffsfehler address space number: Gibt die Nummer des gerade aktuellen Adressraums an

i +1

bi

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 niederwertigen Byte den unterbrochenen Befehl zugewiesen (Opcode und Operanden). Die vier hherwertigen Byte werden hierbei auf 0x80000000 gesetzt. Das hherwertigste Byte wird "ropcode" 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 Befehls, 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 45 Anfangsadresse des Trap-Handlers . rWW = Where-interrupted register (bei TRAP): Bekommt beim Auftreten eines Traps die Adresse des dem unterbrochenen Befehl nachfolgenden Befehls zugewiesen. rXX = Execution register (bei TRAP): Bekommt beim Auftreten eines Traps in den vier niederwertigen Byte den unterbrochenen Befehl zugewiesen (Opcode und Operanden). Die vier hherwertigen Byte werden hierbei auf 0x80000000 gesetzt. Das hherwertigste Byte wird "ropcode" genannt (vgl. RESUME). rYY = Y-Operand (bei TRAP): Bekommt beim Auftreten eines Traps den Y-Operanden des Befehls, 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 Befehls, der den Trap verursacht hat, zugewiesen. Bei Befehlen zum Speichern von Daten wird in rZZ die virtuelle Speicheradresse abgelegt.

45

Der Trap-Handler kann die Unterbrechungsursache mittles rQ rK feststellen

D-3

E Weitere MMIX-Befehle
In diesem Anhang sind die restlichen MMIX-Befehle beschrieben.

E.1 System-Befehle

Befehl

Operanden

Wirkung

Erluterung

LDVTS

CSWAP

$Y+$Z TC (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 TCBefehl $X=1 $Y+$Z TCDaten $X=2 $Y+$Z TCBefehl && && $Y+$Z TCDaten $X=3 $Y+$Z TC $X=0 $Y+Z TC (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 TCBefehl $X=1 $Y+Z TCDaten $X=2 $Y+Z TCBefehl && && $Y+Z TCDaten $X=3 $Y+Z TC $X=0 M8[$Y+$Z]==rP M8[$Y+$Z]=$X $X=1 $X,$Y,$Z M8[$Y+$Z]!=rP rP=M8[$Y+$Z] $X=0 M8[$Y+Z]==rP M8[$Y+Z]=$X $X=1 $X,$Y,Z M8[$Y+Z]!=rP rP=M8[$Y+Z] $X=0

Load virtual translation status: Befehl fr Betriebssysteme. $Y und $Z bzw. Z werden als Schlssel verwendet. Ist der Schlssel 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 TCEintrags gesetzt. Werden die letzten 3 Bits hierbei auf 0 gesetzt, wird der TC-Eintrag entfernt. Befand sich der Schlssel in der TCTabelle fr Befehle, wird $X auf 1 gesetzt. Befand sich der Schlssel in der TC-Tabelle fr Daten, wird $X auf 2 gesetzt. Befand sich der Schlssel in beiden Tabellen, so wird $X auf 3 gesetzt. Befand sich der Schlssel nicht in der Tabelle, so wird $X auf 0 gesetzt.

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

SYNC

XYZ

XYZ==0 Pipeline leeren XYZ==1 Alle Store-Anweisungen nach SYNC werden nach den StoreAnweisungen vor SYNC abgeschlossen XYZ==2 Alle Load-Anweisungen nach SYNC werden nach den LoadAnweisungen vor SYNC abgeschlossen XYZ==3 Alle Load- oder Store-Anweisungen vor SYNC werden vor allen Load- oder Store-Anweisungen nach SYNC abgeschlossen XYZ==4 Prozessor geht in StromsparModus XYZ==5 Schreibpuffer leeren und DatenCache in den Speicher schreibben XYZ==6 Lschen der TC-Tabelle des virtuellen Speichers XYZ==7 Befehls- und Datencache lschen XYZ>7 Auslsen des Interrupts "ungltiger Befehl"

Dient der Synchronisation paralleler Prozesse

E-2

X,$Y,$Z

SYNCD

X,$Y,Z

Ausfhrungsadresse < 0x80...0 Kein Schreib-Puffer oder Writeback Datencache Keine Auswirkung Schreib-Puffer oder Write-Back Cache vorhanden M[$Y+$Z],...,M[$Y+$Z+X] wird in den Speicher zurckgeschrieben Ausfhrungsadresse 0x80...0 Kein Schreib-Puffer oder Writeback Datencache Keine Auswirkung Schreib-Puffer oder Write-Back Cache vorhanden M[$Y+$Z],...,M[$Y+$Z+X] wird in den Speicher zurckgeschrieben und aus dem Cache gelscht Ausfhrungsadresse < 0x80...0 Kein Schreib-Puffer oder Writeback Datencache Keine Auswirkung Schreib-Puffer oder Write-Back Cache vorhanden M[$Y+Z],...,M[$Y+Z+X] wird in den Speicher zurckgeschrieben Ausfhrungsadresse 0x80...0 Kein Schreib-Puffer oder Writeback Datencache Keine Auswirkung Schreib-Puffer oder Write-Back Cache vorhanden M[$Y+Z],...,M[$Y+Z+X] wird in den Speicher zurckgeschrieben und aus dem Cache gelscht

Synchronisiert Daten im Bereich $Y+$Z bis X+$Y+$Z bzw. $Y+Z bis X+$Y+Z

E-3

X,$Y,$Z

SYNCID

X,$Y,Z

Ausfhrungsadresse < 0x80...0 Kein vom Datencache separater Befehlscache Keine Auswirkung Vom Datencache separater Befehlscache vorhanden Die Speicherzellen M[$Y+$Z],...,M[$Y+$Z+X] werden im Befehlscache aktualisiert Ausfhrungsadresse 0x80...0 Kein vom Datencache separater Befehlscache Keine Auswirkung Vom Datencache separater Befehlscache vorhanden Die Speicherzellen M[$Y+$Z],...,M[$Y+$Z+X] werden aus allen Caches gelscht, der zugehrige Arbeitsspeicher wird hierbei nicht aktualisiert Ausfhrungsadresse < 0x80...0 Kein vom Datencache separater Befehlscache Keine Auswirkung Vom Datencache separater Befehlscache vorhanden Die Speicherzellen M[$Y+$Z],...,M[$Y+$Z+X] werden im Befehlscache aktualisiert Ausfhrungsadresse 0x80...0 Kein vom Datencache separater Befehlscache Keine Auswirkung Vom Datencache separater Befehlscache vorhanden Die Speicherzellen M[$Y+Z],...,M[$Y+Z+X] werden aus allen Caches gelscht, der zugehrige Arbeitsspeicher wird hierbei nicht aktualisiert

Synchronisiert Daten, die als Befehle interpretiert werden im Bereich $Y+$Z bis $Y+$Z+X bzw. $Y+Z bis $Y+Z+X

E-4

X,$Y,$Z PRELD X,$Y,Z X,$Y,$Z PREST X,$Y,Z X,$Y,$Z PREGO X,$Y,Z

Informiert das System darber, dass der Speicherinhalt von $Y+$Z bis X+$Y+$Z bzw. $Y+Z bis X+$Y+Z wahrscheinlich in Krze geladen oder gespeichert wird Informiert das System darber, 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 nchste Mal gelesen wird Informiert das System darber, dass der Speicherinhalt von $Y+$Z bis X+$Y+$Z bzw. $Y+Z bis X+$Y+Z wahrscheinlich ausgefhrt wird

E.2 Byteweise Operationen

Befehl BDIF WDIF TDIF ODIF

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

Wirkung
byteweise x=max(0,y-z) wydeweise x=max(0,y-z) tetraweise x=max(0,y-z)

Erluterung Byte difference: Byteweise saturierte Differenz von der Register Y und Z Wyde difference: Wydeweise saturierte Differenz von der Register Y und Z Tetra difference: Tetraweise saturierte Differenz von der Register Y und Z Octa difference: Saturierte Differenz der Register Y und Z

$X=max(0,$Y-$Z) $X=max(0,$Y-Z)

E-5

F Aufbau der MMIX-Objektdatei

F-1

G Parameterbergabe auf dem Registerstack


Motivation

Zugriffe auf den Stack sind stets langsame Speicherzugriffe und nicht schnelle Registerzugriffe zeitaufwendig wird bei Funktionen die Parameterbergabe auf dem Stack durchgefhrt, 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 unntige Speicherzugriffe, die das Programm ausbremsen (Speicherzugriffe sind sehr zeitaufwendig)

Ideen zur Verbesserung

Vorteile der Parameterbergabe in Registern mit den Vorteilen der Parameterbergabe 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 knnen Register einfach umbenannt werden, 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 Parameterbergabe auf dem Register-Stack Umbenennen von Registern beim Sprung in eine Funktion erspart das Sichern der von der Funktion verwendeten Register, da diese einfach ausgeblendet werden, von der Funktion also auch nicht berschrieben werden knnen

Bezeichner vor dem Funktionsaufruf

$9 $8 $7 $6 $5 $4 $3 $2 $1 $0

von der Funktion verwendete Register 2. Parameter 1. Parameter vom Funktionsaufrufer verwendete Register

$4 $3 $2 $1 $0

Bezeichner nach dem Funktionsaufruf

Abb. 200: Umbenennen von Registern

sind bspw. aufgrund vieler verschachtelter Funktionsaufrufe keine Register mehr brig, knnen die ausgeblendeten Register auf den Arbeitsspeicher gesichert werden, um so wieder freie Register zu bekommen da Zugriffe auf den Stack in der Regel immer in der Nhe 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-1

Realisierung beim MMIX mit Hilfe des Register-Rings

der Register-Ring besteht aus verborgenen (s.u.), lokalen und marginalen Registern (vgl. Kap. 46 2.4.2) ein Register kann hierbei als einzelnes Segment eines aus <rG> Segmenten zusammenge47 setzten Rings betrachtet werden

L>=7 =<r

gibt die Stelle an, an der die lokalen Register beginnen

...

Segmente (einzelne Register), aus denen sich der RegisterRing zusammensetzt

$6

$5 $4 $3

$8 $7

.. .

lokale Register, also Register, die vom Unterprogramm bereits verwendet wurden
gibt die Stelle an, an der die lokalen Register beginnen

$2 $1
$0

0x5FF..F 0x600..0 rS-1 rS rO-1 rO

Pool-Segment des Arbeitsspeichers Stack-Segment des Arbeitsspeichers verborgene Register lokale Register Register marginale Register

...

marginale, also noch unbenutzte Register

verborgene Register + sind diejenigen Register, die bei einem Funktionsaufruf auf den Register-Stack geschoben wurden + sind fr die Funktion nicht mehr sichtbar, knnen also von der Funktion nicht berschrieben werden ( bei einem Funktionsaufruf ist keine Sicherung der verwendeten Register erforderlich) + knnen auf den Arbeitsspeicher ausgelagert werden, wenn die Anzahl der marginalen Register fr den Aufruf einer weiteren Funktion nicht ausreicht lokale Register + sind wie bisher die Register $0 bis $(<rL>-1) + der Registerbezeichner ($0, $1 etc.) alleine lt 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 fr das grsste marginale Register nach unten Beispiel: 2 Register wurden verborgen, 3 Register sind lokal, 4 Register sind global die Anzahl der marginalen Register betrgt 256 2 3 4 = 247 aufgrund der Umbenennung der Register ist das hchste marginale Register jetzt nicht mehr Register $251, sondern Register $249
46 Globale Register und Spezialregister knnen als separate Hardware angesehen werden und werden deshalb hier nicht betrachtet. Die verborgenen Register sind, je nachdem, ob sie bereits auf den Arbeitsspeicher ausgelagert sind oder nicht, entweder Bestandteil des Register-Rings oder des Stacksegments des Arbeitsspeichers. 47 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 Spezialregisters 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.

...

$10 $9
48 $2 7 $24

xx xx

xx

verborgene Register, also Register, die auf den RegisterStack verdrngt wurden, jedoch noch nicht auf den Arbeitsspeicher ausgelagert wurden
gibt die Stelle an, an der die verborgenen Register beginnen

Abb. 201: Register-Ring

G-2

Funktionsaufruf mit dem Registerstack des MMIX-Prozessors + Befehle zum Sprung in die Funktion: PUSHJ $X,YZ bzw. PUSHGO $X,$Y,$Z|Z (vgl. 48 Kap. 2.8.10) + Rcksprung aus der Funktion mit dem MMIX-Befehl POP X,YZ (vgl. Kap. 2.8.10) findet bei einem Funktionsaufruf die Parameterbergabe auf dem Stack statt, werden die folgenden Spezialregister wie folgt verwendet (vgl. Anhang D) + rJ = return-jump register: enthlt nach dem Funktionsaufruf die Rcksprungadresse + rO = register stack offset: legt fest, an welcher Speicheradresse im Stack-Segment im Falle einer Verdrngung das erste sichbare lokale Register abgespeichert wird + rS = register stack pointer: legt fest, an welcher Speicheradresse im Stack-Segment im Falle einer Verdrngung das erste verborgene Register abgespeichert wird

Beispielprogramm
LOC GREG LOC GREG LOC GREG fkt2 LOC SET SET SET SET SET POP #2000000000000000 @ Dummy-Aufruf #2000000000000100 @ Dummy-Aufruf #2000000000000200 @ Dummy-Aufruf #100 $0,0 $1,1 $2,2 $3,3 $4,4 3,0

// // // // fkt

GET ADD PUSHJ PUT SET POP SET SET

$2,rJ $3,$0,$1 $4,fkt2 rJ,$2 $0,$3 1,0 $0,0 $1,1

Rcksprung, 3 Rckgabewerte Wert aus $2 (2) ist der Hauptrckgabewert und kommt dann in dem Register unterhalb von $0 abgelegt Adresse von rJ nach $2 sichern Addieren der beiden Parameter Adresse restaurieren

Main // // //

Register $2 freilassen, da dort dann die Anzahl der auf den Stack gelegten Register steht SET SET $3,3 $4,4 1. Parameter 2. Parameter Funktionsaufruf 2 Parameter ($3 und $4) Anzahl der auf den Stack gesicherten Register ($0 und $1 => 2 Stck) wird direkt nach $0 und $1 auf den Register-Stack geschrieben

PUSHJ $2,fkt // // // // // TRAP 0,Halt,0

48 PUSHJ und PUSHGO unterscheiden sich lediglich darin, dass die Zieladresse bei PUSHJ hnlich wie beim JMP-Befehl relativ angegeben wird, bei PUSHGO hnlich wie beim GO-Befehl absolut (vgl. Kap. 2.8.10).

G-3

Ablauf des obigen Beispiels + Annahmen ber den Initialisierungszustand es wurden 4 globale Register verwendet <rG> = 252 + das Hauptprogramm hat die Register $0 und $1 fr eigene Berechnungen verwendet und sie mit den Werten 0 und 1 belegt
SET SET $0,0 $1,1
marginale Register

$9

$8 $7 $6
$5 $4

1 $1 $10
$13 $1 2
...

$3

$2 $1 =1 $0 = 0
1

= <r L>=2

Abb. 202: Ausgangszustand vor dem Funktionsaufruf

+ als nchstes werden die Parameter fr die Funktion fkt in Registern abgelegt die vom Hauptprogramm verwendeten Register $0 und $1 werden beim spteren Aufruf 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 ebenfalls auf den Registerstack abgelegt (vgl. Kap. 2.8.10) zwischen den vom Hauptprogramm verwendeten Registern ($0 und $1) und den Parameter-Registern muss ein Register unbenutzt bleiben Register $2 nicht verwenden die Parameter fr die Funktion fkt in Register $3 und $4 ablegen
SET SET $3,3 $4,4
marginale Register

5 $2
. . .

lokale Register

$8 $7 $6

5 >= rL =<

1 $1 $10

$9

...

Abb. 203: Ablegen der Parameter fr die Funktion fkt in Registern

$13 $1 2

$5 =4 $4 $3 = 3

$2

$1 =1 $0 = 0
1

lokale Register

5 $2

G-4

. . .

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 Rcksprungadresse wird im Spezialregister rJ abgelegt da jetzt 3 Register verborgen sind, ist das hchste marginale Register das Register $248 und nicht mehr $251
PUSHJ $2,fkt
marginale Register

$5 $4 $3

2 >= rL =<

$8 $7 $6

...

Abb. 204: Register-Ring nach dem Funktionsaufruf

+ Sicherung der Rcksprungadresse die Rcksprungadresse, also der Weg zurck ins Hauptprogramm, steht jetzt im Spezialregister rJ da die Funktion fkt die Funktion fkt2 aufruft und bei diesem Aufruf in das Register rJ die Rcksprungadresse der Funktion fkt2, also der Weg zurck zu fkt abgelegt wird, muss das Register rJ vor dem Aufruf von fkt2 in ein lokales Register gesichert werden, damit aus fkt heraus spter wieder zurck ins Hauptprogramm gesprungen werden kann da durch die Sicherung von rJ ein neues lokales Register belegt wird, erhht sich der Inhalt des Spezialregisters rL, in dem die Anzah der benutzten lokalen Register abgelegt ist
GET $2,rJ

$10 $9

$2 =4 $1 $0 = 3

lokale Register

0
4 $2 8

verborgene Register

G-6

. . .

$8 $7 $6

$5 $4 $3

marginale Register

3 >= rL < =

...

4 32 = $2 = 4 $1 $0 = 3

Abb. 205: Sicherung der Rcksprungadresse in Register $2

$10 $9

lokale Register

0
4 $2 8

verborgene Register

G-7

. . .

+ die Funktion verwendet fr Berechnungen zustzlich 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 Register $3 abgelegt
ADD $3,$0,$1
$5 $4 $3 = = <r 7 L>
=4

$8 $7 $6

marginale Register

...

4 32 = $2 = 4 $1 $0 = 3

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 Spezialregister rL den Wert 0
PUSHJ $4,fkt2
=<r L>=0

$3 $2 $1

$0

marginale Register

...

Abb. 207: Register-Ring nach dem Aufruf der Funktion fkt2

$10 $9

lokale Register

0
48 $2

verborgene Register

. . .

32

4
4
3
verborgene Register

$5 $4
$2

0
43

G-8

. . .

+ die Funktion fkt2 verwendet lokale Register


SET SET SET SET SET $0,0 $1,1 $2,2 $3,3 $4,4
lokale Register

3 = $3 =2 $2 $1 = 1 $0 = 0

4
7
32 4
4
3

...

marginale Register

Abb. 208: Die Funktion fkt2 verwendet lokale Register

+ Rcksprung aus der Funktion fkt2



die Funktion fkt2 soll drei Werte zurckgeben die Rckgabewerte mssen stets in dem unteren Teil der lokalen Register stehen die Rckgabewerte stehen hier in den Registern $0, $1 und $2 der Rckgabewert mit dem hchsten lokalen Register (hier: der Wert 2 aus $2) ist immer der Hauptrckgabewert der Hauptrckgabewert wird beim Rcksprung in dasjenige Register geschrieben, das direkt unterhalb des ersten Rckgabewertes liegt, also in dasjenige Register, in das zuvor die Anzahl der auf den Registerstack geschobenen Register abgelegt wurde
POP 3,0
L>=7 = <r

$6 = 1 $5 = 0 $4 =2 $3 = 7

$8 $7

...

marginale Register

Abb. 209: Register-Ring nach dem Rcksprung aus fkt2

$4

$10 $9

$5

=< rL >= 5

0
$2 43
2

verborgene Register

G-9

. . .
. . .

lokale Register

4 32 = $2 = 4 $1 $0 = 3

0
48 $2

verborgene Register

+ Rcksprungadresse restaurieren und Rckgabewert in Register $0 ablegen vor dem Rcksprung aus der Funktion fkt muss zuerst die Rcksprungadresse, die zuvor in Register $2 gesichert wurde, in das Register rJ bertragen werden da Rckgabewerte immer in den unteren lokalen Registern zurckgegeben werden, muss bei der Rckgabe nur eines Wertes dieser vor dem Rcksprung in Register $0 abgelegt werden
PUT SET rJ,$2 $0,$3
L>=7 = <r

$6 = 1 $5 = 0 $4 =2 $3 = 7

$8 $7

lokale Register

...

4 32 = $2 = 4 $1 $0 = 7

marginale Register

Abb. 210: Ablegen des Rckgabewerts in Register $0

+ Rcksprung aus der Funktion fkt es wird ein Rckgabewert zurckgegeben der Rckgabewert steht vor dem Rcksprung in Register $0 beim Rcksprung werden die Register wieder umbenannt, so dass der Rckgabewert dann im obersten lokalen Register steht
POP 1,0

$9

$8 $7 $6

1 $1 $10

...

marginale Register

Abb. 211: Rcksprung in das Hauptprogramm

$13 $1 2

$10 $9

0
48 $2
51

verborgene Register

G-10

. . .
. . .

$5 L>=4 = <r 4 $ $3 = 7

$2 = 2 $1 =1 lokale $0 = Register 0

$2

H Ein- und Ausgabe von Daten


H.1 Allgemein

Hardware vom Betriebssytem verwaltet Ein- und Ausgabe von Daten Ansprechen von Hardware fr Ein- und Ausgabe von Daten sind Betriebssystem-Aufrufe ntig Betriebssystem-Aufruf Trap von der Software ausgelster Interrupt Trip: von der Hardware ausgelster Interrupt

H.2 Betriebssystem-Aufrufe beim MMIX

Auslsen 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 gewnschte 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-Kanle

MMIX-Programm

Betriebssystemaufrufe ber Kanle StdIn: Kanal 0

Hardware

TRAP 0,Fgets,StdIn

TRAP 0,Fputs,StdOut TRAP 0,Fputs,StdErr

StdOut: Kanal 1
C:\> mmix>

StdErr: Kanal 2

TRAP...

TRAP 0,Fopen,15 TRAP 0,Fputs,15 TRAP 0,Fclose,15 TRAP 0,Fopen,16 TRAP 0,Fread,16 TRAP 0,Fclose,16 TRAP...

Kanal 15

Kanal 16

Kanal 255
Abb. 212: Ein- und Ausgabe-Kanle beim MMIX

H-1

Ausgabe von Zeichenketten auf dem Bildschirm

zunchst 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 Gerte umgeleitet sein kann der Aufruf von TRAP 0,Fputs,StdErr schreibt die Zeichenkette auf die Standardfehlerausgabe (den Bildschirm); der Kanal StdErr kann nicht umgeleitet werden Beispiel

1H Main

LOC GREG BYTE LOC LDA TRAP TRAP

Data_Segment @ "hello world",0 #100 $255,1B 0,Fputs,StdOut 0,Halt,0

Einlesen von Zeichenketten von der Tastatur

zunchst 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 drfen (Puffergrsse beachten); die Parameter-Zeichenkette steht in nachfolgendem Beispiel an der Adresse 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 Drcken der Eingabetaste (return) wird die Eingabe in den Eingabepuffer geschrieben

1H 2H 3H 4H // Main

LOC GREG OCTA OCTA BYTE BYTE BYTE LOC LDA TRAP LDA TRAP LDA TRAP TRAP

Data_Segment @ 4F Adresse 4H 100 100 Byte Zeichenpuffer "Eingabe: ",0 "Die Eingabe war: " #100 $255,2B 0,Fputs,StdOut $255,1B 0,Fgets,StdIn $255,3B 0,Fputs,StdOut 0,Halt,0

Ausgabe von "Eingabe: " Einlesen der Eingabe Ausgabe von "Die Eingabe war: " und der Eingabe

// //

01 02 03 04 05 06 07 08 09 10 11 12 13 14 15 16 17 18

H-2

Ein- und Ausgabe mit Dateien

Funktionen, die als Parameter Y des TRAP-Befehls angegeben werden knnen + Fopen: ffnet eine Datei als Parameter Z muss beim TRAP-Befehl eine Kanalnummer angegeben werden, die dann fr 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 binren Lesen + BinaryWrite: ffnet die Datei zum binren Schreiben + BinaryReadWrite: ffnet die Datei zum Lesen und Schreiben, wobei mittels Fseek (s.u.) der Dateizeiger bewegt werden kann Rckgabewert 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 Rckgabewert in Register $255 Ok Anzahl der geschriebenen Zeichen Fehler 1 + Fclose: Schliet eine Datei die Datei, die geschlossen werden soll, ergibt sich aus der Angabe der Kanalnummer (Parameter Z) Rckgabewert in Register $255 Ok Anzahl der geschriebenen Zeichen Fehler 1

Beispiel
LOC GREG BYTE OCTA BYTE LOC LDA TRAP Data_Segment @ "textdatei.txt",0 1B,TextWrite "Hallo Textdatei!" #100 $255,arg 0,Fopen,16

1H arg 2H Main // // // //

Kanal kann willkrlich gewhlt werden (Kanal 0,1 und 2 ist jedoch mit StdIn,StdOut und StdErr vorbelegt

LDA TRAP TRAP TRAP

$255,2B 0,Fputs,16 0,Fclose,16 0,Halt,0

+ Fgets: Liest eine Zeichenkette aus einer Datei


H-3

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 Rckgabewert 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 Rckgabewert in Register $255 Ok alle Zeichen gelesen 0 nicht alle Zeichen gelesen negierter Betrag der Anzahl der Zeichen, die flschlicherweise 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 Rckgabewert in Register $255 Ok alle Zeichen geschrieben 0 nicht alle Zeichen geschrieben negierter Betrag der Anzahl der Zeichen, die flschlicherweise 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 geffneten Datei als Parameter Z muss die Kanalnummer angegeben werden in Register $255 kann ein Offset angegeben werden Rckgabewert in Register $255 Ok gibt die Anzahl der Bytes vom Dateianfang bis zur aktuellen Position an Fehler 1 + Fseek: Positioniert den Dateizeiger in einer geffneten 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 Dateianfang Offset < 0 positioniert den Dateizeiger auf die Position Offset + 1 Byte vor das Dateiende Offset = 0 positioniert den Dateizeiger auf den Dateianfang

H-4