Aufgabenkatalog
Computersysteme 1Dr. Michael Zwick
Technische Universität München
Inhalt
1 Komponenten eines Computer-Systems 5Netzteil . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5
Grafikkarten . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6
Optische Laufwerke . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6
Festplatte . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7
Prozessor . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 9
Bussystem . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 10
Rechner-Architekturen . . . . . . . . . . . . . . . . . . . . . . . . . . . 11
2 Assemblerprogrammierung 13
2.1 Zahldarstellung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 13
Festkommazahlen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 13
Gleitkommazahlen nach IEEE 754 . . . . . . . . . . . . . . . . . . . . . 17
Format von Gleitkommazahlen . . . . . . . . . . . . . . . . . . . . . 17
Rechnen mit Gleitkommazahlen . . . . . . . . . . . . . . . . . . . . 19
2.2 MMIX Architektur . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 22
Überblick . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 22
MMIX Register . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 23
Allgemein . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 23
Allzweckregister . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 23
Spezialregister . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 25
Arbeitsspeicher . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 27
Allgemein . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 27
Speicher-Organisation . . . . . . . . . . . . . . . . . . . . . . . . . . 28
Alignment . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 31
Byte-Reihenfolge beim Abspeichern von Datenworten: Big- und
Little-Endian . . . . . . . . . . . . . . . . . . . . . . . . . . 32
Format von MMIX-Programmen . . . . . . . . . . . . . . . . . . . . . . 33
Assembler- und Loader-Befehle . . . . . . . . . . . . . . . . . . . . . . 34
MMIX Befehlsformat . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 38
2.3 MMIX Befehle . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 43
Definitionen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 43
Zusammenfassen von in Registern gespeicherten Werten . . . . . . 46
3
Programm beenden . . . . . . . . . . . . . . . . . . . . . . . . . . . 46
Lade- und Speicherbefehle . . . . . . . . . . . . . . . . . . . . . . . . . 47
Daten vom Speicher in ein Register laden . . . . . . . . . . . . . . . 47
Adressen in ein Register laden . . . . . . . . . . . . . . . . . . . . . 53
Daten vom Register in den Speicher schreiben (speichern) . . . . . 55
Direktoperand in Register schreiben . . . . . . . . . . . . . . . . . . . . 60
Umwandlung Gleitkommazahl$ Festkommazahl . . . . . . . . . . . . 63
Arithmetische Befehle . . . . . . . . . . . . . . . . . . . . . . . . . . . . 64
Arithmetische Befehle auf Festkommazahlen . . . . . . . . . . . . . 64
Arithmetische Befehle auf Gleitkommazahlen . . . . . . . . . . . . . 67
Schiebe-Befehle . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 71
Logische Operationen auf Bit-Ebene . . . . . . . . . . . . . . . . . . . . 73
Zugriff auf Spezialregister . . . . . . . . . . . . . . . . . . . . . . . . . . 78
Verzweigungsbefehle . . . . . . . . . . . . . . . . . . . . . . . . . . . . 80
Unbedingte Verzweigung . . . . . . . . . . . . . . . . . . . . . . . . 80
Bedingte Verzweigungen . . . . . . . . . . . . . . . . . . . . . . . . 80
Befehle für Funktionsaufrufe . . . . . . . . . . . . . . . . . . . . . . . . 83
Namensräume . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 84
Stack . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 86
2.4 MMIX Programme . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 93
MMIX Programm zur Berechnung der Determinante einer 2 ⇥ 2 Matrix 93
Quadratische Gleichung . . . . . . . . . . . . . . . . . . . . . . . . . . . 96
3 Mikroarchitektur 103
3.1 Datenpfad . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 103
Phase 1: Befehl holen . . . . . . . . . . . . . . . . . . . . . . . . . . . . 103
Phase 2: Befehl dekodieren und Operanden bereitstellen . . . . . . . . 107
Phase 3: Befehlsausführung . . . . . . . . . . . . . . . . . . . . . . . . 124
Phase 4: Speicherzugriff . . . . . . . . . . . . . . . . . . . . . . . . . . 134
Kontrolle aller Phasen: Das Steuerwerk . . . . . . . . . . . . . . . . . . 138
3.2 Aufbau des Rechenwerks (ALU) . . . . . . . . . . . . . . . . . . . . . . 139
Überblick . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 139
UND- und ODER-Einheit . . . . . . . . . . . . . . . . . . . . . . . . . . 140
Schiebe-Einheit . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 141
Addierer und Subtrahierer . . . . . . . . . . . . . . . . . . . . . . . . . . 143
Addition zweier einzelner Bits: 1 Bit Halbaddierer . . . . . . . . . . . 143
Addition von drei einzelnen Bits: 1 Bit Volladdierer . . . . . . . . . . 145
4
Addition von Binärzahlen: Zusammenschalten von Volladdierern . . 150
Subtraktion von Binärzahlen: Addition des negativen zweiten Ope-
randen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 151
Multiplikation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 153
Multiplikation 11 · 13 = 143 im Binärsystem, Wortbreite = 4 . . . . . 153
Multiplikation 13 · 5 = 65 im Binärsystem, Wortbreite = 4 . . . . . . 159
Multiplikations-Hardware . . . . . . . . . . . . . . . . . . . . . . . . 162
Zustandsdiagramm der Steuerung . . . . . . . . . . . . . . . . . . . 165
Multiplexer-basierte Implementierung der Steuerung . . . . . . . . . 168
ROM-basierte Implementierung der Steuerung . . . . . . . . . . . . 177
3.3 Pipelining . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 185
Rückblick: Bisheriger Datenpad = Multicycle-Datenpfad . . . . . . . . . 185
Pipeline-Datenpfad . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 189
3.4 Cache . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 205
Motivation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 205
Direkt abgebildeter Cache . . . . . . . . . . . . . . . . . . . . . . . . . 208
Voll-Assoziativer Cache . . . . . . . . . . . . . . . . . . . . . . . . . . . 212
Set-Assoziativer/Mengen-Assoziativer Cache . . . . . . . . . . . . . . . 213
3.5 Division . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 216
4 Miscellaneous 225
4.1 Memory hierarchy . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 225
General questions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 225
Cache memory organization . . . . . . . . . . . . . . . . . . . . . . . . 226
Performance gain . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 230
4.2 Virtual memory . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 235
Segment based addressing . . . . . . . . . . . . . . . . . . . . . . . . . 236
Paging . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 239
4.3 Segment addressing with paging . . . . . . . . . . . . . . . . . . . . . 241
4.4 Diverses . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 241
4.5 Aufbau von Datenpfad-Komponenten . . . . . . . . . . . . . . . . . . . 241
Multiplexer . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 241
5
1 Komponenten eines Computer-Systems
Netzteil
a) Welche Spannungen werden von PC-Netzteilen bereitgestellt?
b) Warum können PC-Netzteile hohe Leistungen liefern, obwohl die eingebauten
Transformatoren nur relativ klein sind?
c) Wie sind Schaltnetzteile aufgebaut? Skizzieren Sie ein Blockschaltbild!
6 1 Komponenten eines Computer-Systems
Grafikkarten
a) Was sind die Hauptaufgaben einer Grafikkarte?
b) Was ist ein ‘‘Back-Buffer’’, was ist ein ‘‘Front-Buffer’’?
Optische Laufwerke
a) Was sind Pits und Land?
b) Was reflektiert Licht: Pits, Land oder beides?
c) Welche Tiefe müssen die Pits haben, damit man die mit Pits und Land gespeicherte
Information sinnvoll auslesen kann? Warum?
7
Festplatte
a) Was ist eine Festplatten-Spur?
b) Was ist ein Festplatten-Zylinder?
c) Was ist ein Festplatten-Sektor?
d) Was sind typische Sektor-Größen?
e) Was für Informationen werden in Sektoren neben den Nutzdaten noch zusätzlich
abgespeichert?
8 1 Komponenten eines Computer-Systems
f) Skizzieren Sie grob einen Regelkreis der zur Positionierung des Festplatten-Arms
verwendet werden kann.
9
Prozessor
a) Aus welchen logischen Grundeinheiten besteht ein Prozessor?
b) Welche Schritte führt ein Prozessor aus, wenn er den nächsten Befehl aus dem
Speicher lädt?
c) Wo können die Operanden eines Befehls generell abgelegt sein?
10 1 Komponenten eines Computer-Systems
Bussystem
a) In welche drei Busse lässt sich ein Bussystem oft aufgliedern?
b) Was ist die Funktion dieser drei Busse?
c) Welche dieser Busse sind unidirektional, welche bidirektional?
11
Rechner-Architekturen
a) Was ist der Haupt-Unterschied zwischen einer Harvard- und einer von Neumann-
Architektur?
b) Wie kann man die Aussage verstehen, dass heutige Rechnersysteme oft sowohl
eine Harvard- als auch eine von Neumann-Architektur haben?
12 1 Komponenten eines Computer-Systems
2.1 Zahldarstellung 13
2 Assemblerprogrammierung
2.1 Zahldarstellung
Festkommazahlen
a) Wandeln Sie folgende Dezimalzahlen in 8 Bit breite vorzeichenlose Binärzahlen
um.
0
75
127
128
129
255
Dezimal Binär vorzeichenlos
14 2 Assemblerprogrammierung
b) Wandeln Sie – soweit möglich – die folgenden Dezimalzahlen in die Systeme
Vorzeichen und Betrag, Einer Komplement und Zweier Komplement um.
+75
-75
+0
-0
+127
-127
Dezimal Vorzeichen und Betrag
+128
-128
Einer Komplement Zweier Komplement
2.1 Zahldarstellung 15
c) Vervollständigen Sie folgenden Zahlenring für 4 bit Binärzahlen wie folgt:
• Der mittlere Ring soll die 4 Bit breiten Binärzahlen enthalten,
• der äussere Ring soll die demmittleren Ring entsprechenden Dezimalzah-
len enthalten für den Fall, dass der mittlere Ring vorzeichenlose Zahlen
codiert und
• der innere Ring soll die dem mittleren Ring entsprechenden Dezimal-
zahlen enthalten für den Fall, dass der mittlere Ring Zahlen im Zweier
Komplement codiert.
• Markieren Sie, wo ein Überlauf von vorzeichenlosen Zahlen auftritt.
• Markieren Sie, wo ein Überlauf von vorzeichenbehafteten Zahlen auftritt.
16 2 Assemblerprogrammierung
d) Wie kann man einen Überlauf von vorzeichenlosen Zahlen feststellen?
e) Wie lässt sich ein Überlauf von vorzeichenbehafteten Zahlen feststellen?
f) Berechnen Sie 37 + 53 im vorzeichenlosen Binärformat.
g) Berechnen Sie 37 - 53 im Zweier Komplement.
2.1 Zahldarstellung 17
Gleitkommazahlen nach IEEE 754
Format von Gleitkommazahlen
a) Geben Sie das Format von 32 Bit und 64 Bit Gleitkommazahlen an.
b) Wie berechnet sich der Wert einer 32 bzw. 64 Bit breiten normalisierten Gleitkom-
mazahl aus ihrem Bitmuster? Geben Sie den Wert der Konstanten K an!
c) In welchem Bereich liegt e bei normalisierter Zahldarstellung?
d) Wie wird die Zahl 0.0 dargestellt in Bezug auf s, e and f?
18 2 Assemblerprogrammierung
e) Was ist eine denormalisierte Gleitkommazahl, wie wird sie kodiert und wie berech-
net sich ihr Wert?
f) Wie kodiert man die Gleitkommazahl ‘‘unendlich’’?
g) Mit welchen Werten von e und f wird ausgesagt, dass es sich um ‘‘keine Zahl’’
(NaN = not a number) handelt?
h) Geben Sie ein Beispiel an, wie es zu einem Ergebnis kommen kann, das ‘‘keine
Zahl’’ ist.
2.1 Zahldarstellung 19
Rechnen mit Gleitkommazahlen
a) Geben Sie die Festkomma-Binärdarstellung von 3,625 und 13,5 an.
b) Kodieren Sie 3,625 und 13,5 als 32 Bit breite Gleitkommazahlen und tragen Sie
das Bitmuster in die angegebene Tabelle ein.
3.625:
13.5:
20 2 Assemblerprogrammierung
c) Berechnen Sie 3,625 + 13,5 im Binärsystem bei Verwendung einer 32 Bit Gleit-
kommakodierung.
Bitmuster des Ergebnisses:
2.1 Zahldarstellung 21
d) Bestimmen Sie aus dem Ergebnis-Bitmuster das Ergebnis der Addition 3,625 +
13,5
22 2 Assemblerprogrammierung
2.2 MMIX Architektur
Überblick
a) Auf welche Mikroarchitektur-Komponenten kann ein MMIX-Programmierer in sei-
nen Programmen zugreifen (‘‘Programmier-Architektur’’)?
b) Zeichnen Sie die MMIX ‘‘Programmier-Architektur’’. Zeichen Sie mit gerichteten
Pfeilen den Informationsfluss ein und geben Sie dabei die Wortbreiten an.
2.2 MMIX Architektur 23
MMIX Register
Allgemein
a) Was ist ein Register?
b) Wo findet man Register in einem Computer-System?
c) Daten welcher Größenordnung kann ein Register aufnehmen: Byte, kilobytes,
megabytes, gigabytes or terabytes?
d) Skizzieren Sie das Schaltbild eines Registers das 64 Bit Daten abspeichern kann.
Allzweckregister
a) Was sind Allzweckregister?
b) Geben Sie ein Beispiel für eine typische Verwendung eines Allzweckregisters an.
24 2 Assemblerprogrammierung
c) Über wieviele Allzweckregister verfügt derMMIX-Prozessor?WelcheNamen haben
sie?
d) Was ist der Unterschied zwischen einem globalen und einem lokalen Register?
e) Skizzieren Sie die MMIX-Allzweckregister und tragen Sie in Ihre Skizze ein, wo die
globalen und wo die lokalen Register liegen.
2.2 MMIX Architektur 25
Spezialregister
a) Was ist ein Spezialregister?
b) Geben Sie eine typische Anwendung eines Spezialregisters an.
c) Über wieviele Spezialregister verfügt der MMIX-Prozessor? Wie werden sie ge-
nannt (Prinzip)?
d) Kann jeder MMIX-Befehl Spezialregister verwenden?
e) Welches Spezialregister stellt Informationen über Arithmetische Operationen zur
Verfügung?
f) In welchem Spezialregister kann man die oberen 64 Bit eines 128 Bit breiten
Festkomma-Dividenden ablegen?
g) In welchem Register werden die oberen 64 Bit des Ergebnisses einer Festkomma-
Multiplikation abgelegt?
26 2 Assemblerprogrammierung
h) In welchem Spezialregister legt das Rechenwerk den Rest einer Festkomma-
Division ab?
i) Müssen ‘‘normale’’ Programme häufig auf Spezialregister zugreifen?
j) Was müssen Sie tun, wenn Sie einzelne Bits eines Spezialregisters verändern
wollen?
2.2 MMIX Architektur 27
Arbeitsspeicher
Allgemein
a) Wozu verwendet ein Computer Arbeitsspeicher?
b) Wo findet man den Arbeitsspeicher in einem Computersystem? Auf dem
Prozessor-Kern? Auf dem Mainboard? Als externes Gerät?
c) Sind Zugriffe auf den Arbeitsspeicher in der Regel schneller oder langsamer als
Zugriffe auf Register?
d) Begründen Sie Ihre Antwort auf die letzte Frage.
28 2 Assemblerprogrammierung
Speicher-Organisation
a) Zeichnen Sie die Segmente des virtuellen MMIX-Speichers mit den zugehörigen
Start- und End-Adressen.
2.2 MMIX Architektur 29
b) Was wird im Textsegment gespeichert?
c) Was ist ein Interrupt?
d) Nennen Sie ein Ereignis, bei dem ein Interrupt auftreten kann.
e) Was sind Interruptvektoren?
f) Was wird im Datensegment gespeichert?
30 2 Assemblerprogrammierung
g) Was wird im Poolsegment gespeichert?
h) Geben Sie den Inhalt des Poolsegments für das Programm ls an, das mit dem
Parameter -la aufgerufen wird (Aufruf: ls -la).
0x4000000000000000
0x4000000000000008
0x4000000000000010
0x4000000000000018
0x4000000000000020
0x4000000000000028
0x4000000000000030
0x4000000000000038
i) Wenn alle Programme an Adresse 0x100 beginnen bzw. alle Programme ihre
Daten ab Adresse 0x2000000000000000 im Speicher ablegen: Überschreiben
sich die verschiedenen Programme dann nicht gegenseitig ihre Daten? Ja/nein
und warum?
2.2 MMIX Architektur 31
Alignment
a) Geben Sie für nachfolgend angegebene Speicheradressen an, ob es sich um
Byte-, Wyde-, Tetra- oder Octa-Adressen handelt.
0x2000000000000000
0x2000000000000001
0x2000000000000002
0x2000000000000003
0x2000000000000004
0x2000000000000005
0x2000000000000006
0x2000000000000007
0x2000000000000008
0x00
0x00
0x00
0x00
0x00
0x00
0x00
0x00
0x00
Octa Tetra Wyde Byte
32 2 Assemblerprogrammierung
Byte-Reihenfolge beim Abspeichern von Datenworten: Big- und Little-Endian
a) Welche Art von Daten betrifft die Abspeicherung als Big- oder Little-Endian?
b) Verwendet der MMIX-Prozessor Big- oder Little-Endian?
c) Was bedeutet Big- und Litle-Endian? Was ist der Unterschied?
d) Wie wird die 16 Bit-Zahl 0x1234 im Speicher an der Adresse 0x2000000000000000
abgelegt im Falle a) einer Big-Endian-Maschine und b) einer Little-Endian-
Maschine?
2.2 MMIX Architektur 33
Format von MMIX-Programmen
a) Aus wievielen/welchen Spalten bestehen MMIX-Programme?
b) Wie werden die Spalten im Programmcode getrennt?
c) Wie muss man MMIX-Codezeilen schreiben, die keine Marke verwenden?
d) Wie kann man beim MMIX-Assembler eine komplette Zeile auskommentieren?
e) Werden alle vier Spalten eines MMIX-Programms für den Übersetzungsvorgang
herangezogen? Gehen Sie auf die einzelnen Spalten ein.
34 2 Assemblerprogrammierung
Assembler- und Loader-Befehle
a) Geben Sie Befehle an, mit denen Sie Register 1, 2 und 3 durch a, b und c
ansprechbar machen.
b) Geben einen Befehl an, der ein globales Register mit dem Namen GR reserviert
und mit 0 initialisiert.
c) Was ist der Loader?
d) Geben Sie Befehle an, mit denen Sie an Speicheradresse #2000000000000000
vier Bytes reservieren, die über die Marken A, B, C und D angesprochen werden
können. A soll mit 1 und B mit 2 initialisiert werden. Fügen Sie auch einen
geeigneten Befehl zur Reservierung und Initialisierung eines globalen Registers
ein, damit die vier Bytes über ein Basisregister und einen Offset angesprochen
werden können.
2.2 MMIX Architektur 35
e) Mit welchen Befehlen können Sie Worte der Länge 16, 32 und 64 bit im Speicher
reservieren?
f) Erklären Sie den Ausdruck ‘‘Alignment’’.
36 2 Assemblerprogrammierung
g) Was passiert, wenn man ‘‘not aligned’’ auf den Speicher zugreift, d.h. wenn man
z.B. auf einen Befehl zum Laden/Speichern eines Octas zusammen mit einer
Adresse verwendet, bei der die letzten drei Bits nicht den Wert 0 haben?
Betrachten Sie die folgenden Befehle:
LOC #2000000000000000X BYTEY WYDEZ OCTA
h) Geben Sie die Adressen an, an denen X und Y im Speicher abgelegt werden.
i) An welchen Adressen wird Z abgelegt?
2.2 MMIX Architektur 37
j) Welche Eigenschaften muss eine Adresse haben, damit man an ihr ein Byte, Wyde,
Tetra bzw. Octa abspeichern kann?
k) Geben Sie Befehle an, die
• ein neues globales Register anlegen und dieses mit Speicheradresse
0x2000000000000000 initialisieren,
• an dieser Speicheradresse ein 64 Bit breites Datenwort anlegen, das mit
4 initialisiert wird und über die Marke N angesprochen werden kann,
• an den darauffolgenden Speicheradressen zwei 4-dimensionale Vektoren
wie folgt anlegen:
• Der erste Vektor soll über ADR_A1 ansprechbar sein und mit den
64 Bit-Zahlen [1, 2, 3, 4] initialisert werden;
• der zweite Vektor soll über ADR_A2 ansprechbar sein und mit den
64 Bit-Zahlen [10, 20, 30, 40] initialisiert werden.
38 2 Assemblerprogrammierung
MMIX Befehlsformat
a) Wie breit (in Bit) ist das MMIX Befehlswort?
b) Skizzieren Sie das MMIX Befehlswort und geben Sie den Inhalt jedes Bytes an.
c) In welchen Byte des Befehlsworts wird im Allgemeinen Information über die
Quelloperanden bzw. über die Zieloperanden abgespeichert?
d) Bei welchen Befehlen wird die Information über die Befehle anders abgespeichert?
Wie?
e) Warum verwenden diese Befehle X, Y und Z anders als die übrigen MMIX-Befehle?
f) Was ist ein Direktoperand?
Nachfolgende Abbildung zeigt die Codierung der MMIX-Opcodes sowie die zur Befehls-
ausführung benötigte Zeit.:
2.2 MMIX Architektur 39
! "#$%
!"#"$% &'()*+,-.%(*/%012'(*/%!&'(!)*+*,-(#.*-/!01234/*5!67*8434/*9!:;</!=*8>((!7'3,+4-=*7/*<!?'@*--*!A@*<(*BCBD!!
0x..0 0x..1 0x..2 0x..3 0x..4 0x..5 0x..6 0x..7
TRAP 5ν FCMP ν FUN ν FEQL ν FADD 4ν FIX 4ν FSUB 4ν FIXU 4ν
FMUL 4ν FCMPE 4ν FUNE ν FEQLE 4ν FDIV 40ν FSQRT 40ν FREM 4ν FINT 4ν
SETH ν SETMH ν SETML ν SETL ν INCH ν INCHM ν INCML ν INCL νORH ν ORMH ν ORML ν ORL ν ANDNH ν ANDNMH ν ANDNML ν ANDNL ν
POP 3ν RESUME 5ν SYNC ν SWYM ν GET ν TRIP 5ν0x..8 0x..9 0x..A 0x..B 0x..C 0x..D 0x..E 0x..F
SUB[I] ν
CSNP[I] νZSP[I] ν
SUBU[I] ν16ADDU[I] νNEGU[I] νSRU[I]ν
BOD[B] ν+πBEV[B] ν+πPBOD[B] 3ν-π
CMPU[I] νSLU[I] νBZ[B] ν+πBNZ[B] ν+πPBZ[B] 3ν-π
CSNZ[I] νZSZ[I] ν
ADD[I] ν
CSNN[I] νZSN[I] ν
ADDU[I] ν4ADDU[I] ν
PBNZ[B] 3ν-πCSZ[I] ν
0x0.. 0x0..FLOT[I] 4ν FLOTU[I] 4ν SFLOT[I] 4ν SFLOTU[I] 4ν
PUSHJ[B] ν GETA[B] ν PUT[I] ν[UN]SAVE 20µ+ν
XOR[I] νNXOR[I] νODIF[I] νMXOR[I] ν
STWU[I] µ+νSTOU[I] µ+νSTUNC[I] µ+νPUSHGO[I] 3ν
LDWU[I] µ+νLDOU[I] µ+νLDUNC[I] µ+νGO[I] 3ν
CSOD[I] νPBEV[B] 3ν-π
ZSEV[I] ν
CSEV[I] νZSOD[I] ν
NAND[I] νTDIF[I] νMOR[I] ν
STO[I] µ+νSTCO[I] µ+νSYNCID[I] νNOR[I] ν
LDO[I] µ+νCSWAP[I] 2µ+2νPREGO[I] νSTW[I] µ+ν
PBNP[B] 3ν-πCSP[I] ν
ZSNP[I] νLDW[I] µ+ν
BNP[B] ν+πPBP[B] 3ν-π
8ADDU[I] νNEG[I] νSR[I] νBP[B] ν+π
ORN[I] νANDN[I] νWDIF[I] νSADD[I] ν
STBU[I] µ+νSTTU[I] µ+νSTHT[I] µ+νPREST[I] ν
LDBU[I] µ+νLDTU[I] µ+νLDHT[I] µ+νPRELD[I] ν
ZSNZ[I] ν
BDIF[I] νMUX[I] ν
JMP[B] ν
STSF[I] µ+νSYNCD[I] νOR[I] νAND[I] ν
LDSF[I] µ+νLDVTS[I] νSTB[I] µ+νSTT[I] µ+ν
BNN[B] ν+πPBN[B] 3ν-πPBNN[B] 3ν-πCSN[I] ν
ZSNN[I] νLDB[I] µ+νLDT[I] µ+ν
2ADDU[I] νCMP[I] νSL[I] νBN[B] ν+π
0xC..
0xD..
0xE..
0xF..
0x8..
0x9..
0xA..
0xB..
0xD..
0xE..
0xF..
0x1..
0x2..
0x3..
0x4..
0x5..
0x6..
0x7..
0x9..
0xA..
0xB..
0xC..
0x5..
0x6..
0x7..
0x8..
0x1..
0x2..
0x3..
0x4..
MUL[I] 10ν MULU[I] 10ν DIV[I] 60ν DIVU[I] 60ν
!!!&'(!*<(B*!E;@@-*!0F!);B#G*<B9!/*(!1234/*(!*7B(2<;3,B!/*<!&422*-C*;-*!0H!@;(!IJ95! ;7!/*<!(;3,!/*<!)*#+*,-(34/*!@*+;7/*BD!!!&'(!C:*;B*!E;@@-*!/*(!1234/*(!*<=;@B!(;3,!:;*!+4-=BK!!
−! 6L)!0);B!E<D!"9!/*(!C:*;B*7!E;@@-*(!+! H5!:*77!(;3,!/*<!)*+*,-!;8!4@*<*7!?*;-!/*<!&422*-!"#$"!@*+;7/*B!+! I5!:*77!(;3,!/*<!)*+*,-!;8!M7B*<*7!?*;-!/*<!&422*-!"#$"!@*+;7/*B!!
!−! );B(!$5!I!M7/!H!/*(!C:*;B*7!E;@@-*(!*7B(2<*3,*7!/*<!%&'$("!0H!@;(!%95!;7!/*8!(;3,!/*<!)*+*,-(#34/*!@*+;7/*B!
![I]!@*/*MB*BK!N88*/;'B*#O'<;'7B*!/*(!)*+*,-(!
−! ;88*/;'B*!⇔!&;<*PB42*<'7/!−! ADD $1,$2,$3K!7;3,B!;88*/;'B*5!/'!/*<!"D!12*<'7/!*;7!Q*=;(B*<!;(B!M7/!P*;7*!R',-!−! ADD $1,$2,3K!;88*/;'B*5!/'!'-(!"D!12*<'7/!*;7*!R',-!'7=*=*@*7!;(B!M7/!P*;7!Q*=;(B*<!−! /*<! 1234/*! /*<! ;88*/;'B*#O'<;'7B*! *;7*(! )*+*,-(! ;(B! ;88*<! M8! I! ,S,*<! '-(! /;*! 7;3,B#;88*/;'B*#O'<;'7B*!/*(!)*+*,-(!0(B*,B!;7!/*<!&422*-)&'$("!'-(4!<*3,B(9!
−! *;7*! ;88*/;'B*#O'<;'7B*!/*(!)*+*,-(!:;</!T48!U((*8@-*<!'MB48'B;(3,!'7,'7/!/*(! +*,-*7/*7!&4--'<#R*;3,*7(! 0$9! *<P'77B5! :*(,'-@! ;8! V<4=<'88! 7;3,B! *W2-;C;B!ADDI! =*(3,<;*@*7! :*</*7!8M((!!!
g) Was bedeutet ⌫?
h) Was bedeutet ⇡?
40 2 Assemblerprogrammierung
i) Wieviele Takte benötigt der BZ-Befehl, wenn gesprungen wird?
j) Wieviele Takte benötigt der BZ-Befehl, wenn nicht gesprungen wird?
k) Wieviele Takte benötigt der PBZ-Befehl, wenn gesprungen wird?
l) Wieviele Takte benötigt der PBZ-Befehl, wenn nicht gesprungen wird?
m) Was bedeutet µ?
2.2 MMIX Architektur 41
n) Wie kann man mit dieser Tabelle einen MMIX-Opcode ermitteln?
42 2 Assemblerprogrammierung
o) Geben Sie das 32 Bit breite Befehlswort des Befehls ‘‘SL $1,$2,3’’ an.
p) Welcher Befehl benötigt die längste Zeit zur Ausführung, wenn man von Speicher-
befehlen absieht?
q) Wieviele Taktzyklen benötigen die meisten Befehlen zur Ausführung?
r) Was ist der Opcode des JMP-Befehls beim Vorwärts- bzw. beim Rückwärtss-
prung?
Betrachten Sie die folgenden Befehle:
LOC Data_SegmentGREG @
A OCTA 1000
a IS $1b IS $2
LOC #100Main LDB a,AStart SUB a,a,1
OR a,a,0BZ a,EndJMP StartTRAP 0,0,0
s) Bestimmen Sie das 32 Bit breite Befehlswort des Befehls ‘‘JMP Start’’.
2.3 MMIX Befehle 43
2.3 MMIX Befehle
Definitionen
Wort
w
b ist ein Wort der Länge b Byte. wb
x
repräsentiert Bit Nr. x im Datenwort wb, wobei das
niederwertigste Bit in w
b an Bitposition x = 0 liegt. wb
x ...y meint Bits x ...y des Datenworts
w
b.
Befehlswort
Sei ◆ ein 32 Bit breites MMIX Befehlswort.
• X = ◆23...16
• Y = ◆15...8
• Z = ◆7...0
• YZ = ◆15...0
• XY = ◆23...8
• XYZ = ◆23...0
Allzweckregister
• Der MMIX-Prozessor verfügt über 256 Allzweckregister, die mit 0, 1, ... 255
durchnummeriert werden.
• Zur Adressierung eines Allzweckregisters im Befehlswort wird die als vor-
zeichenlose 8 Bit breite Zahl codierte Registernummer verwendet. Beispiel:
Register 5 wird als 0x05 bzw. als Bitkombination 00000101 codiert.
• $x , 0 x 255 entspricht der Bitkombination, die in Register x gespeichert ist.
• $X ist die Bitkombination, die in dem durch Bits 23...16 des Befehlsworts
adressierten Register gespeichert ist. Beispiel: Befehlswort ist 0x12345678;
Bits 23...16 extrahieren ) 0x34 (= Bitkombination 00110100) = Dezimal 52 )Im Falle des Befehlsworts 0x12345678 meint $X den Wert, der in Register 52
gespeichert ist.
• $Y ist die Bitkombination, die in dem durch Bits 15...8 des Befehlsworts
adressierten Register gespeichert ist.
• $Z ist die Bitkombination, die in dem durch Bits 7...0 des Befehlsworts adres-
sierten Register gespeichert ist.
44 2 Assemblerprogrammierung
Spezialregister
Spezialregister werden im Befehlswort wie folgt codiert:
rB: 0x00 rC: 0x08 rQ: 0x10 rW: 0x18rD: 0x01 rN: 0x09 rU: 0x11 rX: 0x19rE: 0x02 rO: 0x0A rV: 0x12 rY: 0x1ArH: 0x03 rS: 0x0B rG: 0x13 rZ: 0x1BrJ: 0x04 rI: 0x0C rL: 0x14 rWW: 0x1CrM: 0x05 rT: 0x0D rA: 0x15 rXX: 0x1DrR: 0x06 rTT: 0x0E rF: 0x16 rYY: 0x1ErBB: 0x07 rK: 0x0F rP: 0x17 rZZ: 0x1F
Arbeitsspeicher
M ist der Arbeitsspeicher des MMIX Prozessors (M = memory).
• M1[x ] ist das an Adresse x gespeicherte Byte.
• M2[x ] ist das an Adresse x &(�2) gespeicherte Wyde.
• M3[x ] ist das an Adresse x &(�4) gespeicherte Tetra.
• M4[x ] ist das an Adresse x &(�8) gespeicherte Octa.
Die Symbole ◆, X, Y, Z, $X, $Y, $Z, $0, $1, ..., M1[...], M2[...], ... repräsentieren Bitmuster.
Ein Zahlenwert entsteht erst durch entsprechende Interpretation des Bitmusters (z.B.
vorzeichenlose Festkommazahl, ...).
Befehlszähler
@
2.3 MMIX Befehle 45
Operationen
• x y : Weise x den Wert y zu
• x , y : Ausdruck x ist äquivalent zum Ausdruck y
• x ) y : Wenn x , dann y
• x ||y : Logische operation x ODER y
• x = y : Vergleich ob x den gleichen Wert hat wie y ; liefert wahr (d.h. 1), wenn x
den selben Wert hat wie y , sonst falsch (d.h. 0)
• x ⌧ y : Schiebe x um y Stellen nach links; fülle frei werdende Bitstellen mit 0
auf
• x �u
y : Schiebe x um y Bitstellen nach rechts; fülle frei werdende Bitstellen
mit 0 auf
• x �s
y : Schiebe x um y Bitstellen nach rechts; fülle frei werdende Bitstellen mit
dem Wert des Vorzeichenbits (MSB) auf.
• x % y : Rest der Festkomma-Division x/y .
• ⇠ x : Invertiere alle Bits von x , d.h. berechne das 1er-Komplement
• x & y : Bitweise UND-Verknüpfung von x und y
• x | y : Bitweise ODER-Verknüpfung von x und y
• x ⌦ y : Bitweise XOR-Verknüpfung von x und y
Umwandlung Festkommazahl$ Gleitkommazahl
• f32(w4): Nimmt an, dass das vier Byte breite Datenwort w4 im 32 Bit IEEE 754
Gleitkommaformat codiert ist und gibt den entsprechenden Zahlenwert zurück
(z.B. 1,75).
• f
032(x): Codiert die Zahl x als 32 Bit breite Gleitkommazahl und gibt das
entsprechende 32 Bit breite Bitmuster zurück.
• f64(w8): Nimmt an, dass das acht Byte breite Datenwort w8 im 64 Bit IEEE 754
Gleitkommaformat codiert ist und gibt den entsprechenden Zahlenwert zurück
(z.B. 1,75).
• f
064(x): Codiert die Zahl x als 64 Bit breite Gleitkommazahl und gibt das
entsprechende 64 Bit breite Bitmuster zurück.
• r(x): Rundet eine reelle Zahl gemäß dem in Register rA ausgewählten Run-
dungsmodus auf eine ganze Zahl.
46 2 Assemblerprogrammierung
(De-) Codierung von Festkommazahlen
• s(wb): Nimmt an, dass das b Byte breite Wort wb im 2er-Komplement codiert
ist und gibt den entsprechenden Wert zurück (z.B. 1, 0, -3)
• u(wb): Nimmt an, dass das b Byte breite Wort wb als vorzeichenlose Festkom-
mazahl codiert ist und gibt den entsprechenden Wert zurück (z.B. 0, 1)
• s
0b
(x): Gibt das b Bit breite im 2er-Komplement codiert Bitmuster zurück das
dem Wert x entspricht.
• u
0b
(x): Gibt das b Bit breite Bitmuster (vorzeichenlose Codierung) zurück das
dem Wert x , x � 0, entspricht.
Zusammenfassen von in Registern gespeicherten Werten
Wenn $X das 64 Bit breite in Register X gespeicherte Bitmuster ist und $Y das 64 Bit breitein Register Y gespeicherte Bitmuster ist, dann ist $X$Y das 128 Bit breite Bitmuster das
aus der Aneinanderreihung der beiden Bitmuster $X und $Y entsteht. ($X$Y)127...64 = $Xund ($X$Y)63...0 = $Y.
Programm beenden
• TRAP 0,Halt,0 beendet ein MMIX-Programm und gibt die Kontrolle zurück an
das Betriebssystem.
2.3 MMIX Befehle 47
Lade- und Speicherbefehle
Daten vom Speicher in ein Register laden
Befehl Operanden Name/Aktion Definition
LDB$X,$Y,$Z Load byte $X s
064(s(M1[u($Y) + u($Z)]))
$X,$Y,Z Load byte immediate $X s
064(s(M1[u($Y) + u(Z)]))
LDBU$X,$Y,$Z Load byte unsigned $X u
064(u(M1[u($Y) + u($Z)]))
$X,$Y,Z Load byte uns. immed. $X u
064(u(M1[u($Y) + u(Z)]))
LDW$X,$Y,$Z Load wyde $X s
064(s(M2[u($Y) + u($Z)]))
$X,$Y,Z Load wyde immediate $X s
064(s(M2[u($Y) + u(Z)]))
LDWU$X,$Y,$Z Load wyde unsigned $X u
064(u(M2[u($Y) + u($Z)]))
$X,$Y,Z Load wyde uns. immed. $X u
064(u(M2[u($Y) + u(Z)]))
LDT$X,$Y,$Z Load tetra $X s
064(s(M4[u($Y) + u($Z)]))
$X,$Y,Z Load tetra immediate $X s
064(s(M4[u($Y) + u(Z)]))
LDTU$X,$Y,$Z Load tetra unsigned $X u
064(u(M4[u($Y) + u($Z)]))
$X,$Y,Z Load tetra uns. immed. $X u
064(u(M4[u($Y) + u(Z)]))
LDO$X,$Y,$Z Load octa $X M8[u($Y) + u($Z)]$X,$Y,Z Load octa immediate $X M8[u($Y) + u(Z)]
LDOU$X,$Y,$Z Load octa unsigned $X M8[u($Y) + u($Z)]$X,$Y,Z Load octa uns. immed. $X M8[u($Y) + u(Z)]
48 2 Assemblerprogrammierung
a) Welche Wortgrößen kann der MMIX vom Speicher in Register laden?
b) Was ist der Unterschied zwischen vorzeichenbehaftetem (signed) und vorzeichen-
losen (unsigned) Laden?
c) Warum muss man zwischen vorzeichenlosem und vorzeichenbehaftetem Laden
unterscheiden?
d) Wie unterscheiden sich die Namen der vorzeichenlosen und vorzeichenbehafteten
Ladebefehle?
2.3 MMIX Befehle 49
e) Wie unterscheiden sich die Opcodes von vorzeichenlosen und vorzeichenbehaf-
teten Ladebefehlen?
f) Nehmen Sie an, dass die vorzeichenbehaftete 8 Bit breite Zahl -64 mit dem
LDB-Befehl in ein Allzweckregister geladen wurde und geben Sie alle Bits des
Allzweckregisters in hexadezimaler Notation aus.
g) Welcher Wert würde im Allzweckregister stehen, wenn die Zahl -64 versehentlich
mit einem LDBU-Befehl statt mit einem LDB-Befehl in das Allzweckregister geladen
worden wäre? Geben Sie den Wert in der Basis 10 an.
h) Wie können die Ladebefehle 64 Bit breite Speicheradressen adressieren, obwohl
im Befehlswort nur 16 Bit zur Darstellung der Adresse verfügbar sind?
50 2 Assemblerprogrammierung
i) Zeichnen Sie in die nachfolgende Darstellung ein, wie die 64 Bit breite Adresse
generiert wird.
8, 16, 32, 64 Bit
64 Bit
OP X Y Z
8, 16, 24 Bit
64 Bit
64 Bit
Spezial- Register
Allzweck- Register
Speicher
Rechen- werk (ALU)
32 Bit Befehlswort
j) Vervollständigen Sie den nachfolgenden MMIX-Code um die Bereitstellung und
Initialisierung eines Basisregisters zur Adressierung von A, B und C.
LOC #2000000000000000
A BYTE 0B OCTA #FFFFC OCTA
LOC #100
Main LDO $0,B...
k) In welches Befehlswort übersetzt der MMIX-Assembler den Befehl LDO $0,B?
2.3 MMIX Befehle 51
l) Tragen Sie in nachfolgende Tabelle den Speicherinhalt ein, der sich nach Aus-
führung der angegebenen MMIX-Befehle im Falle von Big- und Little-Endian-
Adressierung ergibt.
LOC Data_SegmentGREG @BYTE 1TETRA #23456789TETRA #ABCDEF01BYTE #77WYDE #0123
0x2000000000000000
0x2000000000000001
0x2000000000000002
0x2000000000000003
0x2000000000000004
0x2000000000000005
0x2000000000000006
0x2000000000000007
0x2000000000000008
0x2000000000000009
0x200000000000000A
0x200000000000000B
0x200000000000000C
0x200000000000000D
0x200000000000000E
0x200000000000000F
0000
0001
0010
0011
0100
0101
0110
0111
1000
1001
1010
1011
1100
1101
1110
1111
Adresse Niederwert. vier Adress-Bits
Big Endian Little Endian
52 2 Assemblerprogrammierung
m) Nehmen Sie die gezeigte Speicherbelegung an und geben Sie hexadezimal alle 64
Bit des Registers 0 nach Ausführung der folgenden Befehle an:
LDB $0,$254,0:
LDB $0,$254,1:
LDB $0,$254,6:
n) Nehmen Sie die gezeigte Speicherbelegung an und geben Sie hexadezimal alle 64
Bit des Registers 0 nach Ausführung der folgenden Befehle an:
LDT $0,$254,0:
LDT $0,$254,1:
LDT $0,$254,6:
o) Nehmen Sie die gezeigte Speicherbelegung an und geben Sie hexadezimal alle 64
Bit des Registers 0 nach Ausführung der folgenden Befehle an:
LDO $0,$254,0:
LDO $0,$254,1:
LDO $0,$254,6:
2.3 MMIX Befehle 53
Adressen in ein Register laden
Befehl Operanden Name/Aktion Definition
LDA$X,$Y,$Z Get address (absolute) $X u
064(u($Y) + u($Z))
$X,$Y,Z Get address immed. (absolute) $X u
064(u($Y) + u(Z))
GETA $X,YZ Get address (relativ) $X u
064(u(@) + 4 · s(YZ))
a) Was ist der Unterschied zwischen dem Befehl LDA und den Ladebefehlen LDB, ... ?
Nehmen Sie die folgenden Befehle an:
LOC Data_SegmentGREG @ $254 @
A BYTE #12
LOC #100Main LDA $0,A
TRAP 0,Halt,0
b) In welches hexadezimale Befehlswort wird der Befehl LDA $0,A übersetzt?Warum?
c) In welches hexadezimale Befehlswort sollte der Befehl LDA $0,Main übersetzt
werden?
54 2 Assemblerprogrammierung
! "#$%
!"#"$% &'()*+,-.%(*/%012'(*/%!&'(!)*+*,-(#.*-/!01234/*5!67*8434/*9!:;</!=*8>((!7'3,+4-=*7/*<!?'@*--*!A@*<(*BCBD!!
0x..0 0x..1 0x..2 0x..3 0x..4 0x..5 0x..6 0x..7
TRAP 5ν FCMP ν FUN ν FEQL ν FADD 4ν FIX 4ν FSUB 4ν FIXU 4ν
FMUL 4ν FCMPE 4ν FUNE ν FEQLE 4ν FDIV 40ν FSQRT 40ν FREM 4ν FINT 4ν
SETH ν SETMH ν SETML ν SETL ν INCH ν INCHM ν INCML ν INCL νORH ν ORMH ν ORML ν ORL ν ANDNH ν ANDNMH ν ANDNML ν ANDNL ν
POP 3ν RESUME 5ν SYNC ν SWYM ν GET ν TRIP 5ν0x..8 0x..9 0x..A 0x..B 0x..C 0x..D 0x..E 0x..F
SUB[I] ν
CSNP[I] νZSP[I] ν
SUBU[I] ν16ADDU[I] νNEGU[I] νSRU[I]ν
BOD[B] ν+πBEV[B] ν+πPBOD[B] 3ν-π
CMPU[I] νSLU[I] νBZ[B] ν+πBNZ[B] ν+πPBZ[B] 3ν-π
CSNZ[I] νZSZ[I] ν
ADD[I] ν
CSNN[I] νZSN[I] ν
ADDU[I] ν4ADDU[I] ν
PBNZ[B] 3ν-πCSZ[I] ν
0x0.. 0x0..FLOT[I] 4ν FLOTU[I] 4ν SFLOT[I] 4ν SFLOTU[I] 4ν
PUSHJ[B] ν GETA[B] ν PUT[I] ν[UN]SAVE 20µ+ν
XOR[I] νNXOR[I] νODIF[I] νMXOR[I] ν
STWU[I] µ+νSTOU[I] µ+νSTUNC[I] µ+νPUSHGO[I] 3ν
LDWU[I] µ+νLDOU[I] µ+νLDUNC[I] µ+νGO[I] 3ν
CSOD[I] νPBEV[B] 3ν-π
ZSEV[I] ν
CSEV[I] νZSOD[I] ν
NAND[I] νTDIF[I] νMOR[I] ν
STO[I] µ+νSTCO[I] µ+νSYNCID[I] νNOR[I] ν
LDO[I] µ+νCSWAP[I] 2µ+2νPREGO[I] νSTW[I] µ+ν
PBNP[B] 3ν-πCSP[I] ν
ZSNP[I] νLDW[I] µ+ν
BNP[B] ν+πPBP[B] 3ν-π
8ADDU[I] νNEG[I] νSR[I] νBP[B] ν+π
ORN[I] νANDN[I] νWDIF[I] νSADD[I] ν
STBU[I] µ+νSTTU[I] µ+νSTHT[I] µ+νPREST[I] ν
LDBU[I] µ+νLDTU[I] µ+νLDHT[I] µ+νPRELD[I] ν
ZSNZ[I] ν
BDIF[I] νMUX[I] ν
JMP[B] ν
STSF[I] µ+νSYNCD[I] νOR[I] νAND[I] ν
LDSF[I] µ+νLDVTS[I] νSTB[I] µ+νSTT[I] µ+ν
BNN[B] ν+πPBN[B] 3ν-πPBNN[B] 3ν-πCSN[I] ν
ZSNN[I] νLDB[I] µ+νLDT[I] µ+ν
2ADDU[I] νCMP[I] νSL[I] νBN[B] ν+π
0xC..
0xD..
0xE..
0xF..
0x8..
0x9..
0xA..
0xB..
0xD..
0xE..
0xF..
0x1..
0x2..
0x3..
0x4..
0x5..
0x6..
0x7..
0x9..
0xA..
0xB..
0xC..
0x5..
0x6..
0x7..
0x8..
0x1..
0x2..
0x3..
0x4..
MUL[I] 10ν MULU[I] 10ν DIV[I] 60ν DIVU[I] 60ν
!!!&'(!*<(B*!E;@@-*!0F!);B#G*<B9!/*(!1234/*(!*7B(2<;3,B!/*<!&422*-C*;-*!0H!@;(!IJ95! ;7!/*<!(;3,!/*<!)*#+*,-(34/*!@*+;7/*BD!!!&'(!C:*;B*!E;@@-*!/*(!1234/*(!*<=;@B!(;3,!:;*!+4-=BK!!
−! 6L)!0);B!E<D!"9!/*(!C:*;B*7!E;@@-*(!+! H5!:*77!(;3,!/*<!)*+*,-!;8!4@*<*7!?*;-!/*<!&422*-!"#$"!@*+;7/*B!+! I5!:*77!(;3,!/*<!)*+*,-!;8!M7B*<*7!?*;-!/*<!&422*-!"#$"!@*+;7/*B!!
!−! );B(!$5!I!M7/!H!/*(!C:*;B*7!E;@@-*(!*7B(2<*3,*7!/*<!%&'$("!0H!@;(!%95!;7!/*8!(;3,!/*<!)*+*,-(#34/*!@*+;7/*B!
![I]!@*/*MB*BK!N88*/;'B*#O'<;'7B*!/*(!)*+*,-(!
−! ;88*/;'B*!⇔!&;<*PB42*<'7/!−! ADD $1,$2,$3K!7;3,B!;88*/;'B*5!/'!/*<!"D!12*<'7/!*;7!Q*=;(B*<!;(B!M7/!P*;7*!R',-!−! ADD $1,$2,3K!;88*/;'B*5!/'!'-(!"D!12*<'7/!*;7*!R',-!'7=*=*@*7!;(B!M7/!P*;7!Q*=;(B*<!−! /*<! 1234/*! /*<! ;88*/;'B*#O'<;'7B*! *;7*(! )*+*,-(! ;(B! ;88*<! M8! I! ,S,*<! '-(! /;*! 7;3,B#;88*/;'B*#O'<;'7B*!/*(!)*+*,-(!0(B*,B!;7!/*<!&422*-)&'$("!'-(4!<*3,B(9!
−! *;7*! ;88*/;'B*#O'<;'7B*!/*(!)*+*,-(!:;</!T48!U((*8@-*<!'MB48'B;(3,!'7,'7/!/*(! +*,-*7/*7!&4--'<#R*;3,*7(! 0$9! *<P'77B5! :*(,'-@! ;8! V<4=<'88! 7;3,B! *W2-;C;B!ADDI! =*(3,<;*@*7! :*</*7!8M((!!!
Gegeben sind die folgenden Befehle:
LOC Data_SegmentGREG @
A BYTE #12
LOC #100Main LDA $0,A
GETA $0,MainTRAP 0,Halt,0
d) In welches 32 Bit breite Befehlswort wird der Befehl GETA $0,Main übersetzt?
2.3 MMIX Befehle 55
Daten vom Register in den Speicher schreiben (speichern)
Befehl Operanden Name/Aktion Definition
STB
$X,$Y,$Z Store byte; with overflow
M1[u($Y) + u($Z)] ($X)7...0s($X) � 27 ) rA rA | u064(26)
s($X) < �27 ) rA rA | u064(26)
$X,$Y,Z Store byte immed.; ovf.
M1[u($Y) + u(Z)] ($X)7...0s($X) � 27 ) rA rA | u064(26)
s($X) < �27 ) rA rA | u064(26)
STBU$X,$Y,$Z Store byte unsigned M1[u($Y) + u(Z)] ($X)7...0$X,$Y,Z Store byte uns. imm. M1[u($Y) + u(Z)] ($X)7...0
STW
$X,$Y,$Z Store wyde; with overflow
M2[u($Y) + u(Z)] ($X)15...0s($X) � 215 ) rA rA | u064(26)
s($X) < �215 ) rA rA | u064(26)
$X,$Y,Z Store wyde immed.; ovf.
M2[u($Y) + u(Z)] ($X)15...0s($X) � 215 ) rA rA | u064(26)
s($X) < �215 ) rA rA | u064(26)
STWU$X,$Y,$Z Store wyde unsigned M2[u($Y) + u(Z)] ($X)15...0$X,$Y,Z Store wyde uns. imm. M2[u($Y) + u(Z)] ($X)15...0
STT
$X,$Y,$Z Store tetra; with overflow
M4[u($Y) + u(Z)] ($X)31...0s($X) � 231 ) rA rA | u064(26)
s($X) < �231 ) rA rA | u064(26)
$X,$Y,Z Store tetra immed.; ovf.
M4[u($Y) + u(Z)] ($X)31...0s($X) � 231 ) rA rA | u064(26)
s($X) < �231 ) rA rA | u064(26)
STTU$X,$Y,$Z Store byte unsigned M4[u($Y) + u(Z)] ($X)31...0$X,$Y,Z Store byte uns. imm. M4[u($Y) + u(Z)] ($X)31...0
STO$X,$Y,$Z Store octa M8[u($Y) + u(Z)] $X$X,$Y,Z Store octa immediate M8[u($Y) + u(Z)] $X
STOU$X,$Y,$Z Store octa unsigned M8[u($Y) + u(Z)] $X$X,$Y,Z Store octa uns. imm. M8[u($Y) + u(Z)] $X
56 2 Assemblerprogrammierung
a) Wie unterscheidet sich die Verwendung von X, Y und Z bei Speicher-Befehle von
derjenigen aller anderen MMIX-Befehle?
b) Was ist beim MMIX der Unterschied zwischen vorzeichenbehaftetem und vorzei-
chenlosem Speichern?
In folgendem Programmcode wird XXX XXXXXXXX als Platzhalter für einen einzelnen
Befehl verwendet:
LOC Data_SegmentGREG @
A OCTA #FFFF FFFF FFFF FFFFB TETRA #8765 4321
LOC #100Main LDTU $0,B
XXX XXXXXXXXTRAP 0,Halt,0
2.3 MMIX Befehle 57
c) Geben Sie für das oben gezeigte Programm den Inhalt des 64 Bit breiten Wortes
an, welches durch die Marke A adressiert wird, wenn XXX XXXXXXXX durch folgende
Befehle ersetzt wird:
STB $0,A:
STW $0,A:
STWU $0,A:
STT $0,A:
STTU $0,A:
STO $0,A:
STB $0,$254,5:
STW $0,$254,1:
STT $0,$254,6:
ST0 $0,$254,5:
d) Geben Sie hexadezimal das 32 Bit breite Befehlswort des Befehls STBU $0,A an,
wenn dieser in obigem Programmcode den Platzhalter XXX XXXXXXXX ersetzt.
58 2 Assemblerprogrammierung
e) Geben Sie die Befehle an, mit denen Sie
• an Adresse 0x2000 0000 0000 0000 ein 64 Bit breites Datum anlegen,
• dieses Datum über die Marke Data ansprechbar machen und
• das Datenwort mit 0x1234 5678 initialisieren;
• an Adresse 0x100 ein Programm beginnen und
• das an Adresse Data gespeicherte Datenwort in Register 1 einlesen,
• Bits 7 ... 0 des Registers 1 an Adresse Data schreiben,
• Bits 7 ... 0 des Registers 1 an Adresse 0x2000 0000 0000 0002 schreiben,
• Bits 31 ... 0 des Registers 1 an Adresse 0x2000 0000 0000 000A schreiben.
2.3 MMIX Befehle 59
Gegeben ist der folgende Programmcode:
LOC Data_SegementGREG @
Label OCTA #1234 5678
LOC #100Main LDO $0,Label
STB $0,LabelLDA $2,LabelSTB $0,$2,2STT $0,$2,10
f) Zeichnen Sie byteweise den Inhalt des Speichers von Adresse 0x20 ... 00 bis
0x20 ... 00F, der sich nach Ausführung des o.g. Programms ergibt.
60 2 Assemblerprogrammierung
Direktoperand in Register schreiben
Befehl Operanden Name/Aktion Definition
SETL $X,YZ Set to low wyde $X u
064(u(YZ))
SETML $X,YZ Set to med. low wyde $X u
064(u(YZ⌧ 16))
SETMH $X,YZ Set to med. high wyde $X u
064(u(YZ⌧ 32))
SETH $X,YZ Set to high wyde $X u
064(u((YZ⌧ 48))
INCL $X,YZ Increase by low wyde $X u
064(u($X) + u(YZ))
INCML $X,YZ Inc. by med. low wyde $X u
064(u($X) + u(YZ⌧ 16))
INCMH $X,YZ Inc. by med. high wyde $X u
064(u($X) + u(YZ⌧ 32))
INCH $X,YZ Increase by high wyde $X u
064(u($X) + u(YZ⌧ 48))
a) Geben Sie die Befehle an, mit denen Sie ausschließlich durch die Verwendung von
Direktoperanden die Zahl 0x0123 4567 89AB CDEF in Register $0 schreiben.
2.3 MMIX Befehle 61
Gegeben ist der folgende Anfang eines Programms:
LOC Data_SegmentGREG @
Pi32 TETRA #40490FDB ⇡ als 32 Bit Gleitk.Pi32t TETRA �⇡ als 32 Bit Gleitk.
b) Schreiben Sie einMMIX-Programm,mit demSie die 32 Bit breite Gleitkommazahl ⇡
vonMarke Pi32 in Register 0 einlesen, dannmit einem SETxx oder INCxx Befehl dasVorzeichen der Gleitkommazahl ändern und �⇡ dann als 32 Bit Gleitkommazahl
an Marke Pi32t schreiben.
62 2 Assemblerprogrammierung
c) Berechnen Sie die Binärdarstellung der 64 Bit Gleitkommazahl 12.341,3125.
Schreiben Sie dann ein MMIX-Programm das die Gleitkommazahl 12.341,3125
in Register 0 ablegt. Dabei sollen ausschließlich Direktoperanden verwendet wer-
den. Anschließend soll Register 0 an Adresse 0x2000 0000 0000 0100 abgelegt
werden.
2.3 MMIX Befehle 63
Umwandlung Gleitkommazahl$ Festkommazahl
Befehl Operanden Name/Aktion Definition
FLOT$X,$Z Convert fixed to floating $X f
064( s($Z) )
$X,Z Conv. fixed to float. imm. $X f
064( u(Z) )
FLOTU$X,$Z Conv. uns. fixed to floating $X f
064( u($Z) )
$X,Z Conv. uns. fixed to float.
imm.
$X f
064( u(Z) )
FIX $X,$ZConvert floating to fixed
with overflow
$X s
064( r( f64($Z) ) )
f64($Z) < �263 ) rA rA|u064(25)f64($Z) > 263�1) rA rA|u064(25)
FIXU $X,$ZConvert floating to fixed
without overflow$X s
064( r( f64($Z) ) )
a) Welche Aktion führt der Operator r() aus?
b) Geben Sie den Befehl an, mit dem Sie Register 0 die Gleitkommazahl 15,0
zuweisen.
c) Geben Sie den Befehl an, mit dem Sie eine Gleitkommazahl in Register 1 in eine
Festkommazahl umwandeln.
64 2 Assemblerprogrammierung
Arithmetische Befehle
Arithmetische Befehle auf Festkommazahlen
BefehlOperanden Name/Aktion Definition
ADD
$X,$Y,$Z Add; signed, with overflow
$X s
064(s($Y) + s($Z))
(s($Y) + s($Z) < �263) ||(s($Y) + s($Z) � 263))
rA rA|u064(25)
$X,$Y,Z Add immediate; signed, with overflow
$X s
064(s($Y) + u(Z))
(s($Y) + s(Z) < �263) ||(s($Y) + s(Z) � 263))
rA rA|u064(25)
ADDU$X,$Y,$Z Add unsigned; no overflow $X u
064(u($Y) + u($Z))
$X,$Y,Z Add unsigned; no overflow $X u
064(u($Y) + u(Z))
SUB
$X,$Y,$Z Subtract; signed, with overflow
$X s
064(s($Y)� s($Z))
(s($Y)� s($Z) < �263) ||(s($Y)� s($Z) � 263))
rA rA|u064(25)
$X,$Y,Z Subtract immediate; signed, with overflow
$X s
064(s($Y)� u(Z))
(s($Y)� s(Z) < �263) ||(s($Y)� s(Z) � 263))
rA rA|u064(25)
SUBU$X,$Y,$Z Subtract unsigned; no overflow $X u
064(u($Y)� u($Z))
$X,$Y,Z Subtract unsigned immed.; no ovf. $X u
064(u($Y)� u(Z))
NEG$X,Y,$Z Negate; signed, with overflow
$X s
064(u(Y)� s($Z))
u(Y)� s($Z � 263))rA rA|u064(25)
$X,Y,Z Negate immediate; signed, with overflow $X s
064(u(Y)� s(Z))
NEGU$X,Y,$Z Negate unsigned; no overflow $X s
064(u(Y)� s($Z))
$X,Y,Z Negate unsigned immed.; no overflow $X s
064(u(Y)� u(Z))
MUL$X,$Y,$Z Multiply; signed, with overflow $X s
064(s($Y) · s($Z))
$X,$Y,Z Multiply immediate; signed, with ovf. $X s
064(s($Y) · u(Z))
MULU$X,$Y,$Z Multiply unsigned; rH ($Y · $Z)127...64 rH$X u
0128(u($Y) · u($Z))
$X,$Y,Z Multiply uns. imm.; rH ($Y · Z)127...64 rH$X u
0128(u($Y) · u(Z))
2.3 MMIX Befehle 65
DIV
Divide; signed, with overflow $X s
064(bs($Y)/s($Z)c)
$X,$Y,$Z (case $Z 6= 0) rR s
064( s($Y)% s($Z) )
$X,$Y,Z Divide immediate; signed, with ovf. $X u
064(0)
(case $Z = 0) rR $Y
DIVU
$X,$Y,$Z
Divide unsigned; no overflow; $X u
0128( bu(rD$Y)/u($Z)c )
(case u($Z) > u(rD) ) rR u
0128( u(rD$Y)% u($Z) )
Divide unsigned; no overflow; $X rDno overflow (case u($Z) u(rD) ) rR $Y
$X,$Y,Z
Divide unsigned immediate; $X u
0128( bu(rD$Y)/u(Z)c )
no overflow; (case u(Z) > u(rD) ) rR u
0128( u(rD$Y)% u(Z) )
Divide unsigned immedediate; $X rDno overflow (case u(Z) u(rD) ) rR $Y
a) In welchem Wertebereich können die Direktoperanden bei den Arithmetischen
Befehlen liegen?
b) Kann mit dem ADD Befehl 3 + 5 in einer einzigen Codezeile berechnet werden?
c) Wie kann man 5� 3 in einer einzigen Codezeile berechnen?
d) Was ist der Unterschied zwischen den Befehlen MUL und MULU?
66 2 Assemblerprogrammierung
e) Geben Sie die MMIX-Befehle an, mit denen Sie x = a
2 + 2 · a · b + b
2 mit Fest-
kommazahlen berechnen. Nehmen Sie an, dass die Register a, b, und c bereits
initialiert wurden und das Ergebnis in Register x gespeichert werden soll. Benutzen
Sie Register buf1, buf2, ... für Zwischenergebnisse, falls notwendig.
Gegeben ist der folgende Programmcode:
a IS $0b IS $1c IS $2d IS $3buf1 IS $4buf2 IS $5
LOC #100Main SET b,1
SET c,2SET d,3
f) Geben Sie MMIX-Befehle an, mit denen Sie a = c·d�b
b+c+d
mit Festkommazahlen
berechnen.
2.3 MMIX Befehle 67
Arithmetische Befehle auf Gleitkommazahlen
Befehl Operanden Name/Aktion Definition
FADD $X,$Y,$Z Floating point add $X f
064( f64($Y) + f64($Z) )
FSUB $X,$Y,$Z Floating point subtract $X f
064( f64($Y)� f64($Z) )
FMUL $X,$Y,$Z Floating point multiplication $X f
064( f64($Y) · f64($Z) )
FDIV $X,$Y,$Z Floating point divide $X f
064( f64($Y)/f64($Z) )
FSQRT $X,$Z Square root $X f
064(
pf64($Z) )
a) Geben Sie MMIX-Befehle an, die ⇡ = 3.1415 in Register a ablegen.
68 2 Assemblerprogrammierung
b) Geben Sie MMIX-Befehle an, die e = 2.718281828 in Register b ablegen.
2.3 MMIX Befehle 69
c) Geben Sie MMIX-Befehle an, mit denen Sie x = a
2 + 2 · a · b + b
2 mit Gleitkomma-
Operationen berechnen. Nehmen Sie an, dass Register a und b mit Festkomma-
zahlen initialisiert wurden und zunächst in Gleitkommazahlen umgewandelt werden
müssen. Speichern Sie das Ergebnis als Gleitkommazahl in Register x. Benutzen
Sie buf1, buf2, ... als Pufferregister.
70 2 Assemblerprogrammierung
Das Volumen einer Kugel berechnet sich zu V =4
3· ⇡ · r3.
d) Vervollständigen Sie nachfolgend angegebenen MMIX-Code zur Berechnung des
Volumens einer Kugel mit Radius r = 15.37 cm. Speichern Sie das Volumen als 64
Bit breite Gleitkommazahl an Adresse V.
LOC Data_SegmentGREG @
PI OCTA #400921FB54442D18 ⇡ as float64V OCTA float
r IS $0buf1 IS $1buf2 IS $2
LOC #100
Main
2.3 MMIX Befehle 71
Schiebe-Befehle
Befehl Operanden Name/Aktion Definition
SL
$X,$Y,$Z Shift left; with overflow
$X u
064( u($Y⌧ u($Z)) )
u($Y) · 2u($Z) � 264 )rA rA|u064(25)
$X,$Y,Z Shift left immediate; with ovf.
$X u
064( u($Y⌧ u(Z)) )
u($Y) · 2u(Z) � 264 )rA rA|u064(25)
SLU$X,$Y,$Z Shift left uns., no overflow $X u
064( u($Y⌧ u($Z)) )
$X,$Y,Z Shift left uns. immed.; no ovf. $X u
064( u($Y⌧ u(Z)) )
SR$X,$Y,$Z Shift right; fill with sign $X $Y�s
u($Z)$X,$Y,Z Shift right imm.; fill with sign $X $Y�s
u(Z)
SRU$X,$Y,$Z Shift right unsigned; fill with 0 $X $Y�u
u($Z)$X,$Y,Z Shift right uns. imm.; fill w. 0 $X $Y�u
u(Z)
72 2 Assemblerprogrammierung
a) Wie unterscheiden sich der SR und der SRU Befehl?
b) In Register fpn ist eine 64 Bit Gleitkommazahl abgelegt.63 62 52 51 0
Inhalt Register fpn: s e f
Geben Sie die MMIX-Befehle an, mit denen Sie s, e und f aus Register fpn
extrahieren und in Register s, e und f ablegen.
2.3 MMIX Befehle 73
Logische Operationen auf Bit-Ebene
Befehl Operanden Name/Aktion Definition
AND$X,$Y,$Z Bitwise AND $X $Y& $Z$X,$Y,Z Bitwise AND immediate $X $Y& u
064( u(Z) )
ANDN$X,$Y,$Z Bitwise AND NOT $X $Y& ⇠ $Z$X,$Y,Z Bitww AND NOT immed. $X $Y& ⇠ u
064( u(Z) )
ANDNL $X,YZ Bitw. AND NOT low wyde $X $X& ⇠ u
064( u(YZ) )
ANDNML $X,YZ Bw. AND NOT med. l. wd. $X $X& ⇠ ( u064( u(YZ) )⌧ 16)
ANDNMH $X,YZ Bw. AND NOT med. h. wd. $X $X& ⇠ ( u064( u(YZ) )⌧ 32)
ANDNH $X,YZ Bw. AND NOT high wyde $X $X& ⇠ ( u064( u(YZ) )⌧ 48)
NAND$X,$Y,$Z Bitwise NOT AND $X ⇠ ($Y& $Z)$X,$Y,Z Bitwise NOT AND immed. $X ⇠ ( $Y& u
064( u(Z) ) )
OR$X,$Y,$Z Bitwise OR $X $Y | $Z$X,$Y,Z Bitwise OR immediate $X $Y | u064( u(Z) )
ORL $X,YZ Bitwise OR low wyde $X $X | u064( u(YZ) )
ORML $X,YZ Bitw. OR med. low wyde $X $X | ( u064( u(YZ) )⌧ 16)
ORMH $X,YZ Bitw. OR med. high wyde $X $X | ( u064( u(YZ) )⌧ 32)
ORH $X,YZ Bitwise OR high wyde $X $X | ( u064( u(YZ) )⌧ 48)
ORN$X,$Y,$Z Bitwise OR NOT $X $Y | ⇠ $Z$X,$Y,Z Bitwise OR NOT immediate $X $Y | ⇠ u
064( u(Z) )
NOR$X,$Y,$Z Bitwise NOT OR $X ⇠ ($Y | $Z)$X,$Y,Z Bitwise NOT OR immediate $X ⇠ ($Y | u064( u(Z) ) )
XOR$X,$Y,$Z Bitwise XOR $X $Y⌦ $Z$X,$Y,Z Bitwise XOR immediate $X $Y⌦ u
064( u(Z) )
NXOR$X,$Y,$Z Bitwise NOT XOR $X ⇠ ($Y⌦ $Z)$X,$Y,Z Bitw. NOT XOR immediate $X ⇠ ($Y⌦ u
064( u(Z) ) )
74 2 Assemblerprogrammierung
Bits löschen
a) Welche Befehle verwendet man typischerweise um einzelne Bits zu löschen?
Für die nachfolgenden Aufgaben soll jeweils dieses Programm verwendet werden:
LOC Data_SegmentGREG @
A OCTA #AAAA AAAA AAAA AAAA
a IS $0
LOC #100Main LDO a,A
XXX XXXXX hierXXX XXXXX MMIX-XXX XXXXX BefehleXXX XXXXX einsetzen
STO a,ATRAP 0,Halt,0
b) Ersetzen Sie in obigem Programm XX... durch MMIX-Befehle, die in Register a Bit
21 mit einem AND-Befehl löschen.
2.3 MMIX Befehle 75
c) Ersetzen Sie in obigem Programm XX... durch MMIX-Befehle, die in Register a Bit
21 mit einem ANDN-Befehl löschen.
d) Ersetzen Sie in obigem Programm XX... durch MMIX-Befehle, die in Register a Bit
21 mit einem ANDNML-Befehl löschen.
Bits setzen
a) Welche Befehle verwendet man typischerweise um Bits zu setzen?
b) Ersetzen Sie in obigem Programm XX... durch MMIX-Befehle, die in Register a Bit
20 mit einem OR-Befehl auf 1 setzen.
c) Ersetzen Sie in obigem Programm XX... durch MMIX-Befehle, die in Register a Bit
20 mit einem ORML-Befehl auf 1 setzen.
76 2 Assemblerprogrammierung
XOR
a) Erklären Sie den Effekt einer XOR-Operation.
b) Was wird dem Ziel-Operanden einer XOR-Operation zugewiesen, wenn alle Bits
des einen Quell-Operanden gelöscht (0) sind?
c) Was wird dem Ziel-Operanden einer XOR-Operation zugewiesen, wenn alle Bits
des einen Quell-Operanden gesetzt (1) sind?
2.3 MMIX Befehle 77
Gegeben ist das folgende Programm:
LOC Data_SegmentGREG @
A OCTA #AAAA AAAA AAAA AAAAB OCTA #1111 1111 1111 1111C OCTA
a IS $0b IS $1c IS $2
LOC #100Main LDO a,A
LDO b,B
XXX XXXXX hierXXX XXXXX MMIX-XXX XXXXX BefehleXXX XXXXX einfügen
STO c,CTRAP 0,Halt,0
d) Ersetzen Sie XX... durch MMIX-Befehle die a invertieren und das Ergebnis in cablegen.
78 2 Assemblerprogrammierung
Zugriff auf Spezialregister
Befehl Operanden Name/Aktion Definition
GET $X,Z Get value of special purpose register $X r [Z]
PUTX,$Z Put value to special purpose register r [X] $ZX,Z Put immed. value to spec. purp. reg. r [X] u
064(u(Z))
a) Tragen Sie in nachfolgender Befehlssequenz Befehle zur Berechnung der Fest-
kommadivisioni dividend/divisor ein und speichern Sie das Ergebnis an der
Marke Quotient und den Divisionsrest an der Marke Remainder ab.
LOC Data_SegmentGREG @
Dividend OCTA 7Divisor OCTA 3Quotient OCTARemainder OCTA
dividend IS $0divisor IS $1quotient IS $2remainder IS $3
LOC #100Main LDO dividend,Dividend
LDO divisor,Divisor
TRAP 0,Halt,0
2.3 MMIX Befehle 79
Gegeben ist das Format des Spezialregisters rA.
0 0 R1 R0 D V W I O U Z X D V W I O U Z X
Interrupt Enable (Freischalten) Interrupt Event (Auftreten)
Gleitkommazahl ungenau (z.B. 1.0 / 3.0)Gleitkomma-Division durch 0Gleitkomma-UnterlaufGleitkomma-ÜberlaufUnerlaubte Gleitkomma- Operation, z.B. sqrt(-1.0)Überlauf bei Wandlung Gleit- komma- in FestkommazahlFestkomma-ÜberlaufFestkomma-Division durch 0
00: Nächster Wert (standard)01: Abrunden (Richtung 0)10: Aufrunden (Richtung + )11: Abrunden (Richtung - )
Gleitkomma-Rundungsmodus
Nicht verwendet
88
b) Geben Sie den MMIX-Code an, mit dem Sie den Gleitkomma-Rundungsmodus
auf ‘‘aufrunden’’ setzen.
c) Ändern Sie das Interrupt-Enable Bit ‘‘integer overflow’’ (0) 1, 1) 0) .
80 2 Assemblerprogrammierung
Verzweigungsbefehle
Unbedingte Verzweigung
Befehl Operanden Name/Aktion Definition
JMP XYZ Jump @ u
064( u(@) + 4 · s(XYZ) )
Bedingte Verzweigungen
Befehl Operanden Name/Aktion Definition
BZ $X,YZ Branch if zero s($X) = 0) @ u
064( u(@) + 4 · s(YZ) )
PBZ $X,YZ Probable br. if zero s($X) = 0) @ u
064( u(@) + 4 · s(YZ) )
BNZ $X,YZ Branch if nonzero s($X) 6= 0) @ u
064( u(@) + 4 · s(YZ) )
PBNZ $X,YZ Prob. br. if nonzero s($X) 6= 0) @ u
064( u(@) + 4 · s(YZ) )
BN $X,YZ Branch if negative s($X) < 0) @ u
064( u(@) + 4 · s(YZ) )
PBN $X,YZ Prob. br. if negative s($X) < 0) @ u
064( u(@) + 4 · s(YZ) )
BNN $X,YZ Branch if nonneg. s($X) � 0) @ u
064( u(@) + 4 · s(YZ) )
PBNN $X,YZ Prob. br. if nonneg. s($X) � 0) @ u
064( u(@) + 4 · s(YZ) )
BP $X,YZ Branch if positive s($X) > 0) @ u
064( u(@) + 4 · s(YZ) )
PBP $X,YZ Prob. br. if positive s($X) > 0) @ u
064( u(@) + 4 · s(YZ) )
BNP $X,YZ Branch if nonpositive s($X) 0) @ u
064( u(@) + 4 · s(YZ) )
PBNP $X,YZ Prob. br. if nonpos. s($X) 0) @ u
064( u(@) + 4 · s(YZ) )
BEV $X,YZ Branch if even s($X)%2 = 0) @ u
064( u(@)+4·s(YZ) )
PBEV $X,YZ Prob. branch if even s($X)%2 = 0) @ u
064( u(@)+4·s(YZ) )
BOD $X,YZ Branch if odd s($X)%2 = 1) @ u
064( u(@)+4·s(YZ) )
PBOD $X,YZ Prob. branch if odd s($X)%2 = 1) @ u
064( u(@)+4·s(YZ) )
2.3 MMIX Befehle 81
a) Benutzen Sie MMIX Verzweigungs-Befehle um folgenden C-Code zu implemen-
tieren:
C-Code: if(a == 0){
a = 1;}
MMIX-Code:
b) Benutzen Sie MMIX Verzweigungs-Befehle um folgenden C-Code zu implemen-
tieren:
C-code: int a;
...
if(a <= 0){
a = 1;}else{
a = 2;}
MMIX-Code:
82 2 Assemblerprogrammierung
c) Geben Sie den MMIX-Code an, der nachfolgenden C-Code implementiert:
C-Code: int a, b;
...
if(a > 0 && b < 0){
a = 1;}else if(a > 0 || b == 0){
a = 2;}else{
a = 3;}
MMIX-Code:
2.3 MMIX Befehle 83
Befehle für Funktionsaufrufe
Befehl Operanden Name/Aktion Definition
GO$X,$Y,$Z Go to location
$X u
064( u(@) + 4) );
@ u
064( u($Y)+u($Z) )
$X,$Y,Z Go to location immediate$X u
064( u(@) + 4) );
@ u
064( u($Y) + u(Z) )
a) Was ist der Haupt-Unterschied zwischen dem JMP-Befehl und dem GO-Befehl?
b) Wo speichern GO-Befehle die Rücksprungadresse ab?
c) Was ist die ‘‘Rücksprungadresse’’?
d) Wenn GO Absolute Adressierung verwendet: Wie wird die Abolute Adresse (64 Bit)
im 32 Bit breiten Befehlswort abgelegt?
e) Geben Sie den Befehl an, mit dem Sie die Funktion fkt aufrufen und die Rück-
sprungadresse in Register 0 ablegen.
84 2 Assemblerprogrammierung
Namensräume
a) Wozu dient der PREFIX-Befehl?
b) Welche Auswirkung hat der Befehl PREFIX mein_prefix auf darauf folgendeMMIX-
Anweisungen?
c) Wie kann man einen Namensraum beenden, d.h. wie kann man den Assembler
anweisen, Marken/Namen nicht mehr umzuwandeln?
d) Wie kann man – innerhalb eines Namensraums – verhindern, dass der Assembler
einer bestimmten Marke bzw. einem bestimmten Namen die im PREFIX-Befehlangegebene Zeichenkette voranstellt?
2.3 MMIX Befehle 85
Gegeben ist folgender Programmcode:
LOC Data_SegmentGREG @
label0 OCTA 1PREFIX x
label1 OCTA 2PREFIX y
label2 OCTA 3PREFIX :
a IS $0PREFIX z
b IS $1c IS $2
PREFIX :
PREFIX main:LOC #100
XXX XXX XXXXXX XXXXXX XXXPREFIX :
e) Ersetzen Sie XXX durch geeignete Marken/Befehle/Namen, die
• das Programm beginnen,
• das erste Octa ins Register 0 laden,
• das zweite Octa ins Register 1 laden und
• das dritte Octa ins Register 2 laden.
86 2 Assemblerprogrammierung
Stack
a) Was ist der Stack?
b) Wo beginnt der Stack und in welche Richtung wächst er?
c) Was ist der Stack-Pointer?
d) Wie werden Daten adressiert, die auf dem Stack liegen?
2.3 MMIX Befehle 87
e) Welche Operationen muss man ausführen um die Werte zweier Register (acht Byte
breite Datenworte) auf dem Stack abzulegen?
f) Wie wird der Stack bei Funktionsaufrufen verwendet?
88 2 Assemblerprogrammierung
g) Geben Sie den Befehl an mit dem Sie für den Stack-Pointer ein globales Register
reservieren und dieses mit 0x4000 00000000 0000 initialisieren.
h) Warum initialisieren wir den Stack-Pointer mit 0x4000 00000000 0000, d.h. mit
dem Beginn des Poolsegments, und nicht mit dem Ende des Datensegments?
i) Geben Sie die MMIX-Befehle an, mit denen Sie Register $1 und $2 auf den Stack
schreiben und dann die Funktion fkt aufrufen. Nehmen Sie an, dass Ihr Code im
Namensraum Main: steht und fkt im Namensraum Fkt: unter dem Namen :fktangelegt wurde. Sichern Sie die Rücksprungadresse in Register 0.
2.3 MMIX Befehle 89
Nehmen Sie an, dass Sie eine Funktion im Namensraum Fkt: implementieren.
j) Geben Sie die MMIX-Befehle an, mit denen Sie die Register 0, 1, 2 und 3 auf den
Stack sichern und anschließend zwei acht Byte breite Parameter vom Stack in die
Register 1 und 2 einlesen.
k) Zeichnen Sie, wie der Stack nach diesen Operationen aussieht.
90 2 Assemblerprogrammierung
l) Im Hauptprogramm wurden die Parameter in die Register 1 und 2 geschrieben.
Im Unterprogramm wurden Register 1 und 2 dann auf den Stack gesichert und
dann dieselben Werte wieder vom Stack in Register 1 und 2 geladen, obwohl
sich die Werte von Register 1 und 2 in der Zwischenzeit nicht geändert hatten.
Warum haben wir und diesen Schritt nicht gespart sondern dieselben Werte, die
in Registern 1 und 2 waren, nochmal reingeschrieben?
m) Warum speichert man die Rücksprungadresse auf dem Stack?
n) Was würde passieren, wenn der Stack so groß wird, dass er mit den Daten
zusammenstößt, die am Beginn des Datensegments liegen?
2.3 MMIX Befehle 91
o) Geben Sie die MMIX-Befehle an, mit denen Sie den Inhalt von Register 3 als
Ergebnis auf dem Stack ablegen, dann die Register 0, 1, 2 und 3 wiederherstellen
und anschließend zurück zum Funktionsaufrufer springen.
p) Nehmen Sie an, Sie sind wieder im Hauptprogramm. Geben Sie die Befehle an mit
denen Sie das Ergebnis der Funktion vom Stack in das Register 1 einlesen.
q) Warum muss der Stack-Pointer angepasst werden nachdem das Ergebnis vom
Stack geladen wurde?
92 2 Assemblerprogrammierung
2.4 MMIX Programme 93
2.4 MMIX Programme
MMIX Programm zur Berechnung der Determinante einer 2 ⇥ 2 Matrix
In dieser Aufgabe sollen Sie ein Programm schreiben zur Berechnung der Determinante
einer 2⇥ 2 Matrix mittels detA = det�� a c
b d
�� = a · d � b · c .
a) Geben Sie MMIX-Befehle an um für jede der Variablen a, b, c und d, beginnend bei
Adresse 0x2000 0000 00000000, acht Byte imSpeicher zu reservieren. Initialisieren
Sie a mit 4, b mit 3, c mit 2 und d mit 1 und machen Sie die Variablen über A, B, Cund D ansprechbar.
b) Reservieren Sie an Adresse 0x20000000 0000 0100 ein acht Byte breites Daten-
wort für das Ergebnis und machen Sie es über die Marke Erg ansprechbar.
94 2 Assemblerprogrammierung
c) Warum benötigen Sie für das Ergebnis einen separaten Befehl GREG @ ?
d) Was passiert, wenn einem durch viele Variable die globalen Register ausgehen?
e) Geben Sie die Befehle an mit denen Sie Register 1, 2, 3, 4, 5 und 6 über die
Marken a, b, c, d, buf1, und buf2 ansprechbar machen.
2.4 MMIX Programme 95
f) Geben Sie den MMIX-Code an, mit dem Sie an Adresse 0x100 ein Programm
beginnen und zum Programmstart die Speicherworte A, B, C, und D in die Register
a, b, c, und d einlesen.
g) Geben Sie die Befehle an, mit denen Sie a · d � b · c berechnen, das Ergebnis im
Arbeitsspeicher an die Marke Erg speichern und das Programm beenden.
96 2 Assemblerprogrammierung
Quadratische Gleichung
In dieser Übung schreiben Sie ein MMIX Programm zur Lösung der Quadratischen
Gleichung a · x2 + b · x + c = 0 mit der Formel x1,2 = �b±pb
2�4·a·c2·a zu lösen. Die Variable
a, b und c sind als Festkommazahlen gegeben; das Ergebnis soll als Gleitkommazahl
angegeben werden.
a) Geben Sie den MMIX Befehl an, mit dem Sie den Stack-Pointer anlegen und über
die Marke SP ansprechbar machen.
Zunächst soll das Hauptprogramm implementiert werden.
b) Geben Sie den MMIX-Befehl an, mit dem Sie den Namensraum Main: eröffnen.
c) Reservieren Sie an Adresse 0x2000 0000 0000 0000 die 64 Bit breiten SpeicherworteA, B, C, X1 und X2 und initialisieren Sie A mit 2, B mit 4 und C mit 8.
d) Geben Sie den Befehl an, mit dem Sie Register 1 durch buf ansprechbar machen.
2.4 MMIX Programme 97
e) Beginnen Sie das Hauptprogramm, legen Sie A, B und C auf dem Stack ab und
rufen Sie dann die global definierte Funktion QuadGleich auf. Speicher Sie dabei
die Rücksprungadresse in Register $0.
f) Geben Sie den MMIX Code an, mit dem Sie die Ergebnisse x1 und x2 der Funktion
vom Stack auslesen und im Arbeitsspeicher an den Marken X1 bzw. X2 ablegen.
g) Geben Sie die Anweisungen an, mit denen Sie das Programm und den Namens-
raum Main: beenden.
98 2 Assemblerprogrammierung
Im Folgenden soll die Funktion QuadGleich implementiert werden, von der folgender
Programm-Code bereits gegeben ist:
PREFIX QuadGleich:
a IS $1b IS $2c IS $3x1 IS $4x2 IS $5disk IS $6buf1 IS $7buf2 IS $8
Der Funktion QuadGleich werden die Parameter a, b und c wie folgt auf dem Stack
übergeben:SP! a
b
c
h) Geben Sie an der Marke :QuadGleich die Befehle an, mit denen Sie die verwende-
ten Register auf den Stack sichern und die Parameter a, b und c dann vom Stack
in die Register a, b und c einlesen.
:QuadGleich
2.4 MMIX Programme 99
i) Geben Sie den MMIX-Befehlscode an, der
• im Fall a = 0 das Ergebnis x = �c/b berechnet, dieses dann sowohl in
x1 und x2 speichert und dann an die Marke Speichern springt, und
• im Fall a 6= 0 an die Marke Anicht0 springt.
j) Geben Sie an Marke Anicht0 den MMIX Code an, mit dem Sie die Diskriminante
b
2� 4 · a · c mittels Festkomma-Arithmetik berechnen und das Ergebnis in Register
disk ablegen.
Anicht0
100 2 Assemblerprogrammierung
k) Geben Sie den MMIX Code an mit dem Sie
• im Fall disk < 0 an die Marke Dneg verzweigen,
• im Fall disk = 0 an die Marke D0 verzweigen und
• im Fall disk > 0 an die Marke Dpos verzweigen.
l) Geben Sie an Marke Dneg den MMIX Code an, mit dem Sie x1 und x2 auf NaN
setzen; verzweigen Sie dann an die Marke Speichern.
Dneg
m) Geben Sie an Marke D0 den MMIX Code an, mit dem Sie �b/2a berechnen und
das Ergebnis sowohl in x1 als auch in x2 ablegen. Verzweigen Sie danach an die
Marke Speichern.
D0
2.4 MMIX Programme 101
n) Geben Sie an Marke Dpos die MMIX Befehle an, mit denen Sie x1 und x2 gemäß
x1,2 = �b±pb
2�4·a·c2·a berechnen und das Ergebnis in x1 und x2 ablegen. Springen
Sie dann an die Marke Speichern. Beachten Sie, dass die Diskriminante bereits
berechnet wurde und als Festkommazahl in Register disk abgelegt ist.
Dpos
o) Geben Sie an Marke Speichern die MMIX Befehle an, mit denen Sie x1 und x2 auf
den Stack sichern, zum Funktionsaufrufer zurückspringen und den Namensraum
QuadGleich: beenden.
Speichern
102 2 Assemblerprogrammierung
3.1 Datenpfad 103
3 Mikroarchitektur
3.1 DatenpfadIn diesem Kapitel entwickeln wir einen Datenpfad, der MMIX-Befehle ausführen kann.
Die Befehlsausführung wird in 4 Phasen abgearbeitet:
• Phase 1: Befehl holen
• Phase 2: Befehl dekodieren und Operanden bereitstellen
• Phase 3: Befehl ausführen und ggf. Ergebnis in Register schreiben
• Phase 4: Speicherzugriff und ggf. ausgelesenes Datum in Register schreiben
Phase 1: Befehl holen
In Phase 1wird der auszuführende Befehl aus demBefehlsspeicher in das Befehlsregister
geladen. Der MMIX-Befehlsspeicher ist eine Black-Box, der am Eingang eine Adresse
übergeben wird. Als Folge liefert der Befehlsspeicher am Ausgang das Befehlswort, das
an dieser Adresse steht. Die Adressumsetzung von virtuellen auf reale Adressen findet
innerhalb des Befehlsspeichers statt und ist für uns nicht sichtbar.
a) Welche Ein- und Ausgänge benötigt der MMIX Befehlsspeicher?
b) Welche Wortbreiten haben der Eingangs- und Ausgangsbus des MMIX Be-
fehlsspeichers?
c) Entwerfen Sie ein geeignetes Symbol für den MMIX-Befehlsspeicher.
104 3 Mikroarchitektur
d) Wie wird die Adresse gespeichert, mit der der Befehlsspeicher adressiert wird?
e) Wie muss sich der Wert des Befehlszählers ändern, damit der auf den aktuellen
Befehl im Speicher folgende Befehl adressiert wird?
3.1 Datenpfad 105
f) Erweitern Sie die nachfolgend abgebildete Schaltung so, dass bei jedem Takt
des Befehlszählers der im Speicher auf den aktuellen Befehl unmittelbar folgende
Befehl adressiert wird.
Eigener Lösungsweg:
Befehls- Speicher
Adresse
Befehl32
64
BZ
Musterlösung:
Befehls- Speicher
Adresse
Befehl32
64
BZ
106 3 Mikroarchitektur
g) Erweitern Sie nachfolgende Abbildung um das Befehlsregister und verdrahten Sie
das Befehlsregister mit dem Befehlsspeicher.
Eigener Lösungsweg:
Befehls- Speicher
Adresse
Befehl32
64
Musterlösung:
Befehls- Speicher
Adresse
Befehl32
64
3.1 Datenpfad 107
Phase 2: Befehl dekodieren und Operanden bereitstellen
In Phase 2 wird der im Befehlsregister stehende Befehl analysiert/dekodiert und die
für die Befehlsausführung benötigten Operanden bereitgestellt. Die Operanden können
entweder im Registerblock abgelegt sein, oder direkt im Befehlsregister stehen.
a) Tragen Sie in nachfolgende Abbildung Benennung und Bedeutung der jeweiligen
Befehls-Bits des Befehlsregisters ein.
32
31...24
Bits 31...24:
23...16
Bits 23...16:
15...8
Bits 15...08:
7...0
Bits 7...0:
BR
108 3 Mikroarchitektur
Der Allzweck-Registerblock kapselt die 256 Allzweckregister des MMIX.
b) Welche Ein- und Ausgänge benötigt der Registerblock für die durch Y und Z
adressierten Register?
c) Welche Ein- und Ausgänge benötigt der Registerblock für die durch X adressierten
Register?
d) Skizzieren Sie ein für den Allzweck-Registerblock passendes Blockschaltbild
3.1 Datenpfad 109
e) Wie kann man aus dem Allzweck-Registerblock den Wert eines Registers ausle-
sen?
f) Wie kann man in den Allzweck-Registerblock schreiben?
110 3 Mikroarchitektur
g) Skizzieren Sie, wie sich der Allzweck-Registerblock aus 256 einzelnen Registern
zusammensetzen lässt.
3.1 Datenpfad 111
Unsere Implementierung des Allzweck-Registerblocks verwendet ausschließlich Register
und Multiplexer.
h) Skizzieren Sie in nachfolgender Abbildung, wie sich ein 64 Bit-Register aus 64
einzelnen taktflankengesteuerten 1 Bit D-Flipflops zusammensetzen lässt.
Eigener Lösungsweg:
64 64
112 3 Mikroarchitektur
Musterlösung:
64 64
3.1 Datenpfad 113
i) Tragen Sie in nachfolgende Abbildung ein, wie sich ein taktflankengesteuertes D-
Flipflop nach dem Master-Slave-Prinzip aus taktzustandsgesteuerten D-Flipflops
aufbauen lässt.
Eigener Lösungsweg:
D
C
Q C
D
C
D Q Q
Musterlösung:
D
C
Q C
D
C
D Q Q
114 3 Mikroarchitektur
j) Tragen Sie in nachfolgende Abbildung ein, wie sich ein taktzustandsgesteuertes
D-Flipflop aus einem RS-Flipflop aufbauen lässt.
Eigener Lösungsweg:
C
D
Q C
S Q
R
Musterlösung:
C
D
Q C
S Q
R
3.1 Datenpfad 115
k) Tragen Sie in nachfolgende Abbildung ein, wie sich ein RS-Flipflop aus einfachen
Logikgattern zusammensetzen lässt.
Eigener Lösungsweg:
C
S
Q
R
Musterlösung:
C
S
Q
R
116 3 Mikroarchitektur
l) Skizzieren Sie, wie sich ein vierfach 4 Bit Multiplexer aus vier vierfach 1 Bit
Multiplexern aufbauen lässt.
Eigener Lösungsweg:
01
2
3
01
2
3
01
2
3
01
2
3
2
2
2
2
2
3.1 Datenpfad 117
Musterlösung:
01
2
3
01
2
3
01
2
3
01
2
3
2
2
2
2
2
118 3 Mikroarchitektur
m) Skizzieren Sie, wie sich ein vierfach 1 Bit Multiplexern aus Logikgattern aufbauen
lässt.
Eigener Lösungsweg:
2
1
1
1
1
1
3.1 Datenpfad 119
Musterlösung:
2
1
1
1
1
1
120 3 Mikroarchitektur
n) Tragen Sie in nachfolgende Abbildung geeignete Verbindungen ein, damit X,
Y und Z (aus dem Befehlsregister) die entsprechenden Register des Allzweck-
Registerblocks adressieren und die ausgelesenen Registerinhalte ins Operanden-
Register OR geschrieben werden können.
Eigene Lösung:
Add
Befehls- Speicher
Adresse
Befehl32
64
BZ
64
64
4
BR
Schreiben
Schreib- Daten $X
Allzweck- Registerblock
64
8
8
8
64
64
64
X
Y
Z
$X
$Y
$Z
OR
o1
o2
o3
Musterlösung:
Add
Befehls- Speicher
Adresse
Befehl32
64
BZ
64
64
4
BR
Schreiben
Schreib- Daten $X
Allzweck- Registerblock
64
8
8
8
64
64
64
X
Y
Z
$X
$Y
$Z
OR
o1
o2
o3
3.1 Datenpfad 121
Bisher kann der Datenpfad nur Operanden $X, $Y und $Z bereitstellen.
o) Erweitern Sie nachfolgende Abbildung um die Möglichkeit, dass Operand o3 statt
$Z auch den Wert u
064(u(Z )) annehmen kann, so dass nicht nur Befehle mit
Operanden $X,$Y,$Z (z.B. ADD $1,$2,$3), sondern auch Befehle mit Operanden
$X,$Y,Z (z.B. ADD $1,$2,3) ausgeführt werden können.
Eigene Lösung:
BR
8 64Z $Z
7...032
o3
Musterlösung:
BR
8 64Z $Z
7...032
o3
p) Was ist beim NEG-Befehl anders als bei allen anderen Befehlen?
q) Wie berechnet sich beim JMP-Befehl die Sprungziel-Adresse?
r) Wie berechnet sich bei den Befehlen zur bedingten Verzweigung (BZ, BNZ, ...) die
Sprungziel-Adresse?
122 3 Mikroarchitektur
s) Erweitern Sie nachfolgende Schaltung um die Möglichkeit, dass o2 statt $Y auch
• den Wert u064(u(Y )) und
• den Wert @ annehmen kann und
Operand o3 statt $Y auch
• u
064(u(Z )),
• s
064(s(YZ )) und
• s
064(s(XYZ )) annehmen kann.
Eigene Lösung:
Add
Befehls- Speicher
Adresse
Befehl 32
64
BZ
64
64
4
BR
Schreiben
Schreib- Daten $X
Allzweck- Registerblock
64
8
8
8
64
64
64
X
Y
Z
$X
$Y
$Z
OR
o1
o2
o3
23...16
15...8
7...032
3.1 Datenpfad 123
Musterlösung:
Add
Befehls- Speicher
Adresse
Befehl 32
64
BZ
64
64
4
BR
Schreiben
Schreib- Daten $X
Allzweck- Registerblock
64
8
8
8
64
64
64
X
Y
Z
$X
$Y
$Z
OR
o1
o2
o3
23...16
15...8
7...032
124 3 Mikroarchitektur
Phase 3: Befehlsausführung
In Phase 3 werden die im Operandenregister bereitgestellten Operanden op2 und op3
vom Rechenwerk (ALU = Arithmetic Logic Unit) verknüpft. Das ALU-Ergebnis wird u.a.
im Speicher-Register SR zwischengespeichert.
a) Tragen Sie in nachfolgende Skizze die ALU ein und verbinden Sie die Ein- und
Ausgänge. Sorgen Sie auch dafür, dass o1 an der Stelle dat ins SR-Register
geschrieben wird.
Eigene Lösung:
Add
Befehls- Speicher
Adresse
Befehl32
64
BZ
64
64
4
BR
Schrei- ben
Schreib- Daten $X
Allzw.-Reg.
64 64
64
64
X
Y
Z
$X
$Y
$Z
OR
o1
o2
o3
23...16
15...8
7...032
560
15...8
63...8
7...0
64
560
7...0
63...8
7...0
6415...0
63...16
15...0
6415
...
48
0
4723..0
63...24
23...0
6423
...
40
0
39
10
23
10
23
SR
adr
dat
3.1 Datenpfad 125
Musterlösung:
Add
Befehls- Speicher
Adresse
Befehl32
64
BZ
64
64
4
BR
Schrei- ben
Schreib- Daten $X
Allzw.-Reg.
64 64
64
64
X
Y
Z
$X
$Y
$Z
OR
o1
o2
o3
23...16
15...8
7...032
560
15...8
63...8
7...0
64
560
7...0
63...8
7...0
6415...0
63...16
15...0
6415
...
48
0
4723..0
63...24
23...0
6423
...
40
0
39
10
23
10
23
SR
adr
dat
b) Wie wird beim MMIX mit dem Ergebnis der ALU verfahren?
126 3 Mikroarchitektur
c) Passen Sie nachstehende Abbildung so an, dass das Ergebnis der ALU an die
benötigten Stellen geschrieben werden kann.
Eigene Lösung:
Add
Befehls- Speicher
Adresse
Befehl32
64
BZ
64
4
BR
Schrei- ben
Schreib- Daten $X
Allzw.-Reg.
64 64
64
64
X
Y
Z
$X
$Y
$Z
OR
o1
o2
o3
23...16
15...8
7...0
560
15...8
63...8
7...0
64
560
7...0
63...8
7...0
6415...0
63...16
15...0
6415
...
48
0
4723..0
63...24
23...0
6423
...
40
0
39
10
23
10
ALU
23
SR
adr
dat
3.1 Datenpfad 127
Musterlösung:
Add
Befehls- Speicher
Adresse
Befehl32
64
BZ
64
4
BR
Schrei- ben
Schreib- Daten $X
Allzw.-Reg.
64 64
64
64
X
Y
Z
$X
$Y
$Z
OR
o1
o2
o3
23...16
15...8
7...0
560
15...8
63...8
7...0
64
560
7...0
63...8
7...0
6415...0
63...16
15...0
6415
...
48
0
4723..0
63...24
23...0
6423
...
40
0
39
10
23
10
ALU
23
SR
adr
dat
128 3 Mikroarchitektur
d) Zeichnen Sie in nachstehende Abbildung ein, wie beim GO-Befehl die Rücksprun-
gadresse ins Register $X geschrieben werden kann.
Eigene Lösung:
Add
Befehls- Speicher
Adresse
Befehl32
64
BZ
64
4
BR
Schrei- ben
Schreib- Daten $X
Allzw.-Reg.
64 64
64
64
X
Y
Z
$X
$Y
$Z
OR
o1
o2
o3
23...16
15...8
7...0
560
15...8
63...8
7...0
64
560
7...0
63...8
7...0
6415...0
63...16
15...0
6415
...
48
0
4723..0
63...24
23...0
6423
...
40
0
39
10
23
10
ALU
23
SR
adr
dat
0
1
3.1 Datenpfad 129
Musterlösung:
Add
Befehls- Speicher
Adresse
Befehl32
64
BZ
64
4
BR
Schrei- ben
Schreib- Daten $X
Allzw.-Reg.
64 64
64
64
X
Y
Z
$X
$Y
$Z
OR
o1
o2
o3
23...16
15...8
7...0
560
15...8
63...8
7...0
64
560
7...0
63...8
7...0
6415...0
63...16
15...0
6415
...
48
0
4723..0
63...24
23...0
6423
...
40
0
39
10
23
10
ALU
23
SR
adr
dat
0
1
130 3 Mikroarchitektur
Bei bedingten Sprungbefehlen (BZ, BNZ,...) findet ein Sprung nur dann, statt, wenn
u($X) bestimmte Eigenschaften erfüllt. Diese werden mit dem Verzweigungs-Detektor
abgeprüft.
e) Zeichen Sie in nachstehende Abbildung ein Blockschaltbild für den Verzweigungs-
Detektor ein.
Eigene Lösung:
Add
Befehls- Speicher
Adresse
Befehl32
64
BZ
64
4
BR
Schrei- ben
Schreib- Daten $X
Allzw.-Reg.
64 64
64
64
X
Y
Z
$X
$Y
$Z
OR
o1
o2
o3
23...16
15...8
7...0
560
15...8
63...8
7...0
64
560
7...0
63...8
7...0
6415...0
63...16
15...0
6415
...
48
0
4723..0
63...24
23...0
6423
...
40
0
39
10
23
10
ALU
23
SR
adr
dat
1 0
1
0
3.1 Datenpfad 131
Musterlösung:
Add
Befehls- Speicher
Adresse
Befehl32
64
BZ
64
4
BR
Schrei- ben
Schreib- Daten $X
Allzw.-Reg.
64 64
64
64
X
Y
Z
$X
$Y
$Z
OR
o1
o2
o3
23...16
15...8
7...0
560
15...8
63...8
7...0
64
560
7...0
63...8
7...0
6415...0
63...16
15...0
6415
...
48
0
4723..0
63...24
23...0
6423
...
40
0
39
10
23
10
ALU
23
SR
adr
dat
1 0
1
0
132 3 Mikroarchitektur
Der Verzweigungsdetektor bekommt als Eingangs-Werte den Opcode des Befehls und
den Inhalt von Register X. Als Ausgang liefert der Verzweigungs-Detektor ein einzelnes
Bit, das angibt, ob verzweigt werden soll (Bitwert = 1), oder nicht (Bitwert = 0).
! "#$%
!"#"$% &'()*+,-.%(*/%012'(*/%!&'(!)*+*,-(#.*-/!01234/*5!67*8434/*9!:;</!=*8>((!7'3,+4-=*7/*<!?'@*--*!A@*<(*BCBD!!
0x..0 0x..1 0x..2 0x..3 0x..4 0x..5 0x..6 0x..7
TRAP 5ν FCMP ν FUN ν FEQL ν FADD 4ν FIX 4ν FSUB 4ν FIXU 4ν
FMUL 4ν FCMPE 4ν FUNE ν FEQLE 4ν FDIV 40ν FSQRT 40ν FREM 4ν FINT 4ν
SETH ν SETMH ν SETML ν SETL ν INCH ν INCHM ν INCML ν INCL νORH ν ORMH ν ORML ν ORL ν ANDNH ν ANDNMH ν ANDNML ν ANDNL ν
POP 3ν RESUME 5ν SYNC ν SWYM ν GET ν TRIP 5ν0x..8 0x..9 0x..A 0x..B 0x..C 0x..D 0x..E 0x..F
SUB[I] ν
CSNP[I] νZSP[I] ν
SUBU[I] ν16ADDU[I] νNEGU[I] νSRU[I]ν
BOD[B] ν+πBEV[B] ν+πPBOD[B] 3ν-π
CMPU[I] νSLU[I] νBZ[B] ν+πBNZ[B] ν+πPBZ[B] 3ν-π
CSNZ[I] νZSZ[I] ν
ADD[I] ν
CSNN[I] νZSN[I] ν
ADDU[I] ν4ADDU[I] ν
PBNZ[B] 3ν-πCSZ[I] ν
0x0.. 0x0..FLOT[I] 4ν FLOTU[I] 4ν SFLOT[I] 4ν SFLOTU[I] 4ν
PUSHJ[B] ν GETA[B] ν PUT[I] ν[UN]SAVE 20µ+ν
XOR[I] νNXOR[I] νODIF[I] νMXOR[I] ν
STWU[I] µ+νSTOU[I] µ+νSTUNC[I] µ+νPUSHGO[I] 3ν
LDWU[I] µ+νLDOU[I] µ+νLDUNC[I] µ+νGO[I] 3ν
CSOD[I] νPBEV[B] 3ν-π
ZSEV[I] ν
CSEV[I] νZSOD[I] ν
NAND[I] νTDIF[I] νMOR[I] ν
STO[I] µ+νSTCO[I] µ+νSYNCID[I] νNOR[I] ν
LDO[I] µ+νCSWAP[I] 2µ+2νPREGO[I] νSTW[I] µ+ν
PBNP[B] 3ν-πCSP[I] ν
ZSNP[I] νLDW[I] µ+ν
BNP[B] ν+πPBP[B] 3ν-π
8ADDU[I] νNEG[I] νSR[I] νBP[B] ν+π
ORN[I] νANDN[I] νWDIF[I] νSADD[I] ν
STBU[I] µ+νSTTU[I] µ+νSTHT[I] µ+νPREST[I] ν
LDBU[I] µ+νLDTU[I] µ+νLDHT[I] µ+νPRELD[I] ν
ZSNZ[I] ν
BDIF[I] νMUX[I] ν
JMP[B] ν
STSF[I] µ+νSYNCD[I] νOR[I] νAND[I] ν
LDSF[I] µ+νLDVTS[I] νSTB[I] µ+νSTT[I] µ+ν
BNN[B] ν+πPBN[B] 3ν-πPBNN[B] 3ν-πCSN[I] ν
ZSNN[I] νLDB[I] µ+νLDT[I] µ+ν
2ADDU[I] νCMP[I] νSL[I] νBN[B] ν+π
0xC..
0xD..
0xE..
0xF..
0x8..
0x9..
0xA..
0xB..
0xD..
0xE..
0xF..
0x1..
0x2..
0x3..
0x4..
0x5..
0x6..
0x7..
0x9..
0xA..
0xB..
0xC..
0x5..
0x6..
0x7..
0x8..
0x1..
0x2..
0x3..
0x4..
MUL[I] 10ν MULU[I] 10ν DIV[I] 60ν DIVU[I] 60ν
!!!&'(!*<(B*!E;@@-*!0F!);B#G*<B9!/*(!1234/*(!*7B(2<;3,B!/*<!&422*-C*;-*!0H!@;(!IJ95! ;7!/*<!(;3,!/*<!)*#+*,-(34/*!@*+;7/*BD!!!&'(!C:*;B*!E;@@-*!/*(!1234/*(!*<=;@B!(;3,!:;*!+4-=BK!!
−! 6L)!0);B!E<D!"9!/*(!C:*;B*7!E;@@-*(!+! H5!:*77!(;3,!/*<!)*+*,-!;8!4@*<*7!?*;-!/*<!&422*-!"#$"!@*+;7/*B!+! I5!:*77!(;3,!/*<!)*+*,-!;8!M7B*<*7!?*;-!/*<!&422*-!"#$"!@*+;7/*B!!
!−! );B(!$5!I!M7/!H!/*(!C:*;B*7!E;@@-*(!*7B(2<*3,*7!/*<!%&'$("!0H!@;(!%95!;7!/*8!(;3,!/*<!)*+*,-(#34/*!@*+;7/*B!
![I]!@*/*MB*BK!N88*/;'B*#O'<;'7B*!/*(!)*+*,-(!
−! ;88*/;'B*!⇔!&;<*PB42*<'7/!−! ADD $1,$2,$3K!7;3,B!;88*/;'B*5!/'!/*<!"D!12*<'7/!*;7!Q*=;(B*<!;(B!M7/!P*;7*!R',-!−! ADD $1,$2,3K!;88*/;'B*5!/'!'-(!"D!12*<'7/!*;7*!R',-!'7=*=*@*7!;(B!M7/!P*;7!Q*=;(B*<!−! /*<! 1234/*! /*<! ;88*/;'B*#O'<;'7B*! *;7*(! )*+*,-(! ;(B! ;88*<! M8! I! ,S,*<! '-(! /;*! 7;3,B#;88*/;'B*#O'<;'7B*!/*(!)*+*,-(!0(B*,B!;7!/*<!&422*-)&'$("!'-(4!<*3,B(9!
−! *;7*! ;88*/;'B*#O'<;'7B*!/*(!)*+*,-(!:;</!T48!U((*8@-*<!'MB48'B;(3,!'7,'7/!/*(! +*,-*7/*7!&4--'<#R*;3,*7(! 0$9! *<P'77B5! :*(,'-@! ;8! V<4=<'88! 7;3,B! *W2-;C;B!ADDI! =*(3,<;*@*7! :*</*7!8M((!!!
f) Wie können Sie im Datenpfad detektieren, ob einer der gezeigten Verzweigungs-
befehle ins Befehlsregister geladen wurde?
g) Wie können Sie im Datenpfad detektieren, welcher der gezeigten Verzweigungs-
befehle im Befehlsregister steht?
h) Bei welchen Werten von s($X) wird beim BP-Befehl verzweigt?
i) Wie können Sie anhand der Bits $X detektieren, ob im Falle eines BP-Befehls
gesprungen werden muss?
j) Tragen Sie in nachfolgende Abbildung eine Implementierung des Verzweigungs-
Detektors ein.
3.1 Datenpfad 133
1, falls Sprung 0, falls kein Sprung
1
8
Opcode
64
134 3 Mikroarchitektur
Phase 4: Speicherzugriff
Wie bereits beim MMIX-Befehlsspeicher betrachten wir den MMIX-Datenspeicher als
Black-Box, welche die Umsetzung von virtuellen auf reale Adressen für uns nicht sichtbar
in ihrem Inneren umsetzt.
a) Welche MMIX-Lade- und Speicherbefehle kennen Sie?
b) Wie breit sind die Adressen des virtuellen MMIX-Datenspeichers?
c) Welche Daten-Wortbreiten muss der MMIX-Datenspeicher unterstützen?
d) Welchen Zugriffsmodus muss der Speicher neben den Wortgrößen noch unter-
stützen?
3.1 Datenpfad 135
e) Über welche Ein- und Ausgänge muss der MMIX-Datenspeicher verfügen?
f) Welche Funktion muss der MMIX-Datenspeicher aufweisen?
136 3 Mikroarchitektur
g) Entwerfen Sie ein geeignetes Symbol für den MMIX-Datenspeicher
h) Integrieren Sie den Datenspeicher in den Datenpfad.
Eigener Lösungsweg:
Add
Befehls- Speicher
Adresse
Befehl32
BZ
64
4
BR
Schrei- ben
Schreib- Daten $X
Allzw.-Reg.
64 64
64
64
X
Y
Z
$X
$Y
$Z
OR
o1
o2
o3
23...16
15...8
7...0
560
15...8
63...8
7...0
31...24
64
Verzwei- gungs- Detektor
560
7...0
63...8
7...0
6415...0
63...16
15...0 64
15
...
48
0
4723..0
63...24
23...0
6423
...
40
0
39
10
23
10
ALU
23
SR
adr
dat
1
0
64
3.1 Datenpfad 137
Musterlösung:
Add
Befehls- Speicher
Adresse
Befehl32
BZ
64
4
BR
Schrei- ben
Schreib- Daten $X
Allzw.-Reg.
64 64
64
64
X
Y
Z
$X
$Y
$Z
OR
o1
o2
o3
23...16
15...8
7...0
560
15...8
63...8
7...0
31...24
64
Verzwei- gungs- Detektor
560
7...0
63...8
7...0
6415...0
63...16
15...0 64
15
...
48
0
4723..0
63...24
23...0
6423
...
40
0
39
10
23
10
ALU
23
SR
adr
dat
1
0
64
138 3 Mikroarchitektur
Kontrolle aller Phasen: Das Steuerwerk
a) Tragen Sie in den folgenden Datenpfad ein Blockschaltbild der Steuerung ein und
verdrahten Sie diese.
Add
Befehls- Speicher
Adresse
Befehl32
BZ
64
4
BR
Schrei- ben
Schreib- Daten $X
Allzw.-Reg.
64 64
64
64
X
Y
Z
$X
$Y
$Z
OR
o1
o2
o3
23...16
15...8
7...0
560
15...8
63...8
7...0
31...24
64
Verzwei- gungs- Detektor
560
7...0
63...8
7...0
6415...0
63...16
15...0 64
15
...
48
0
4723..0
63...24
23...0
6423
...
40
0
39
10
23
10
ALU
23
0 1
SR
Daten- Eingang
Adresseadr
Daten- Ausgang
Daten- Speicher
Mo- dus
dat
Takt
1
40
2
64
64
3.2 Aufbau des Rechenwerks (ALU) 139
3.2 Aufbau des Rechenwerks (ALU)
Überblick
a) Skizzieren Sie den Aufbau eines Rechenwerks, das die MMIX-Befehle ADD, SUB,
MUL, DIV, SR, SRU, SL, SLU, AND und OR unterstützt.
140 3 Mikroarchitektur
UND- und ODER-Einheit
a) Skizzieren Sie, wie sich die 64 Bit UND-Einheit aus 64 einzelnen 1 Bit UND-
Einheiten zusammensetzen lässt.
b) Skizzieren Sie, wie sich die 64 Bit ODER-Einheit aus 64 einzelnen 1 Bit ODER-
Einheiten zusammensetzen lässt.
3.2 Aufbau des Rechenwerks (ALU) 141
Schiebe-Einheit
a) Was ist der Unterschied zwischen vorzeichenbehaftetem Rechts-Schieben und
vorzeichenlosem Rechts-Schieben?
b) Was ist der Unterschied zwischen vorzeichenbehaftetem Links-Schieben und
vorzeichenlosem Links-Schieben?
142 3 Mikroarchitektur
c) Skizzieren Sie die Aufbau eines Schiebers mit Wortbreite 8 Bit. Stellen Sie für den
Fall ‘‘Schieben um 3 Stellen’’ dar, wie man den Schiebemechanismus implemen-
tieren kann.
3.2 Aufbau des Rechenwerks (ALU) 143
Addierer und Subtrahierer
Addition zweier einzelner Bits: 1 Bit Halbaddierer
Ein Halbaddierer ist eine Schaltung, die zwei Eingangs-Bits zu einem Ergebnis-Bit und
einem Überlauf-Bit addiert.
a) Entwerfen Sie eine Wertetabelle, welche die Addition zweier Bits mit einem Halb-
addierer beschreibt.
b) Welcher logischer Funktion entspricht die Berechnung des Ergenbnis-Bits?
c) Welcher logischer Funktion entspricht die Berechnung des Überlauf-Bits?
d) Entwerfen Sie eine Implementierung des Halbaddierers.
Eigene Lösung:Bit 1 Bit 2
Überlauf Ergebnis
144 3 Mikroarchitektur
Musterlösung:
Bit 1 Bit 2
Überlauf Ergebnis
e) Führen Sie die binäre Addition 0110 1101 + 0011 0110 durch.
f) Kann die durchgeführte Addition vom entworfenen Halbaddierer gelöst werden?
g) Wie müsste ein Addierer aussehen, damit die oben durchgeführte Addition be-
rechnet werden kann?
3.2 Aufbau des Rechenwerks (ALU) 145
Addition von drei einzelnen Bits: 1 Bit Volladdierer
a) Entwerfen Sie eine Wertetabelle, welche die Addition dreier Eingangsbits (Bit 1, Bit
2 und Überlauf-Eingang) zu einem Ergebnis- und Überlauf-Bit (Ausgang) addiert.
Eigene Lösung:
Musterlösung:
146 3 Mikroarchitektur
b) Schauen Sie sich die aufgestellte Wertetabelle gut an und überlegen Sie, wie man
das Ergebnis-Bit berechnen könnte. Schreiben Sie es auf!
3.2 Aufbau des Rechenwerks (ALU) 147
c) Tragen Sie Ihre Lösung in nachstehende Volladdierer-Schaltung ein.
Eigene Lösung:
Bit 1 Bit 2
Überlauf (Ausg.) Ergebnis
Überlauf (Eing.)
Musterlösung:
Bit 1 Bit 2
Überlauf (Ausg.) Ergebnis
Überlauf (Eing.)
148 3 Mikroarchitektur
d) Schauen Sie sich die zuvor aufgestellte Wertetabelle an und überlegen Sie, wie
man aus den drei Eingangs-Bits das Überlauf-Bit (Ausgang) berechnen könnte.
Schreiben Sie es auf!
3.2 Aufbau des Rechenwerks (ALU) 149
e) Tragen Sie Ihre Lösung in nachstehende Volladdierer-Schaltung ein.
Eigene Lösung:
Bit 1 Bit 2
Überlauf (Ausg.) Ergebnis
Überlauf (Eing.)
Musterlösung:
Bit 1 Bit 2
Überlauf (Ausg.) Ergebnis
Überlauf (Eing.)
150 3 Mikroarchitektur
Addition von Binärzahlen: Zusammenschalten von Volladdierern
a) Skizzieren Sie, wie sie mit 64 Volladdierern zwei 64 Bit breite Zahlen addieren
können. (Hinweis: Man nennt einen Addierer, bei dem der Übertrag von hinten
nach vorne durchläuft einen Ripple-Carry-Addierer.)
Eigene Lösung:
Bit 1 Bit 2 Über- lauf
Überl. Erg.
VA 0
Bit 1 Bit 2 Über- lauf
Überl. Erg.
VA 1
Bit 1 Bit 2 Über- lauf
Überl. Erg.
VA 2
Bit 1 Bit 2 Über- lauf
Überl. Erg.
VA 63 ...
Musterlösung:
Bit 1 Bit 2 Über- lauf
Überl. Erg.
VA 0
Bit 1 Bit 2 Über- lauf
Überl. Erg.
VA 1
Bit 1 Bit 2 Über- lauf
Überl. Erg.
VA 2
Bit 1 Bit 2 Über- lauf
Überl. Erg.
VA 63 ...
3.2 Aufbau des Rechenwerks (ALU) 151
Subtraktion von Binärzahlen: Addition des negativen zweiten Operanden
a) Wie müsste man die Volladdierer verwenden, um damit auch subtrahieren zu
können?
b) Skizzieren Sie, wie sie den Ripple-Carry-Addierer aus der letzten Aufgabe so
umbauen, dass Sie damit auch Zahl 1 - Zahl 2 berechnen können, d.h. subtrahieren
können.
Eigene Lösung:
X XXX
Bit 1 Bit 2 Über- lauf
Überl. Erg.
VA 0
X XXX
Bit 1 Bit 2 Über- lauf
Überl. Erg.
Zahl 1:
VA 1
Zahl 2:
Bit 1 Bit 2 Über- lauf
X
Überl.
X
Erg.
XX
VA 2
Bit 1
Ergebnis:
Bit 2 Über- lauf
Überl. Erg.
Überlauf Vor- zeichenlose Zah- len (beim MMIX nicht verwendet)
VA 63 ...
152 3 Mikroarchitektur
Musterlösung:
X XXX
Bit 1 Bit 2 Über- lauf
Überl. Erg.
VA 0
X XXX
Bit 1 Bit 2 Über- lauf
Überl. Erg.
Zahl 1:
VA 1
Zahl 2:
Bit 1 Bit 2 Über- lauf
X
Überl.
X
Erg.
XX
VA 2
Bit 1
Ergebnis:
Bit 2 Über- lauf
Überl. Erg.
Überlauf Vor- zeichenlose Zah- len (beim MMIX nicht verwendet)
VA 63 ...
3.2 Aufbau des Rechenwerks (ALU) 153
Multiplikation
Multiplikation 11 · 13 = 143 im Binärsystem, Wortbreite = 4
PR0 = 1
PR8..4 ⟵ u'5( u(PR7..4) + u(MR3..0) )
PR ⟵ (PR >>u 1)
MR3..0 ⟵ u'4(Multiplikand) PR8..4 ⟵ u'5(0) PR3..0 ⟵ u'4(Multiplikator)
ja nein
Start
viermal gemacht?
Ende
Initialisierung:
ja
nein
154 3 Mikroarchitektur
a) Geben Sie den Inhalt des Multiplikand-Registers MR und den Inhalt des Produkt-
Registers PR für den Zeitpunkt nach der Initialisierung an.
Eigene Lösung:
ADD
MR
PR
8 7 6 5 4 3 2 1 0
3 2 1 0
Musterlösung:
ADD
MR
PR
8 7 6 5 4 3 2 1 0
3 2 1 0
3.2 Aufbau des Rechenwerks (ALU) 155
b) Tragen Sie in nachfolgende Abbildung die nach der ersten Runde in den Registern
MR und PR gespeicherten Daten ein.
Eigene Lösung:
ADD
MR
PR
8 7 6 5 4 3 2 1 0
3 2 1 0
ADD
MR
PR
8 7 6 5 4 3 2 1 0
3 2 1 0
Nach Addition: Nach Schieben:
Musterlösung:
ADD
MR
PR
8 7 6 5 4 3 2 1 0
3 2 1 0
ADD
MR
PR
8 7 6 5 4 3 2 1 0
3 2 1 0
Nach Addition: Nach Schieben:
156 3 Mikroarchitektur
c) Tragen Sie in nachfolgende Abbildung die nach der zweiten Runde in den Registern
MR und PR gespeicherten Daten ein.
Eigene Lösung:
ADD
MR
PR
8 7 6 5 4 3 2 1 0
3 2 1 0
ADD
MR
PR
8 7 6 5 4 3 2 1 0
3 2 1 0
Nach Addition: Nach Schieben:
Musterlösung:
ADD
MR
PR
8 7 6 5 4 3 2 1 0
3 2 1 0
ADD
MR
PR
8 7 6 5 4 3 2 1 0
3 2 1 0
Nach Addition: Nach Schieben:
3.2 Aufbau des Rechenwerks (ALU) 157
d) Tragen Sie in nachfolgende Abbildung die nach der dritten Runde in den Registern
MR und PR gespeicherten Daten ein.
Eigene Lösung:
ADD
MR
PR
8 7 6 5 4 3 2 1 0
3 2 1 0
ADD
MR
PR
8 7 6 5 4 3 2 1 0
3 2 1 0
Nach Addition: Nach Schieben:
Musterlösung:
ADD
MR
PR
8 7 6 5 4 3 2 1 0
3 2 1 0
ADD
MR
PR
8 7 6 5 4 3 2 1 0
3 2 1 0
Nach Addition: Nach Schieben:
158 3 Mikroarchitektur
e) Tragen Sie in nachfolgende Abbildung die nach der vierten Runde in den Registern
MR und PR gespeicherten Daten ein.
Eigene Lösung:
ADD
MR
PR
8 7 6 5 4 3 2 1 0
3 2 1 0
ADD
MR
PR
8 7 6 5 4 3 2 1 0
3 2 1 0
Nach Addition: Nach Schieben:
Musterlösung:
ADD
MR
PR
8 7 6 5 4 3 2 1 0
3 2 1 0
ADD
MR
PR
8 7 6 5 4 3 2 1 0
3 2 1 0
Nach Addition: Nach Schieben:
3.2 Aufbau des Rechenwerks (ALU) 159
f) Wie lautet das Ergebnis der Multiplikation?
Multiplikation 13 · 5 = 65 im Binärsystem, Wortbreite = 4
PR0 = 1
PR8..4 ⟵ u'5( u(PR7..4) + u(MR3..0) )
PR ⟵ (PR >>u 1)
MR3..0 ⟵ u'4(Multiplikand) PR8..4 ⟵ u'5(0) PR3..0 ⟵ u'4(Multiplikator)
ja nein
Start
viermal gemacht?
Ende
Initialisierung:
ja
nein
160 3 Mikroarchitektur
a) Tragen Sie in nachfolgende Abbildung den Inhalt der Register MR und PR bei der
Multiplikation 13 · 5 = 65 ein.
Eigene Lösung:
ADD
MR:
PR:
Initialisierung
Erste Runde
Zweite Runde
Dritte Runde
Vierte Runde
Nach Addition:
Nach Schieben:
Nach Addition:
Nach Schieben:
Nach Addition:
Nach Schieben:
Nach Addition:
Nach Schieben:
3.2 Aufbau des Rechenwerks (ALU) 161
Musterlösung:
ADD
MR:
PR:
Initialisierung
Erste Runde
Zweite Runde
Dritte Runde
Vierte Runde
Nach Addition:
Nach Schieben:
Nach Addition:
Nach Schieben:
Nach Addition:
Nach Schieben:
Nach Addition:
Nach Schieben:
162 3 Mikroarchitektur
Multiplikations-Hardware
Nachfolgende Abbildung zeigt noch einmal den Multiplikationsalgorithmus und das
verwendete Prinzip-Schaltbild.
PR0 = 1
PR8..4 ⟵ u'5( u(PR7..4) + u(MR3..0) )
PR ⟵ (PR >>u 1)
MR3..0 ⟵ u'4(Multiplikand) PR8..4 ⟵ u'5(0) PR3..0 ⟵ u'4(Multiplikator)
ja nein
Start
viermal gemacht?
Ende
Initialisierung:
ja
nein
ADD
MR
PR
8 7 6 5 4 3 2 1 0
3 2 1 0
3.2 Aufbau des Rechenwerks (ALU) 163
a) Vervollständigen Sie nachfolgende Schaltung so, dass sie den gezeigten Multipli-
kationsalgorithmus implementiert.
Eigene Lösung:
MR
n
n
PR
Addierer
2n
Steuerung
n..2n-1
0..n-10..n-1
n..2n
Init/>>1
Multiplikand
Multiplikator
Produkt
164 3 Mikroarchitektur
Musterlösung:
MR
n
n
PR
Addierer
2n
Steuerung
n..2n-1
0..n-10..n-1
n..2n
Init/>>1
Multiplikand
Multiplikator
Produkt
3.2 Aufbau des Rechenwerks (ALU) 165
Zustandsdiagramm der Steuerung
Gegeben ist der nachfolgende Multiplizierer sowie das zugehörige Ablauf-Diagramm für
den Fall Wortbreite n = 4.
PR0 = 1
PR8..4 ⟵ u'5( u(PR7..4) + u(MR3..0) )
PR ⟵ (PR >>u 1)
MR3..0 ⟵ u'4(Multiplikand) PR8..4 ⟵ u'5(0) PR3..0 ⟵ u'4(Multiplikator)
ja nein
Start
viermal gemacht?
Ende
Initialisierung:
ja
nein
n+1 n+1
0 1
0
MR
0
1
n
n
PR
Addierer
0
2n
1Steuerung
nn
n..2n-1
n
n 0..n-10..n-1
n..2n
Init/>>1
Multiplikand
2n
Multiplikator
Produkt
n
nn
clk
_mkand
multip
lexer
init/>
>1
clk
_pro
dukt
PR0
166 3 Mikroarchitektur
a) Vervollständigen Sie nachfolgend abgebildeten Zustands-Automaten so, dass er
den Multiplizierer wie gewünscht steuert. Nehmen Sie an, dass Sie zur Detektion
des Schleifen-Abbruchs (im Ablauf-Diagramm ‘‘viermal gemacht?’’) das Signal
Runde_n zur Verfügung haben, das Ihnen anzeigt, ob Sie bereits alle Runden
durchlaufen haben (Runde_n = 1) oder noch nicht (Runde_n = 0).
Eigene Lösung:
multiplexer=
clk_produkt=
clk_mkand=
init/>>1=
1Initialisierung
multiplexer=
clk_produkt=
clk_mkand=
init/>>1=
2Initialisierung
multiplexer=
clk_produkt=
clk_mkand=
init/>>1=
3Addieren
multiplexer=
clk_produkt=
clk_mkand=
init/>>1=
4Addieren
multiplexer=
clk_produkt=
clk_mkand=
init/>>1=
5Schieben
multiplexer=
clk_produkt=
clk_mkand=
init/>>1=
6Schieben
multiplexer=
clk_produkt=
clk_mkand=
init/>>1=
7Ende
3.2 Aufbau des Rechenwerks (ALU) 167
Musterlösung:
multiplexer=
clk_produkt=
clk_mkand=
init/>>1=
1Initialisierung
multiplexer=
clk_produkt=
clk_mkand=
init/>>1=
2Initialisierung
multiplexer=
clk_produkt=
clk_mkand=
init/>>1=
3Addieren
multiplexer=
clk_produkt=
clk_mkand=
init/>>1=
4Addieren
multiplexer=
clk_produkt=
clk_mkand=
init/>>1=
5Schieben
multiplexer=
clk_produkt=
clk_mkand=
init/>>1=
6Schieben
multiplexer=
clk_produkt=
clk_mkand=
init/>>1=
7Ende
168 3 Mikroarchitektur
Multiplexer-basierte Implementierung der Steuerung
Für den Fall n = 4 soll die Steuerung wie folgt implementiert werden:
D4
D3
D2
D0
Q4
Q3
Q2
Q0
clk
...
...
clk_mkand
clk_produkt
multiplexer
init/>>1
PR0
3
2
2
3
Kombinatorische Schaltung
Das Zustandsregister speichert die Information über
• den aktuellen Zustand (d.h. in welchem Zustand des Zustandsdiagramms sich
die Steuerung gerade befindet) und
• den Rundenzähler (d.h. welche Iterations-Runde (vgl. Ablauf-Diagramm) gerade
ausgeführt wird).
a) In welchen Bits des Zustandsregisters wird
• der aktuelle Zustand und
• die aktuelle Runde
gespeichert?
3.2 Aufbau des Rechenwerks (ALU) 169
b) Tragen Sie in nachfolgende Abbildung die Eingangswerte des Multiplexers ein, die
die Ausgangs-Funktion der Steuerung implementieren. Womit muss der Steuerein-
gang des Multiplexers verbunden werden?
Eigene Lösung:
4
4
4
4
4
4
4
4
0
1
2
3
4
5
6
7
4
clk_mkand
clk_produkt
multiplexer
init/>>1
3
0
1
2
3
170 3 Mikroarchitektur
Musterlösung:
4
4
4
4
4
4
4
4
0
1
2
3
4
5
6
7
4
clk_mkand
clk_produkt
multiplexer
init/>>1
3
0
1
2
3
3.2 Aufbau des Rechenwerks (ALU) 171
c) Tragen Sie in nachfolgende Abbildung diejenigen Eingangswerte ein, welche die
Zustands-Übergangs-Funktion aller unbedinger Verzweigungen implementieren.
Eigene Lösung:
3
3
3
3
3
3
3
3
0
1
2
3
4
5
6
7
3
3
0
1
2
Aktueller Zustand
172 3 Mikroarchitektur
Musterlösung:
3
3
3
3
3
3
3
3
0
1
2
3
4
5
6
7
3
3
0
1
2
Aktueller Zustand
d) Tragen Sie in nachfolgende Abbildung ein Schaltung ein, die den Folgezustand
des Zustands 2 liefert.
Eigene Lösung:
PR0Folgezustand von Zustand 23
3.2 Aufbau des Rechenwerks (ALU) 173
Musterlösung:
PR0Folgezustand von Zustand 23
e) Tragen Sie in nachfolgende Abbildung eine Schaltung ein, die im Zustand 5 den
Eingang Runde um 1 erhöht und den neuen Rundenwert am Ausgang bereitstellt
(00 ! 01, 01 ! 10, 10 ! 11, 11 ! 00). In Zuständen 6= 5 soll die am Eingang
angelegte Runde an den Ausgang durchgereicht werden.
Eigene Lösung:
Zustand (Bit 2 ... 0)
Runde (Bit 4, 3)
3
2
Neue Runde (Bit 4, 3)2
174 3 Mikroarchitektur
Musterlösung:
Zustand (Bit 2 ... 0)
Runde (Bit 4, 3)
3
2
Neue Runde (Bit 4, 3)2
f) Tragen Sie in nachfolgende Abbildung eine Implementierung des Runde_n-
Detektors ein, der in Runde 1, 2 und 3 den Ausgang auf Low-Pegel legt und
in Runde 4 auf High-Pegel (Runde 1, 01, Runde 2, 10, Runde 3, 11, Runde
4, 00).
Eigene Lösung:
Runde (Bit 4,3)
Runde_n12
Musterlösung:
Runde (Bit 4,3)
Runde_n12
3.2 Aufbau des Rechenwerks (ALU) 175
g) Tragen Sie in nachfolgende Abbildung eine Multiplexer-basierte Schaltung ein, die
in Abhängigkeit der Eingänge Runde_n und PR0 den auf Zustand 6 folgenden
Zustand am Ausgang ausgibt.
Eigene Lösung:
Runde_n
Folgezustand von Zustand 6
3
1
1PR0
Musterlösung:
Runde_n
Folgezustand von Zustand 6
3
1
1PR0
176 3 Mikroarchitektur
h) Tragen Sie in nachfolgende Abbildung eine Schaltung ein, die den auf Zustand
6 folgenden Zustand mit Hilfe eines Inverters und zweier ODER-Gatter bestimmt
und am Ausgang ausgibt.
Eigene Lösung:
1
1
3
1
1
Runde_n
PR0
Folgezustand von Zustand 6
Musterlösung:
1
1
3
1
1
Runde_n
PR0
Folgezustand von Zustand 6
3.2 Aufbau des Rechenwerks (ALU) 177
ROM-basierte Implementierung der Steuerung
In diesem Abschnitt soll die Multiplizierer-Steuerung mit nachfolgend abgebildeter ROM-
basierten Schaltung implementiert werden.
D4
D3
D2
D0
Q4
Q3
Q2
Q0
clk
clk_mkandclk_produktmultiplexerinit/>>1
PR0
D1
Q1
ROM012345678
012345
multiplexer=
clk_produkt=
clk_mkand=
init/>>1=
1Initialisierung
multiplexer=
clk_produkt=
clk_mkand=
init/>>1=
2Initialisierung
multiplexer=
clk_produkt=
clk_mkand=
init/>>1=
3Addieren
multiplexer=
clk_produkt=
clk_mkand=
init/>>1=
4Addieren
multiplexer=
clk_produkt=
clk_mkand=
init/>>1=
5Schieben
multiplexer=
clk_produkt=
clk_mkand=
init/>>1=
6Schieben
multiplexer=
clk_produkt=
clk_mkand=
init/>>1=
7Ende
0
0
0
0
1
1
0
0
0
0
1
0
0
1
X
1
0
0
X
1
0
1
1
0
0
0
X
X
immer PR0 = 1
PR0 = 0 immer
immerimmer
Runde_n = 0 && PR0 = 0
Runde_n = 1
Runde_n = 0 && PR0 = 1
immer
178 3 Mikroarchitektur
a) Welche Organisation hat das ROM?
b) Geben Sie den ROM-Inhalt an, der zur Implementierung der Zustände 1 und
2 benötigt wird. Nehmen Sie dazu an, dass das Zustandsregister zu Beginn
zurückgesetzt wurde und die Ausgänge Q0, Q1, ... Q4 auf Low-Pegel liegen.
Eigene Lösung:
Musterlösung:
3.2 Aufbau des Rechenwerks (ALU) 179
c) Geben Sie den Inhalt des ROM-Speichers für Zustand 3 an.
Eigene Lösung:
Musterlösung:
180 3 Mikroarchitektur
d) Geben Sie den Inhalt des ROM-Speichers für Zustand 4 an.
Eigene Lösung:
Musterlösung:
3.2 Aufbau des Rechenwerks (ALU) 181
e) Geben Sie den Inhalt des ROM-Speichers für Zustand 5 an.
Eigene Lösung:
Musterlösung:
182 3 Mikroarchitektur
f) Geben Sie den Inhalt des ROM-Speichers für Zustand 6 an.
Eigene Lösung:
Musterlösung:
3.2 Aufbau des Rechenwerks (ALU) 183
g) Geben Sie den Inhalt des ROM-Speichers für Zustand 7 an.
Eigene Lösung:
Musterlösung:
184 3 Mikroarchitektur
3.3 Pipelining 185
3.3 Pipelining
Rückblick: Bisheriger Datenpad = Multicycle-Datenpfad
Nachfolgende Abbildung zeigt den bisherigen Datenpfad:
Add
Befehls- Speicher
Adresse
Befehl32
BZ
64
4
BR
Schrei- ben
Schreib- Daten $X
Allzw.-Reg.
64 64
64
64
X
Y
Z
$X
$Y
$Z
OR
o1
o2
o3
23...16
15...8
7...0
560
15...8
63...8
7...0
31...24
64
Verzwei- gungs- Detektor
560
7...0
63...8
7...0
6415...0
63...16
15...0 64
15
...
48
0
4723..0
63...24
23...0
6423
...
40
0
39
10
23
10
ALU
23
0 1
SR
Daten- Eingang
Adresseadr
Daten- Ausgang
Daten- Speicher
Mo- dus
dat
Takt
1
40
2
64
64
clk
_b
r
mu
x_
$X
clk
_b
z
mu
x_
bz
clk
_a
r
c lk_or
clk_sr
clk_ds
mo_ds
alu
v_det
mux_o3
mux_o2
Steuerung
Beim bisherigen Datenpfad steht der gerade ausgeführte Befehl im Befehlsregister und
die Steuerung sorgt über die Steuerleitungen dafür, dass der Befehl ausgeführt wird. Die
Ausführung eines Befehls benötigt mehrere Takte, weshalb dieser Typ von Datenpfad
auch Multicycle-Datenpfad genannt wird.
186 3 Mikroarchitektur
a) Beschreiben Sie den Ablauf der Befehlsausführung.
3.3 Pipelining 187
b) Warum ist der Multicycle-Datenpfad nicht besonders effizient?
c) Wie könnte man den Datenpfad effektiver gestalten?
d) Welche Probleme/Konflikte können dabei auftreten?
188 3 Mikroarchitektur
e) Welche Folgerungen ergeben sich daraus für die Steuerung?
f) Wie lässt sich die Steuerung vereinfachen?
3.3 Pipelining 189
Pipeline-Datenpfad
Nachfolgende Abbildung zeigt eine Implementierung des MMIX-Prozessors.
Befehls-Speicher
32 Lesen $ZLesen $Y
Schreiben/Lesen $X
Schreib-Daten $X
Lese-Daten $Z
Lese-Daten $Y
Registerblock
0..7
8..15Daten
ALU64
BZ64
Adresse
Add64
4
64
Schreiben
640
1
24..31
32
64BR
64
64
0
1
2
64
64
64
ES
ALU-Funktion
64
Daten-Speicher
Adr.
Lese-Daten $X
64 Schreib-Daten
SP
AFDirektoperand
ES
SP ES
2Zugriffs-Art
Zugriffs-Art
Lese-Daten
Ergebnisauswahl
16..23
Reg.-Schreiben
8 8
8
8
Sp.-Schreiben
Schrei-ben
0
1
32
64
Steuerung
8
8Clk1
Clk2Clk3
Clk4
Reg.-Puls
Sp.-Puls
X-Au
swah
l
16..23 $X
$Y
$Z
DirOp.
X X X
ErgALU
$X
ErgALU
LeseDat.
648
056
a) Wie unterscheidet sich diese Implementierung vom bisher kennengelernten Da-
tenpfad in Bezug auf die unterstützten Befehle?
190 3 Mikroarchitektur
b) Wieviele Stufen/Phasen hat die Pipeline? Was passiert in den einzelnen Stu-
fen/Phasen?
Die Register des Datenpfads, die die einzelnen Stufen voneinander abtrennen, werden
Pipeline-Register genannt.
c) Welches ist das erste Pipeline-Register?
d) Was bedeuten die Abschnitte ES, SP und AF des zweiten, dritten und vierten
Pipeline-Registers?
3.3 Pipelining 191
e) Was unterscheidet die Befehlsausführung des gezeigten Pipelining-Datenpfads
vom zuvor kennengelernten Datenpfad?
Gegeben sind zwei Datenpfade:
• Hiergezeigter Datenpfad mit 5-stufiger Pipeline, bei dem in allen Stufen gleich-
zeitig Befehle ausgeführt werden können.
• Derselbe Datenpfad, jedoch mit der Einschränkung, dass die Stufen einzeln
hintereinander getaktet werden (Multicycle-Datenpfad).
f) Um welchen Faktor kann ein MMIX-Programm beim Pipelining-Betrieb schneller
ausgeführt werden als beim Multicycle-Betrieb?
192 3 Mikroarchitektur
g) Um welchen Faktor kann allgemein ein Programm beim Pipelining mit n Stufen
schneller ausgeführt werden als bei einem entsprechenden Multicycle-Datenpfad?
h) Welche Anforderung muss man an die einzelnen Stufen eines Pipelining-
Datenpfads stellen, damit man die Komponenten des Datenpfads bestmöglichst
ausnutzt und den maximalen Performance-Gewinn erzielen kann?
Gegeben ist der folgende Auszug aus einem MMIX-Programm:
ADD $1,$2,3SUB $2,$2,$3MUL $3,$3,5DIV $4,$4,4LDW $5,$254,0LDO $6,$254,8OR $7,$7,#ACAND $8,$8,#DCNEG $9,0,5
i) Vervollständigen Sie für die oben angegebene Befehlsfolge das nachfolgend
angegebene Pipeline-Füll-Diagramm, indem Sie für die gegebenen Zeitpunkte die
Befehle den entsprechenden Pipeline-Stufen zuordnen.
j) Ab welchem Zeitpunkt ist die Pipeline gefüllt?
k) Was bedeutet es, dass die Pipeline gefüllt ist?
3.3 Pipelining 193
BH BD AF SP ES
BH BD AF SP ES
BH BD AF SP ES
BH BD AF SP ES
BH BD AF SP ES
BH BD AF SP
BH BD AF
BH BD
BH
tt t t t t t t t t1 2 3 4 5 6 7 8 9
Betrachten Sie nachfolgend angegebene MMIX-Befehls-Folge.
ADD $1,$2,$3SUB $3,$2,$1MUL $4,$5,6
l) Was für ein Konflikt tritt hier auf?
194 3 Mikroarchitektur
m) Wie könnte man den Konflikt lösen?
Forwarding-Pfade sind zusätzliche Leitungen im Datenpfad, die bereits berechnete bzw.
ermittelte Datenwerte an andere Stellen weiterleiten können.
n) Skizzen Sie Forwarding-Pfade, mit denen Sie sowohl Ergebnisse der ALU als
auch aus dem Datenspeicher ausgelesene Werte an den Eingängen der ALU
bereitstellen können.
3.3 Pipelining 195
Betrachten Sie folgende Befehle:
ADD $1,$2,$3SUB $3,$2,$1
o) Kann der SUB-Befehl durch Forwarding-Pfade so auf den vom ADD-Befehl be-
rechneten Wert zugreifen, dass in der AF-Phase der SUB-Befehl direkt nach dem
ADD-Befehl bearbeitet werden kann?
Betrachten Sie folgende Befehle:
LDO $1,$254,0SUB $3,$2,$1
p) Was ist hier anders?
q) Was für Konsequenzen ergeben sich daraus?
196 3 Mikroarchitektur
Gegeben ist der nachfolgend abgebildete Ausschnitt aus einer MMIX-Codesequenz.
LDT $3,$2,32 Zeile 1SUB $2,$4,8 Zeile 2OR $1,$2,$3 Zeile 3STO $2,$254,$1 Zeile 4
r) Geben Sie alle auftretenden Datenkonflikte an. Nehmen Sie dabei an, dass der Re-
gisterblock ein Datum, das gerade in ihn hineingeschrieben wird, nicht gleichzeitig
am Ausgang ausgeben kann.
Eigene Lösung:
Musterlösung:
s) Welcher zusätzliche Konflikt tritt bei der gegebenen Codesequenz auf? Wie kann
dieser behoben werden?
3.3 Pipelining 197
t) Tragen Sie in nachfolgendes Pipeline-Füll-Diagramm die ausgeführten Befehle
sowie die benötigten Forwarding-Pfade ein. Berücksichtigen Sie die Lösung der
letzten Aufgabe!
Eigene Lösung:
BH BD AF SP ES
BH BD AF SP ES
BH BD AF SP ES
BH BD AF SP ES
BH BD AF SP ES
198 3 Mikroarchitektur
Musterlösung:
BH BD AF SP ES
BH BD AF SP ES
BH BD AF SP ES
BH BD AF SP ES
BH BD AF SP ES
3.3 Pipelining 199
Gegeben ist der folgende Ausschnitt aus einer MMIX Codesequenz:
SUB $2,$5,10 Zeile 1LDO $5,$0,2*8 Zeile 2OR $1,$2,$5 Zeile 3STO $1,$5,$2 Zeile 4
u) Geben Sie alle auftretenden Datenkonflikte an. Nehmen Sie dabei an, dass der Re-
gisterblock ein Datum, das gerade in ihn hineingeschrieben wird, nicht gleichzeitig
am Ausgang ausgegeben werden kann. Nehmen Sie an, dass auf den Regis-
terblock innerhalb einer Phase erst lesend, dann schreibend zugegriffen wird.
Berücksichtigen Sie ggf. einzufügende Stalls.
Eigene Lösung:
Musterlösung:
200 3 Mikroarchitektur
Nehmen Sie folgende Register-Belegung an: $1 = 0x01, $2 = 0x22, $3 = 0x03, $254
= 0x2000000000000000. Nehmen Sie desweiteren an, dass im Speicher an der OCTA-
Adresse 0x2000000000000000 der Wert 0x0123456789ABCDEF steht.
v) Tragen Sie in nachfolgende Abbildung den Inhalt der Pipeline-Register für die unter
den Pipeline-Registern angegebenen Befehle ein. Geben Sie für alle irrelevanten
Einträge ‘‘X’’ an. Nehmen Sie an, dass alle benötigten Forwarding-Pfade geschaltet
sind.
Eigene Lösung:
Reg. Schr.:
Erg. Ausw.:
Sp. Schr.:
Zugr.-Art:
ALU:
Dir. Op.:
$X:
Dir. Op.:
$Y:
$Z:
X:
Reg. Schr.:
Erg. Ausw.:
Sp. Schr.:
Zugr.-Art:
$X:
Erg. ALU:
X:
Reg. Schr.:
Erg. Ausw.:
Lese-Daten:
X:
Erg. ALU:
ADD $1,$3,2 Stall LDT $3,$254,$1
STT $1,$254,0
STT $1,$254,0
0x21
3.3 Pipelining 201
Musterlösung:
Reg. Schr.:
Erg. Ausw.:
Sp. Schr.:
Zugr.-Art:
ALU:
Dir. Op.:
$X:
Dir. Op.:
$Y:
$Z:
X:
Reg. Schr.:
Erg. Ausw.:
Sp. Schr.:
Zugr.-Art:
$X:
Erg. ALU:
X:
Reg. Schr.:
Erg. Ausw.:
Lese-Daten:
X:
Erg. ALU:
ADD $1,$3,2 Stall LDT $3,$254,$1
STT $1,$254,0
STT $1,$254,0
0x21
202 3 Mikroarchitektur
Nehmen Sie die folgenden Registerwerte an: $1 = 0x11, $2 = $22, $3 = $33, $254 =
0x2000000000000000
w) Tragen Sie in nachfolgende Abbildung den Inhalt der Pipeline-Register für die unter
den Pipeline-Registern angegebenen Befehle ein. Geben Sie für alle irrelevanten
Einträge ‘‘X’’ an. Nehmen Sie an, dass alle benötigten Forwarding-Pfade geschaltet
sind.
Eigene Lösung:
Reg. Schr.:
Erg. Ausw.:
Sp. Schr.:
Zugr.-Art:
ALU:
Dir. Op.:
$X:
Dir. Op.:
$Y:
$Z:
X:
Reg. Schr.:
Erg. Ausw.:
Sp. Schr.:
Zugr.-Art:
$X:
Erg. ALU:
X:
Reg. Schr.:
Erg. Ausw.:
Lese-Daten:
X:
Erg. ALU:
0x05
SUB $1,$3,$2ADD $3,$254,0 OR $2,$2,36 AND $3,$2,28
1
1
0
X
1
1
0
X
1
1
ADD $3,$254,0
3.3 Pipelining 203
Musterlösung:
Reg. Schr.:
Erg. Ausw.:
Sp. Schr.:
Zugr.-Art:
ALU:
Dir. Op.:
$X:
Dir. Op.:
$Y:
$Z:
X:
Reg. Schr.:
Erg. Ausw.:
Sp. Schr.:
Zugr.-Art:
$X:
Erg. ALU:
X:
Reg. Schr.:
Erg. Ausw.:
Lese-Daten:
X:
Erg. ALU:
0x05
SUB $1,$3,$2ADD $3,$254,0 OR $2,$2,36 AND $3,$2,28
1
1
0
X
1
1
0
X
1
1
ADD $3,$254,0
204 3 Mikroarchitektur
3.4 Cache 205
3.4 Cache
Motivation
Betrachten Sie den folgenden Pipelining-Datenpfad:
Befehls-Speicher
32 Lesen $ZLesen $Y
Schreiben/Lesen $X
Schreib-Daten $X
Lese-Daten $Z
Lese-Daten $Y
Registerblock
0..7
8..15Daten
ALU64
BZ64
Adresse
Add64
4
64
Schreiben
640
1
24..31
32
64BR
64
64
0
1
2
64
64
64
ES
ALU-Funktion
64
Daten-Speicher
Adr.
Lese-Daten $X
64 Schreib-Daten
SP
AFDirektoperand
ES
SP ES
2Zugriffs-Art
Zugriffs-Art
Lese-Daten
Ergebnisauswahl
16..23
Reg.-Schreiben
8 8
8
8
Sp.-Schreiben
Schrei-ben
0
1
32
64
Steuerung
8
8Clk1
Clk2Clk3
Clk4
Reg.-Puls
Sp.-Puls
X-Au
swah
l
16..23 $X
$Y
$Z
DirOp.
X X X
ErgALU
$X
ErgALU
LeseDat.
648
056
a) Wie muss der Pipelining-Datenpfad getaktet werden, damit möglichst viele Befehle
pro Zeiteinheit abgearbeitet werden können?
206 3 Mikroarchitektur
b) Wenn alle Pipeline-Stufen gleichzeitig getaktet werden: Was folgt daraus hinsicht-
lich der Ausführungszeit der einzelnen Stufen?
c) Welche Pipeline-Stufen sind von sich aus eher schnell, welche eher langsam?
Begründen Sie Ihre Antwort.
3.4 Cache 207
d) Wo liegt der Flaschenhals des Datenpfads?
e) Wie könnte man diesen Flaschenhals beseitigen?
f) Was beschränkt eine Total-Integration des Arbeitsspeichers in den Prozessor?
g) Macht es Sinn, auf dem Prozessor eine kleine Menge an schnellem Arbeitsspeicher
zu integrieren? Warum?
208 3 Mikroarchitektur
Direkt abgebildeter Cache
Der ‘‘Cache’’ ist ein kleiner, sehr schneller SRAM-Speicher, der direkt auf demProzessor-
Die untergebracht ist. Er wird zur Zwischenspeicherung von Befehlen (Befehls-Cache)
und Daten (Daten-Cache) verwendet.
a) Zeichnen Sie in nachfolgende Abbildung ein, wie man – einfach zu realisieren –
eine große Menge Arbeitsspeicher auf eine kleine Menge Cache-Speicher abbilden
kann.
Eigene Lösung:
0x00
0x01
0x02
0x03
0x04
0x05
0x06
0x07
0x08
0x09
0x0A
0x0B
0x0C
0x0D
0x0E
0x0F
0x00
0x01
0x02
0x03
3.4 Cache 209
Musterlösung:
0x00
0x01
0x02
0x03
0x04
0x05
0x06
0x07
0x08
0x09
0x0A
0x0B
0x0C
0x0D
0x0E
0x0F
0x00
0x01
0x02
0x03
b) Wie kannman feststellen, auf welcheCache-Adresse eine Arbeitsspeicher-Adresse
abgebildet wird?
210 3 Mikroarchitektur
Nachfolgende Abbildung zeigt, wie beim sog. Direktabgebildeten Cache jede
Arbeitsspeicher-Adresse direkt auf eine Cache-Adresse abgebildet wird.
Byte-AuswahlRahmen-Nr.Schlüssel
0
1
2 - 1
012...2 - 1b
...
f
bf (frame)k (key) bytes
k Bits
b Bitsf Bitsk Bits
Arbeitsspeicher-Adresse (k + f + b Bits)
Rahmen (frame)
In diesen 2 Byte sind die Cache-Daten abgespeichert (Cache-Inhalt)
f+bIn diesen k⋅2 Bits des sog. Tag-RAMs ist der von jedem Cache-Rahmen verwendete Schlüssel abgespeichert
f
v
v
v
v
v
v
v
v
Bei einem Cache-Zugriff, wird zunächst die Rahmen-Nummer aus der Arbeitsspeicher-
Adresse extrahiert. Mit der Rahmen-Nummer wird dann einer von 2f � 1 Einträge des
sog. Tag-RAMs adressiert.
c) Wieviele Einträge hat das Tag-RAM, wenn zur Codierung der Rahmen-Nummer 20
Bits verwendet werden?
d) Welcher Rahmen wird beim Zugriff mit der 64 Bit breiten Arbeitsspeicher-Adresse
0x0123456789ABCDEF ausgewählt, wenn der Schlüssel mit 40 Bits und die
Byteauswahl mit 12 Bits codiert wird?
3.4 Cache 211
e) Welcher Rahmen wird beim Zugriff mit der 64 Bit breiten Arbeitsspeicher-Adresse
0x0123456789ABCDEF ausgewählt, wenn der Schlüssel mit 38 Bits und die
Byteauswahl mit 10 Bits codiert wird? Geben Sie den Wert hexadezimal an.
Eigene Lösung:
Musterlösung:
Der adressierte k Bit breite Tag-RAM Eintrag wird mit den höherwertigsten k Bits der
Arbeitsspeicher-Adresse (Schlüssel genannt) verglichen. Sind Schlüssel und adressierter
Tag-RAM-Eintrag identisch, dann sind die gesuchten Arbeitsspeicher-Daten dem dem
adressierten Tag-RAM-Eintrag zugehörigen Cache-Frame zugeordnet. Falls das v-Bit (v
= valid) auf 1 gesetzt ist, ist das im Cache gespeicherte Datenwort gültig.
f) Wieviele 1-Bit-Vergleicher sind zum Vergleich des Schlüssels mit dem adressierten
Tag-RAM-Eintrag notwendig?
g) Warum werden bei einem Arbeitsspeicher-/Cache-Zugriff die oberen k Bits der
Arbeitsspeicher-Adresse im Tag-RAM abgelegt?
Ist der Arbeitsspeicher-Rahmen im Cache gespeichert, kann über die Byte-Auswahl das
entsprechende Byte des Cache-Rahmens adressiert werden.
h) Wie groß ist ein Cache-Rahmen, wenn zur Codierung der Byte-Auswahl 12 Bits
verwendet werden?
212 3 Mikroarchitektur
i) In einem Cache-Rahmen können 16 Octas abgelegt werden. Wieviele Bits werden
zur Codierung der Byteauswahl benötigt?
Voll-Assoziativer Cache
Bei einem Voll-Assoziativen Cache können die Daten eines Arbeitsspeicher-Rahmens in
jedem beliebigen Cache-Rahmen abgespeichert werden.
a) Wie muss die Arbeitsspeicher-Adresse zur Adressierung eines Voll-Assoziativen
Caches aufgeteilt werden?
b) Ein vollassoziativer MMIX-Cache-Speicher verwendet eine Rahmengröße von 256
Byte. Wieviele Bits werden zur Codierung des Schlüssels verwendet?
c) Ein 32 kByte großer vollassoziativer MMIX-Cache-Speicher verwendet eine Rah-
mengröße von 256 Byte. Wieviele 1-Bit-Vergleicher sind zum Vergleich des Schlüs-
sels mit den Tags notwendig?
Eigene Lösung:
Musterlösung:
3.4 Cache 213
Set-Assoziativer/Mengen-Assoziativer Cache
Beim Set-Assoziativen Cache kann ein Arbeitsspeicher-Rahmen in einen von a ausge-
wählten Cache-Rahmen abgelegt werden. a wird die Assoziativität des Caches genannt.
Byte-AuswahlSet-Nr.Schlüssel
0
1
2 - 1
012...2 - 1b
...
s
bs (set)k (key) bytes
k Bits
b Bitss Bitsk Bits
Arbeitsspeicher-Adresse (k + s + b Bits)
Rahmen (frame)
In diesen a⋅2 Byte sind die Cache-Daten abgespeichert (Cache-Inhalt)
s+bIn diesen k⋅2 Bits des sog. Tag-RAMs ist der von jedem Cache-Rahmen verwendete Schlüssel abgespeichert
s
v
v
v
v
v
v
v
v
2
Assoziativität a = 2
Zur Detektion, ob ein Arbeitsspeicher-Rahmen im Cache liegt, muss der Schlüssel
der Arbeitsspeicher-Adresse mit allen Tags des durch die Set-Nummer adressierten
Cache-Sets verglichen werden.
a) Wieviele 1-Bit-Vergleicher sind für einen 4 fach Set-Assoziativen MMIX-Cache
notwendig, wenn die Rahmengröße 2048 Byte beträgt und bei jeder 228-sten
Speicheradresse auf dasselbe Set zugegriffen wird? Wieviele Sets hat der Cache?
214 3 Mikroarchitektur
b) Über wieviele Cache-Rahmen verfügt ein 8 fach Set-Assoziativer MMIX-Cache,
wenn zur Codierung der Set-Nummer 13 Bit verwendet werden?
Ein 8 fach Set-Assoziativer MMIX-Cache hat eine Größe von 1 MB. Die Rahmengröße
beträgt 32 Byte.
c) Wieviele Bits werden zur Codierung der Byteauswahl, der Setnummer und des
Schlüssels verwendet?
Ein 16 fach Set-Assoziativer MMIX-Cache hat 2048 Cache Sets. Zum Vergleich des
Schlüssels mit den Tags werden 688 Vergleicher verwendet.
d) Welche Rahmengröße hat der Cache?
3.4 Cache 215
Ein Set-Assoziativer Cache verwendet zur Codierung des Schlüssels 41 Bit, zur Codie-
rung der Setnummer 16 Bit und zur Codierung der Byteauswahl 7 Bit.
e) Geben Sie für folgende Arbeitsspeicher-Adressen die zugehörige Set-Nummer an.
0x2000 0000 0000 0000:
0x2000 0000 0123 4567:
0x2000 0000 478B 0228:
Top Related