Aufgabenkatalog

Commentaren

Transcriptie

Aufgabenkatalog
Aufgabenkatalog
Computersysteme 1
Dr. Michael Zwick
Technische Universität München
Inhalt
1 Komponenten eines Computer-Systems
Netzteil . . . . . . . . .
Grafikkarten . . . . . .
Optische Laufwerke . .
Festplatte . . . . . . . .
Prozessor . . . . . . . .
Bussystem . . . . . . .
Rechner-Architekturen
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
2 Assemblerprogrammierung
2.1 Zahldarstellung . . . . . . . . . . . .
Festkommazahlen . . . . . . . . . .
Gleitkommazahlen nach IEEE 754 .
Format von Gleitkommazahlen .
Rechnen mit Gleitkommazahlen
5
5
6
6
7
9
10
11
13
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
2.2 MMIX Architektur . . . . . . . . . . . . . . . .
Überblick . . . . . . . . . . . . . . . . . . . .
MMIX Register . . . . . . . . . . . . . . . . .
Allgemein . . . . . . . . . . . . . . . . . .
Allzweckregister . . . . . . . . . . . . . .
Spezialregister . . . . . . . . . . . . . . .
Arbeitsspeicher . . . . . . . . . . . . . . . .
Allgemein . . . . . . . . . . . . . . . . . .
Speicher-Organisation . . . . . . . . . . .
Alignment . . . . . . . . . . . . . . . . . .
Byte-Reihenfolge beim Abspeichern von
Little-Endian . . . . . . . . . . .
Format von MMIX-Programmen . . . . . . .
Assembler- und Loader-Befehle . . . . . . .
MMIX Befehlsformat . . . . . . . . . . . . . .
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
13
13
17
17
19
. . . . . . . . . . . . . .
. . . . . . . . . . . . . .
. . . . . . . . . . . . . .
. . . . . . . . . . . . . .
. . . . . . . . . . . . . .
. . . . . . . . . . . . . .
. . . . . . . . . . . . . .
. . . . . . . . . . . . . .
. . . . . . . . . . . . . .
. . . . . . . . . . . . . .
Datenworten: Big- und
. . . . . . . . . . . . . .
. . . . . . . . . . . . . .
. . . . . . . . . . . . . .
. . . . . . . . . . . . . .
.
.
.
.
.
.
.
.
.
.
22
22
23
23
23
25
27
27
28
31
.
.
.
.
32
33
34
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 .
Subtraktion von Binärzahlen: Addition des negativen zweiten Operanden . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Multiplikation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Multiplikation 11 · 13 = 143 im Binärsystem, Wortbreite = 4 . . . .
Multiplikation 13 · 5 = 65 im Binärsystem, Wortbreite = 4 . . . . .
Multiplikations-Hardware . . . . . . . . . . . . . . . . . . . . . . .
Zustandsdiagramm der Steuerung . . . . . . . . . . . . . . . . . .
Multiplexer-basierte Implementierung der Steuerung . . . . . . . .
ROM-basierte Implementierung der Steuerung . . . . . . . . . . .
. 150
.
.
.
.
.
.
.
.
151
153
153
159
162
165
168
177
3.3 Pipelining . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 185
Rückblick: Bisheriger Datenpad = Multicycle-Datenpfad . . . . . . . . . 185
Pipeline-Datenpfad . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 189
3.4 Cache . . . . . . . . . . . . . . . . . . . . . . .
Motivation . . . . . . . . . . . . . . . . . . . .
Direkt abgebildeter Cache . . . . . . . . . . .
Voll-Assoziativer Cache . . . . . . . . . . . . .
Set-Assoziativer/Mengen-Assoziativer Cache .
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
205
205
208
212
213
5
1 Komponenten eines Computer-Systems
Netzteil
a)
Welche Spannungen werden von PC-Netzteilen bereitgestellt?
3.3 V, 5 V, 12 V, -5 V, -12 V.
b) Warum können PC-Netzteile hohe Leistungen liefern, obwohl die eingebauten
Transformatoren nur relativ klein sind?
PC-Netzteile werden in der Regel als Schaltnetzteile gebaut, die mit einigen kHz
betrieben werden. Da bei Transformatoren die übertragbare Leistung nicht nur von
der Anzahl der Windungen abhängt, sondern auch von der Frequenz, kann bei
einre Erhöhung der Frequenz auch eine höhere Leistung übertragen werden.
c)
Wie sind Schaltnetzteile aufgebaut? Skizzieren Sie ein Blockschaltbild!
°
230 V ~
°
Gleichrichter
°
•
~
°•
°
•
•
°
SchaltGlied
HF
Trafo
Gleichrichter
•
=
°
°
°
°
°
°
°
~
Galvanische
Trennung
°
°
°
°
°•
°
Tiefpass
°
°
•
°
°
•
°
•
•
Regelkreis
=
°
=
•
°
5V=
°
6
1 Komponenten eines Computer-Systems
Grafikkarten
a)
Was sind die Hauptaufgaben einer Grafikkarte?
• Schnittstelle PC $ Display
• Hardware-Bescheunigung von Grafik-Berechnungen: 3D-Berechnungen,
schnelles Zeichnen von Grafik-Primitiven, rendern
b) Was ist ein ‘‘Back-Buffer’’, was ist ein ‘‘Front-Buffer’’?
Der ‘‘Front-Buffer’’ wird gerade am Bildschirm dargestellt, während der ‘‘BackBuffer’’ im Rahmen des Renderings verändert wird.
Optische Laufwerke
a)
Was sind Pits und Land?
Land ist die Oberfläche des optischen Mediums. Pits sind kleine Vertiefungen auf
dem Land.
b) Was reflektiert Licht: Pits, Land oder beides?
Beides
c)
Welche Tiefe müssen die Pits haben, damit man die mit Pits und Land gespeicherte
Information sinnvoll auslesen kann? Warum?
Die Pits müssen eine Tiefe von /4 haben, wobei die Wellenlänge des Lasers
ist, der zum Auslesen verwendet wird. Das Licht, das von einem Pit reflektiert wird
ist dann gegenüber dem vom Land reflektierten Licht um /2 phasenverschoben
( /4 (Land ! Pit) + /4 (Pit ! Land) = /2).
7
Festplatte
a)
Was ist eine Festplatten-Spur?
Kreis den die Schreib-/Leseköpfe auf der Platte abfahren, wenn sich bei rotierender
Platte die Position des Schreib-/Lesekopfs nicht ändert.
b) Was ist ein Festplatten-Zylinder?
Ein Festplatten-Zylinder ist die Menge der Spuren, die gleichzeitig gelesen/geschrieben werden. (Bei einer Festplatte werden in der Regel immer mehrere
Platten auf einer Achse verbaut. Diese Platten werden gleichzeitig beschrieben/ausgelesen.)
c)
Was ist ein Festplatten-Sektor?
Ein Sektor ist kleinste adressierbare Einheit bei einer Festplatte. Die auf einer
Festplatte abzuspeichernden Daten werden in Sektoren abgespeichert.
d) Was sind typische Sektor-Größen?
512 Byte, 4 kByte
e)
Was für Informationen werden in Sektoren neben den Nutzdaten noch zusätzlich
abgespeichert?
Verwaltungs-Information, z.B. Zylinder-ID, Sektor Start- und Ende-Markierungen,
...
8
1 Komponenten eines Computer-Systems
f)
Skizzieren Sie grob einen Regelkreis der zur Positionierung des Festplatten-Arms
verwendet werden kann.
Soll-Position
+
Fehler
Aktuelle Position
Regelung
Sensor
•
Spulenstrom
9
Prozessor
a)
Aus welchen logischen Grundeinheiten besteht ein Prozessor?
• Rechenwerk/ALU
• Registerblock
• Steuerwerk/Leitwerk
• Befehlsregister
• Befehlszähler
• Flags
• Bus-Treiber-Logik
• Cache
• Einheit zur Adress-Übersetzung/Virtueller Speicher
b) Welche Schritte führt ein Prozessor aus, wenn er den nächsten Befehl aus dem
Speicher lädt?
• Den Wert des Befehlszählers als Adresse auf den Adress-Bus legen
• Vom Datenbus das adressierte Datum einlesen
• Den eingelesenen Wert im Befehls-Register ablegen.
c)
Wo können die Operanden eines Befehls generell abgelegt sein?
• Direkt im Befehlswort (Direktoperand/immediate operand)
• In den Registern
• Im Speicher
10
1 Komponenten eines Computer-Systems
Bussystem
a)
In welche drei Busse lässt sich ein Bussystem oft aufgliedern?
• Adressbus
• Datenbus
• Steuerungsbus
b) Was ist die Funktion dieser drei Busse?
• Adressbus: Dient zur adressierung einer Speicheradresse oder eines
Geräts
• Datenbus: Auf dem Datenbus werden die Daten übertragen; sowohl im
Fall Lesen als auch im Fall Schreiben
• Steuerungsbus: Teilt mit, ob gelesen oder geschrieben werden soll bzw.
wann gültige Daten auf dem Bus liegen
c)
Welche dieser Busse sind unidirektional, welche bidirektional?
• Unidirektional: Adress- und Steuerbus; wird vom Prozessor gesteuert
(ausser DMA)
• Bidirektional: Datenbus (lesen und schreiben)
11
Rechner-Architekturen
a)
Was ist der Haupt-Unterschied zwischen einer Harvard- und einer von NeumannArchitektur?
• Von Neumann: Daten und Befehle liegen im selben Speicher
• Harvard-Architektur: Daten und Befehle liegen in unterschiedlichen Speichern.
b) Wie kann man die Aussage verstehen, dass heutige Rechnersysteme oft sowohl
eine Harvard- als auch eine von Neumann-Architektur haben?
Bei heutigen Rechner-Systemen werden häufig für Befehle und Daten verschiedene L1-Caches verwendet. Ab dem L2-Cache wird dann oft nicht mehr zwischen
Befehlen und Daten unterschieden, d.h. es gibt dann nur noch einen L2-Cache in
dem dann sowohl Befehle als auch Daten abgespeichert sind.
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.
Dezimal
Binär vorzeichenlos
0
0000 0000
75
0100 1011
127
0111 1111
128
1000 0000
129
1000 0001
255
1111 1111
14
2 Assemblerprogrammierung
b) Wandeln Sie – soweit möglich – die folgenden Dezimalzahlen in die Systeme
Vorzeichen und Betrag, Einer Komplement und Zweier Komplement um.
Dezimal
Vorzeichen und Betrag
Einer Komplement
Zweier Komplement
+75
0100 1011
0100 1011
0100 1011
-75
1100 1011
1011 0100
1011 0101
+0
0000 0000
0000 0000
0000 0000
-0
1000 0000
1111 1111
0000 0000
+127
0111 1111
0111 1111
0111 1111
-127
1111 1111
1000 0000
1000 0001
+128
-
-
-
-128
-
-
1000 0000
2.1 Zahldarstellung
c)
15
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 dem mittleren Ring entsprechenden Dezimalzahlen enthalten für den Fall, dass der mittlere Ring vorzeichenlose Zahlen
codiert und
• der innere Ring soll die dem mittleren Ring entsprechenden Dezimalzahlen 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.
8
9
10
1001
1010
7
1000 0111
-7
-8
7
6
0110
6
-6
11 1011
-5
12
Vorzeichenbehaftet: pos + pos = neg
neg + neg = pos
1100 -4
5
neg.
pos.
-3
1101
13
0101
4
0100 4
3
0011
2
-2
1110
14
5
-1
1
0
1111 0000
15
3
0010
0001
2
1
0
Vorzeichenlos
16
2 Assemblerprogrammierung
d) Wie kann man einen Überlauf von vorzeichenlosen Zahlen feststellen?
Das Carry-Out-Bit, d.h. das Bit an der Stelle MSB + 1 ist gesetzt.
e)
Wie lässt sich ein Überlauf von vorzeichenbehafteten Zahlen feststellen?
Bei vorzeichenbehafteten Zahlen tritt ein Überlauf auf, wenn man
• zwei positive Zahlen addiert und eine negative Zahl als Ergebnis erhält,
oder wenn man
• zwei negative Zahlen addiert und eine positive Zahl als Ergebnis bekommt.
f)
Berechnen Sie 37 + 53 im vorzeichenlosen Binärformat.
37 = 32 + 4 + 1 ) 0010 0101
53 = 32 + 16 + 4 + 1 ) 0011 0101
+
0010 0101
0011 0101
0101 1010
g) Berechnen Sie 37 - 53 im Zweier Komplement.
37 = 32 + 4 + 1 ) 0010 0101
53 = 32 + 16 + 4 + 1 ) 0011 0101
53ones’ comp. = 1100 1010
53twos’ comp. = 1100 1011
+
0010 0101
1100 1011
1111 0000
Wert:
Einer Komplement: 0000 1111
Zweier Komplement: 0001 0000
) 16
2.1 Zahldarstellung
17
Gleitkommazahlen nach IEEE 754
Format von Gleitkommazahlen
a)
Geben Sie das Format von 32 Bit und 64 Bit Gleitkommazahlen an.
• 32 Bit: 1 Bit Vorzeichen, 8 Bit Exponent, 23 Bit Bruchteil/Fraction
• 64 Bit: 1 Bit Vorzeichen, 11 Bit Exponent, 52 Bit Bruchteil/Fraction
b) Wie berechnet sich der Wert einer 32 bzw. 64 Bit breiten normalisierten Gleitkommazahl aus ihrem Bitmuster? Geben Sie den Wert der Konstanten K an!
v = ( 1)s · 2e
K
· 1.f
• 32 Bit: s = sign = Vorzeichen; e = Exponent (8 bit); K = 127; f = fraction =
Bruchteil (23 bit)
• 64 Bit: s = sign = Vorzeichen; e = Exponent (11 bit); K = 1023; f = fraction
= Bruchteil (52 bit)
c)
In welchem Bereich liegt e bei normalisierter Zahldarstellung?
• 32 Bit: 0 < e < 255
• 64 Bit: 0 < e < 2047
d) Wie wird die Zahl 0.0 dargestellt in Bezug auf s, e and f?
s = 0; e = 0; f = 0
18
e)
2 Assemblerprogrammierung
Was ist eine denormalisierte Gleitkommazahl, wie wird sie kodiert und wie berechnet sich ihr Wert?
Bei normalisierten Gleitkommazahlen wird eine ‘‘1,’’ direkt vor den Bruchteil f
hinzugefügt. Bei denormalisierten Gleitkommazahlen ist es eine ‘‘0,’’. Mit denormalisierten Gleitkommazahlen können – um den Wert 0 herum – betragsmäßig viel
kleinere Zahlen dargestellt werden als bei normalisierten Gleitkommazahlen.
Kodierung: e = 0; f > 0;
Wert: v = ( 1)s · 21 K · 0.f
f)
Wie kodiert man die Gleitkommazahl ‘‘unendlich’’?
• 32 Bit: e = 255; f = 0
• 64 Bit: e = 2047; f = 0
• Das Bit s gibt jeweils das Vorzeichen an (+1 oder
1).
g) Mit welchen Werten von e und f wird ausgesagt, dass es sich um ‘‘keine Zahl’’
(NaN = not a number) handelt?
• 32 Bit: e = 255; f > 0
• 64 Bit: e = 255; f > 0
h)
Geben Sie ein Beispiel an, wie es zu einem Ergebnis kommen kann, das ‘‘keine
Zahl’’ ist.
Wurzel einer negativen Zahl. (Auch möglich: Division 0/0)
2.1 Zahldarstellung
19
Rechnen mit Gleitkommazahlen
a)
Geben Sie die Festkomma-Binärdarstellung von 3,625 und 13,5 an.
3.625 ! 11.101
13.5 ! 1101.1
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:
11.101 = 1.1101 · 21
s=0
e K =1
e = K + 1 = 127 + 1 = 128
f = 11010...0
13.5:
1101.1 = 1.1011 · 23
s=0
e K =3
e = K + 3 = 127 + 3 = 130
f = 10110...0
3.625:
0 1 0 0 0 0 0 0 0 1 1 0 1 0 0 0 0 ...
0
13.5:
0 1 0 0 0 0 0 1 0 1 0 1 1 0 0 0 0 ...
0
20
c)
2 Assemblerprogrammierung
Berechnen Sie 3,625 + 13,5 im Binärsystem bei Verwendung einer 32 Bit Gleitkommakodierung.
Exponent 3.625: 10000000
Exponent 13.5: 10000010
Exponent von 3.625 dem von 13.5 anpassen (Exponenten müssen gleich sein,
bevor die Mantissen addiert werden können).
13.5:
Exponent
Bruchteil/Mantisse
1000 0010
1011000...0
3.625:
Exponent
Bruchteil/Mantisse
1000 0000
1000 0001
1000 0010
1101000...0
11101000...0 (führende 1,)
011101000...0
Mantissen addieren:
+
1.101100000...0
0.011101000...0
10.001001000...0
Normalisieren:
Mantisse normalisieren: 10.001001000...0 ! 1.0001001000...0
Exponent normalisieren: 1000 0010 ! 1000 0011
Bitmuster des Ergebnisses:
0 1 0 0 0 0 0 1 1 0 0 0 1 0 0 1 0 ...
0
2.1 Zahldarstellung
21
d) Bestimmen Sie aus dem Ergebnis-Bitmuster das Ergebnis der Addition 3,625 +
13,5
( 1)0 · 1,0001001 · 2131
127
= 10001,001 · 20 = 17,12510
22
2 Assemblerprogrammierung
2.2 MMIX Architektur
Überblick
a)
Auf welche Mikroarchitektur-Komponenten kann ein MMIX-Programmierer in seinen Programmen zugreifen (‘‘Programmier-Architektur’’)?
•
•
•
•
•
Rechenwerk/ALU
Allzweckregister
Spezialregister
Hauptspeicher
Befehlsregister
b) Zeichnen Sie die MMIX ‘‘Programmier-Architektur’’. Zeichen Sie mit gerichteten
Pfeilen den Informationsfluss ein und geben Sie dabei die Wortbreiten an.
Spezial-
Register
Allzweck-
Register
Speicher
64 Bit
8, 16, 32, 64 Bit
OP
X
Y
Z
32 Bit Befehlswort
8, 16, 24 Bit
Rechen-
werk (ALU)
64 Bit
64 Bit
2.2 MMIX Architektur
23
MMIX Register
Allgemein
a)
Was ist ein Register?
Ein Register ist ein sehr kleiner aber schneller Speicher.
b) Wo findet man Register in einem Computer-System?
Hauptprozessor, Steuerungen von externen Geräten, ...
c)
Daten welcher Größenordnung kann ein Register aufnehmen: Byte, kilobytes,
megabytes, gigabytes or terabytes?
Ein Register speichert in der Regel nicht mehr als einige Byte.
d) Skizzieren Sie das Schaltbild eines Registers das 64 Bit Daten abspeichern kann.
Clk
Daten-
Eingang
64
64
Daten-
Ausgang
Allzweckregister
a)
Was sind Allzweckregister?
Allzweckregister sind Register, die keinem bestimmten Zweck (z.B. Steuerung der
Hardware, Bereitstellen von Statusinformationen der Hardware, ...) zugeordnet
sind und somit für die Programme frei zur Verfügung stehen.
b) Geben Sie ein Beispiel für eine typische Verwendung eines Allzweckregisters an.
Quell- oder Zieloperanden für arithmetische Befehle.
24
c)
2 Assemblerprogrammierung
Über wieviele Allzweckregister verfügt der MMIX-Prozessor? Welche Namen haben
sie?
Der MMIX hat 256 Allzweckregister, die $0, $1, ... , $255 genannt werden.
d) Was ist der Unterschied zwischen einem globalen und einem lokalen Register?
• Global: Gedacht für die Verwendung von allen Programmteilen
• Lokal: Gedacht für die Verwendung durch einzelne Funktionen
e)
Skizzieren Sie die MMIX-Allzweckregister und tragen Sie in Ihre Skizze ein, wo die
globalen und wo die lokalen Register liegen.
$255
Globale
Register
rG
Marginale
Register
rL
Lokale
Register
$0
2.2 MMIX Architektur
25
Spezialregister
a)
Was ist ein Spezialregister?
Spezialregister sind auf dem Prozessor untergebracht und werden dazu verwendet, von Programmen aus die Hardware zu steuern bzw. um Programmen
Statusinformationen aus der Hardware zugänglich zu machen.
b) Geben Sie eine typische Anwendung eines Spezialregisters an.
Rundungsmodus für Gleitkommaoperationen festlegen.
c)
Über wieviele Spezialregister verfügt der MMIX-Prozessor? Wie werden sie genannt (Prinzip)?
Der MMIX verfügt über 32 Spezialregister. Der Name beginnt mit ‘‘r’’, dann kommen
1 oder 2 Buchstaben. (Konkret: rA, rB, ... , rZ, rBB, rTT, rWW rXX, rYY und rZZ)
d) Kann jeder MMIX-Befehl Spezialregister verwenden?
Nein. Auf Spezialregister kann nur mit GET (lesen) und PUT (schreiben) zugegriffen
werden.
e)
Welches Spezialregister stellt Informationen über Arithmetische Operationen zur
Verfügung?
Spezialregister rA.
f)
In welchem Spezialregister kann man die oberen 64 Bit eines 128 Bit breiten
Festkomma-Dividenden ablegen?
Register rD.
g) In welchem Register werden die oberen 64 Bit des Ergebnisses einer FestkommaMultiplikation abgelegt?
Spezialregister rH.
26
2 Assemblerprogrammierung
h)
In welchem Spezialregister legt das Rechenwerk den Rest einer FestkommaDivision ab?
Spezialregister rR.
i)
Müssen ‘‘normale’’ Programme häufig auf Spezialregister zugreifen?
In der Regel nicht. Beispielsweise sind 64 Bit Festkomma-Genauigkeit in der Regel
völlig ausreichend.
j)
Was müssen Sie tun, wenn Sie einzelne Bits eines Spezialregisters verändern
wollen?
• Spezialregister mit GET in Allzweckregister einlesen
• Allzweckregister bearbeiten
• Allzweckregister mit PUT wieder in Spezialregister schreiben
2.2 MMIX Architektur
27
Arbeitsspeicher
Allgemein
a)
Wozu verwendet ein Computer Arbeitsspeicher?
Speichern von Daten, mit denen gerade gearbeitet wird.
b) Wo findet man den Arbeitsspeicher in einem Computersystem? Auf dem
Prozessor-Kern? Auf dem Mainboard? Als externes Gerät?
Man findet Computer-Speicher auf dem Mainboard.
c)
Sind Zugriffe auf den Arbeitsspeicher in der Regel schneller oder langsamer als
Zugriffe auf Register?
Zugriffe auf den Arbeitsspeicher sind nie schneller als Zugriffe auf die Register
im Hauptprozessor, sondern wesentlich langsamer. Im Vergleich zu FestplattenZugriffen sind sie jedoch viel schneller.
d) Begründen Sie Ihre Antwort auf die letzte Frage.
Register sind direkt in Prozessoren integriert und können deshalb mit vollem
Prozessor-Takt angesprochen werden. Der Hauptspeicher befindet sich ausserhalb des Prozessors und muss deshalb über den langsamen Bus angesprochen
werden. Durch die langen Verbindungsleitungen (Bus) erhöhen sich nicht nur die
reinen Signallaufzeiten, sondern es ergeben sich auch höhere Kapazitäten, die
überwunden werden müssen. Desweiteren müssen die Signale durch zusätzliche elektronische Komponenten laufen, die das Bus-Protokoll implementieren.
Desweiteren werden die Register auf dem Hauptprozessor mit schnellem SRAM
implementiert, und nicht mit dem langsameren DRAM.
28
2 Assemblerprogrammierung
Speicher-Organisation
a)
Zeichnen Sie die Segmente des virtuellen MMIX-Speichers mit den zugehörigen
Start- und End-Adressen.
0x0000000000000000
= Text_Segment
Interruptvektoren
0x00000000000000FF
0x0000000000000100
Text-
segment
MMIX-Programme
0x1FFFFFFFFFFFFFFF
0x2000000000000000
= Data_Segment
Variable
Datensegment
0x3FFFFFFFFFFFFFFF
Stack
0x4000000000000000
= Pool_Segment
Poolsegment
0x5FFFFFFFFFFFFFFF
0x6000000000000000
= Stack_Segment
Stacksegment
0x7FFFFFFFFFFFFFFF
0x8000000000000000
Für Betriebssystem
reservierter Bereich
0xFFFFFFFFFFFFFFFF
2.2 MMIX Architektur
29
b) Was wird im Textsegment gespeichert?
• Programm-Code
• Direktoperanden
• Interruptvektoren
c)
Was ist ein Interrupt?
Bei einem Interrupt wird die Programmausführung unterbrochen und es wird in
die Interrupt Service Routine (ISR) verzweigt. Nach Abarbeitung der ISR wird das
Programm an der unterbrochenen Stelle fortgesetzt.
d) Nennen Sie ein Ereignis, bei dem ein Interrupt auftreten kann.
Division durch 0.
e)
Was sind Interruptvektoren?
Bereich im Arbeitsspeicher, in dem Adressen oder Verzweigungen zu Interrupt
Service Routinen gespeichert werden.
f)
Was wird im Datensegment gespeichert?
• Variable: Von niedrigeren zu höheren Adressen
• Stack: Von höheren zu niedrigeren Adressen
30
2 Assemblerprogrammierung
g) Was wird im Poolsegment gespeichert?
Das Poolsegment wird gemeinsam vom Programm und dem Betriebssystem
verwendet und wird zum Datenaustausch benutzt. Zum Programmstart enthält es
die Parameter, mit denen das Programm aufgerufen wird.
h)
i)
Geben Sie den Inhalt des Poolsegments für das Programm ls an, das mit dem
Parameter -la aufgerufen wird (Aufruf: ls -la).
0x4000000000000000
0x4000000000000030
0x4000000000000008
0x4000000000000020
0x4000000000000010
0x4000000000000028
0x4000000000000018
0x0000000000000000
0x4000000000000020
0x6C73000000000000
0x4000000000000028
0x2D6C610000000000
0x4000000000000030
0x0000000000000000
0x4000000000000038
0x0000000000000000
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?
Nein, die Programme überschreiben sich Ihre Daten nicht gegenseitig, da es sich
um virtuellen Speicher handelt. Die einzelnen Programme verwenden zwar die
selben Adressen, das Betriebssystem leitet die Zugriffe jedoch auf verschiedene
reale Speicheradressen weiter.
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
Octa
Tetra
Wyde
Byte
X
X
X
X
0x00
X
0x00
X
0x00
X
0x00
X
0x00
X
0x00
X
0x00
X
0x00
X
0x00
0x2000000000000001
0x2000000000000002
X
0x2000000000000003
0x2000000000000004
X
X
0x2000000000000005
0x2000000000000006
X
0x2000000000000007
0x2000000000000008
X
X
X
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?
Die Abspeicherung von Daten als Big- oder Little-Endian betrifft nur die Abspeicherung von Worten, die ein vielfaches (> 1, d.h. 2, 3, 4, ...) eines Bytes sind.
b) Verwendet der MMIX-Prozessor Big- oder Little-Endian?
Der MMIX verwendet Big-Endian.
c)
Was bedeutet Big- und Litle-Endian? Was ist der Unterschied?
Big- oder Little-Endian beschreibt zwei Möglichkeiten, Datenworte abzuspeichern,
die sich aus mehreren Bytes zusammensetzen.
• Bei Big-Endian wird das höherwertigere Byte adressiert,
• bei Little-Endian wird das niedrigere Byte Adressiert.
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-EndianMaschine?
• Big Endian: 0x12 liegt an Adresse 0x2000000000000000 und 0x34 an
Adresse 0x2000000000000001
• Little Endian: 0x34 liegt an Adresse 0x2000000000000000 und 0x12 an
Adresse 0x2000000000000001.
2.2 MMIX Architektur
33
Format von MMIX-Programmen
a)
Aus wievielen/welchen Spalten bestehen MMIX-Programme?
Vier: Marke, Befehl, Operanden, Kommentar.
b) Wie werden die Spalten im Programmcode getrennt?
Die Spalten werden durch ‘‘Whitespaces’’ getrennt, d.h. Leerzeichen und Tabulatoren.
c)
Wie muss man MMIX-Codezeilen schreiben, die keine Marke verwenden?
Man muss die Zeile mit einem ‘‘Whitespace’’ beginnen, d.h. entweder mit Leerzeichen oder mit Tabulatoren.
d) Wie kann man beim MMIX-Assembler eine komplette Zeile auskommentieren?
Wenn das erste Zeichen einer Zeile ein Sonderzeichen (z.B. ein Slash ‘/’, ein
Prozentzeichen ‘%’ etc.) ist, interpretiert der MMIX-Assembler die ganze Zeile als
Kommentar.
e)
Werden alle vier Spalten eines MMIX-Programms für den Übersetzungsvorgang
herangezogen? Gehen Sie auf die einzelnen Spalten ein.
Nein.
• Die vierte Spalte (Kommentare) wird komplett ignoriert.
• Die erste Spalte (Marken) tragen nur insoweit zum Übersetzungsvorgang
bei, dass sie zur Berechnung von Adressen verwendet werden.
• Die einzigen Spalten, die tatsächlich in MMIX-Befehle übersetzt werden,
sind Spalten 2 und 3.
• Wenn Spalten 2 und 3 Loader-Befehle enthalten, werden diese nur
implizit verwendet, d.h. es wird anderer MMIX-Code generiert, der die
Loader-Anweisungen umsetzt.
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.
a
b
c
IS
IS
IS
$1
$2
$3
b) Geben einen Befehl an, der ein globales Register mit dem Namen GR reserviert
und mit 0 initialisiert.
GR
c)
GREG
0
Was ist der Loader?
Der Loader ist der Teil eines Betriebssystems, der Programme von einem Massenspeicher (HDD/SSD) in den Arbeitsspeicher lädt, bevor mit der Programmausführung begonnen wird.
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.
A
B
C
D
LOC
GREG
BYTE
BYTE
BYTE
BYTE
#2000000000000000
@
1
2
2.2 MMIX Architektur
e)
35
Mit welchen Befehlen können Sie Worte der Länge 16, 32 und 64 bit im Speicher
reservieren?
• 16 bit: WYDE
• 32 bit: TETRA
• 64 bit: OCTA
f)
Erklären Sie den Ausdruck ‘‘Alignment’’.
Der Begriff ‘‘Alignment’’ bedeutet ‘‘Ausrichtung’’. Gemeint ist die Ausrichtung von
Datenworten an bestimmten Adressen. Beim MMIX gilt folgendes:
• Ein Byte (8 Bit) kann an jeder Speicheradresse liegen.
• Ein Wyde (16 Bit) kann nur an einer durch 2 teilbaren Speicheradresse
liegen. Das letzte Adress-Bit muss hier also den Wert 0 haben.
• Ein Tetra (32 Bit) kann nur an einer durch 4 teilbaren Speicheradresse
liegen. Hier müssen die letzten beiden Adress-Bits den Wert 0 haben.
• Ein Octa (64 Bit) kann nur an einer durch 8 teilbaren Speicheradresse
liegen. Hier müssen die letzten drei Adress-Bits den Wert 0 haben.
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?
Das Alignment wird vom Prozessor automatisch durchgeführt, d.h. bei
• Wyde-Zugriffsbefehlen wird beim Speicherzugriff automatisch das letzte
Adress-Bit gelöscht,
• Tetra-Zugriffsbefehlen werden beim Speicherzugriff automatisch die letzten beiden Adress-Bits gelöscht und
• bei Octa-Zugriffsbefelhen werden beim Speicherzugriff automatisch die
letzten drei Adress-Bits gelöscht.
Betrachten Sie die folgenden Befehle:
X
Y
Z
h)
LOC
BYTE
WYDE
OCTA
#2000000000000000
Geben Sie die Adressen an, an denen X und Y im Speicher abgelegt werden.
• X: 0x2000000000000000
• Y: 0x2000000000000002 (höherwertigeres Byte) und 0x2000000000000003
(niederwertigeres Byte)
i)
An welchen Adressen wird Z abgelegt?
Z wird an den Adressen 0x200000000000008 bis 0x200000000000000F abgelegt.
2.2 MMIX Architektur
j)
37
Welche Eigenschaften muss eine Adresse haben, damit man an ihr ein Byte, Wyde,
Tetra bzw. Octa abspeichern kann?
• Byte: Alle Adressen geeignet
• Wyde: Adresse muss durch 2 teilbar sein (das letzte Adressbit muss 0
sein)
• Tetra: Adresse muss durch 4 teilbar sein (die letzten beiden Adressbits
müssen 0 sein)
• Octa: Adresse muss durch 8 teilbar sein (die letzten drei Adressbits
müssen 0 sein)
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.
N
ADR_A1
ADR_A2
LOC
GREG
Data_Segment
@
OCTA
OCTA
OCTA
OCTA
OCTA
OCTA
OCTA
OCTA
OCTA
4
1
2
3
4
10
20
30
40
38
2 Assemblerprogrammierung
MMIX Befehlsformat
a)
Wie breit (in Bit) ist das MMIX Befehlswort?
32 Bit
b) Skizzieren Sie das MMIX Befehlswort und geben Sie den Inhalt jedes Bytes an.
31
24 23
Opcode
c)
16 15
1. Operand = X
8 7
2. Operand = Y
0
3. Operand = Z
In welchen Byte des Befehlsworts wird im Allgemeinen Information über die
Quelloperanden bzw. über die Zieloperanden abgespeichert?
Ziel = X; Quelle = Y, Z.
d) Bei welchen Befehlen wird die Information über die Befehle anders abgespeichert?
Wie?
Befehle zum Speicher von Daten (Register ! Arbeitsspeicher) benützen X als
Quellregister und Y und Z zur Adressierung des Ziels.
e)
Warum verwenden diese Befehle X, Y und Z anders als die übrigen MMIX-Befehle?
Auf diese Weise wird die Hardware einfacher: Zur Adressierung eines Offsets
(Z/$Z) zum Basisregister (Y) kann so dasselbe Rechenwerk verwendet werden
wie zur Addition. Ebenso können die gleichen Verbindungsleitungen, die den
Registerblock mit dem Rechenwerk verbinden, verwendet werden.
f)
Was ist ein Direktoperand?
Ein Direktoperand ist ein Operand der direkt im Befehlswort steht.
Nachfolgende Abbildung zeigt die Codierung der MMIX-Opcodes sowie die zur Befehlsausführung benötigte Zeit.:
2.2 MMIX Architektur
!"#"$% &'()*+,-.%(*/%012'(*/%
!
&'(!)*+*,-(#.*-/!01234/*5!67*8434/*9!:;</!=*8>((!7'3,+4-=*7/*<!?'@*--*[email protected]*<(*BCBD!
!
0x..0
0x0..
0x1..
0x2..
0x3..
0x4..
0x5..
0x6..
0x7..
0x8..
0x9..
0xA..
0xB..
0xC..
0xD..
0xE..
0xF..
0x..1
TRAP 5ν
FCMP ν
FLOT[I] 4ν
FMUL 4ν
FCMPE 4ν
MUL[I] 10ν
ADD[I] ν
2ADDU[I] ν
CMP[I] ν
SL[I] ν
BN[B] ν+π
BNN[B] ν+π
PBN[B] 3ν-π
PBNN[B] 3ν-π
CSN[I] ν
CSNN[I] ν
ZSN[I] ν
ZSNN[I] ν
LDB[I] µ+ν
LDT[I] µ+ν
LDSF[I] µ+ν
LDVTS[I] ν
STB[I] µ+ν
STT[I] µ+ν
STSF[I] µ+ν
SYNCD[I] ν
OR[I] ν
AND[I] ν
BDIF[I] ν
MUX[I] ν
SETH ν
SETMH ν
ORH ν
ORMH ν
JMP[B] ν
POP 3ν
RESUME 5ν
0x..8
0x..9
0x..2
0x..3
0x..4
FUN ν
FEQL ν
FLOTU[I] 4ν
FUNE ν
FEQLE 4ν
MULU[I] 10ν
ADDU[I] ν
4ADDU[I] ν
CMPU[I] ν
SLU[I] ν
BZ[B] ν+π
BNZ[B] ν+π
PBZ[B] 3ν-π
PBNZ[B] 3ν-π
CSZ[I] ν
CSNZ[I] ν
ZSZ[I] ν
ZSNZ[I] ν
LDBU[I] µ+ν
LDTU[I] µ+ν
LDHT[I] µ+ν
PRELD[I] ν
STBU[I] µ+ν
STTU[I] µ+ν
STHT[I] µ+ν
PREST[I] ν
ORN[I] ν
ANDN[I] ν
WDIF[I] ν
SADD[I] ν
SETML ν
SETL ν
ORML ν
ORL ν
PUSHJ[B] ν
[UN]SAVE 20µ+ν
0x..A
0x..B
0x..5
0x..6
39
0x..7
FADD 4ν
FIX 4ν
FSUB 4ν
FIXU 4ν
SFLOT[I] 4ν
SFLOTU[I] 4ν
FDIV 40ν FSQRT 40ν FREM 4ν
FINT 4ν
DIV[I] 60ν
DIVU[I] 60ν
SUBU[I] ν
SUB[I] ν
8ADDU[I] ν
16ADDU[I] ν
NEG[I] ν
NEGU[I] ν
SR[I] ν
SRU[I]ν
BP[B] ν+π
BOD[B] ν+π
BNP[B] ν+π
BEV[B] ν+π
PBP[B] 3ν-π
PBOD[B] 3ν-π
PBNP[B] 3ν-π
PBEV[B] 3ν-π
CSP[I] ν
CSOD[I] ν
CSNP[I] ν
CSEV[I] ν
ZSP[I] ν
ZSOD[I] ν
ZSNP[I] ν
ZSEV[I] ν
LDW[I] µ+ν
LDWU[I] µ+ν
LDO[I] µ+ν
LDOU[I] µ+ν
CSWAP[I] 2µ+2ν
LDUNC[I] µ+ν
PREGO[I] ν
GO[I] 3ν
STW[I] µ+ν
STWU[I] µ+ν
STO[I] µ+ν
STOU[I] µ+ν
STCO[I] µ+ν
STUNC[I] µ+ν
SYNCID[I] ν
PUSHGO[I] 3ν
NOR[I] ν
XOR[I] ν
NAND[I] ν
NXOR[I] ν
TDIF[I] ν
ODIF[I] ν
MOR[I] ν
MXOR[I] ν
INCH ν
INCHM ν
INCML ν
INCL ν
ANDNH ν
ANDNMH ν ANDNML ν
ANDNL ν
GETA[B] ν
PUT[I] ν
SYNC ν
SWYM ν
GET ν
TRIP 5ν
0x..C
0x..D
0x..E
0x..F
0x0..
0x1..
0x2..
0x3..
0x4..
0x5..
0x6..
0x7..
0x8..
0x9..
0xA..
0xB..
0xC..
0xD..
0xE..
0xF..
!
!
!
&'(!*<(B*!E;@@-*!0F!);B#G*<B9!/*(!1234/*(!*7B(2<;3,B!/*<!&422*-C*;-*[email protected];(!IJ95!;7!/*<!(;3,!/*<!)*#
+*,-(34/*[email protected]*+;7/*BD!
!
g)! Was bedeutet ⌫?
&'(!C:*;B*!E;@@-*!/*(!1234/*(!*<=;@B!(;3,!:;*!+4-=BK!
!
⌫ bedeutet 1 Takt. Steht bei einem Befehl ⌫, so braucht dieser Befehl 1 Takt
−! 6L)!0);B!E<D!"9!/*(!C:*;B*7!E;@@-*(!
zur+Ausführung.
Steht bei einem Befehl 4⌫, so !"#$"
braucht
dieser Befehl 4 Takte zur
! H5!:*77!(;3,!/*<!)*+*,-!;[email protected]*<*7!?*;-!/*<!&422*[email protected]*+;7/*B!
+
!
I5!:*77!(;3,!/*<!)*+*,-!;8!M7B*<*7!?*;-!/*<!&422*!"#$"
[email protected]*+;7/*B!!
Ausführung.
!
−! );B(!$5!I!M7/!H!/*(!C:*;B*7!E;@@-*(!*7B(2<*3,*7!/*<! %&'$("[email protected];(!%95!;7!/*8!(;3,!/*<!)*+*,-(#
34/*[email protected]*+;7/*B!
!
[email protected]*/*MB*BK!N88*/;'B*#O'<;'7B*!/*(!)*+*,-(!
h)[I]Was
bedeutet ⇡?
−! ;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*<!
bedeutet
−! /*<! 1234/*! /*<! ;88*/;'B*#O'<;'7B*! *;7*(! )*+*,-(! ;(B! ;88*<! M8! I! ,S,*<! '-(! /;*! 7;3,B#
;88*/;'B*#O'<;'7B*!/*(!)*+*,-(!0(B*,B!;7!/*<!&422*• 2 ⌫ = 2 Takte, falls gesprungen wird, und )&'$("!'-(4!<*3,B(9!
−! *;7*! ;88*/;'B*#O'<;'7B*! /*(! )*+*,-(!:;</! T48! U((*[email protected]*<!'MB48'B;(3,! '7,'7/! /*(! +*,-*7/*7!
• 0 ⌫ = 0 Takte, falls nicht gesprungen wird.
&4--'<#R*;3,*7(! 0$9! *<P'77B5! :*(,'[email protected]! ;8! V<4=<'88! 7;3,B! *W2-;C;B! ADDI! =*(3,<;*@*7! :*</*7!
8M((!!!
!
"#$%
40
i)
2 Assemblerprogrammierung
Wieviele Takte benötigt der BZ-Befehl, wenn gesprungen wird?
⌫ + ⇡ = ⌫ + 2⌫ = 3⌫ ) 3 Takte
j)
Wieviele Takte benötigt der BZ-Befehl, wenn nicht gesprungen wird?
⌫ + ⇡ = ⌫ + 0⌫ = 1⌫ ) 1 Takt
k)
Wieviele Takte benötigt der PBZ-Befehl, wenn gesprungen wird?
3⌫
l)
⇡ = 3⌫
2⌫ = 1⌫ ) 1 Takt
Wieviele Takte benötigt der PBZ-Befehl, wenn nicht gesprungen wird?
3⌫
⇡ = 3⌫
0⌫ = 3⌫ ) 3 Takte
m) Was bedeutet µ?
µ entspricht der Anzahl der Takte, die für einen Speicherzugriff benötigt werden.
2.2 MMIX Architektur
n)
Wie kann man mit dieser Tabelle einen MMIX-Opcode ermitteln?
• Befehl suchen
• Doppelzeile ermitteln, in der der Befehl steht
• An der Seite der Tabelle das obere Nibble (= die oberen 4 Bits) des
Opcodes ablesen, z.B. ADD ) 0x2
• Prüfen, ob der Befehl im oberen oder im unteren Teil der Doppelzeile
steht
• Steht der Befehl im oberen Teil der Doppelzeile, kann man das
untere Nibble (= die unteren 4 Bits) des Opcodes an der ersten
Tabellenzeile ablesen, z.B. ADD ) 0x..0 oder 0x..1
• Steht der Befehl im unteren Teil der Doppelzeile, kann man das
untere NIbble (=die unteren 4 Bits) des Opcodes an der untersten
Tabellenzeile ablesen, z.B. 2ADDU ) 0x..8 oder 0x..9
• Anschließend muss nur noch unterschieden werden, ob es sich um die
linke oder die rechte Variante des Befehls handelt, beispielsweise ob
man in der oberen Zeile 0x..0 oder 0x..1 auswählen muss oder ob man
in der unteren Zeile 0x..8 oder 0x..9 auswählen muss. Dazu wird der in
der Tabelle nach dem Befehlsnamen in Klammern stehende Buchstabe
verwendet;
• I bedeutet immediate, d.h. Direktoperand; Beispiel: Bei ADD
$1,$2,$3 wird ADD mit 0x20 codiert, bei ADD $1,$2,3 mit 0x21
• B bedeutet backward, d.h. Rückwärtssprung; erhöht sich bei
einem Sprung die Adresse, wird der linke Zahlenwert verwendet
(Vorwärtssprung); verringert sich bei einem Sprung die Adresse,
wird der rechte Zahlenwert verwendet (Rückwertssprung)
41
42
2 Assemblerprogrammierung
o) Geben Sie das 32 Bit breite Befehlswort des Befehls ‘‘SL $1,$2,3’’ an.
0x39010203
p) Welcher Befehl benötigt die längste Zeit zur Ausführung, wenn man von Speicherbefehlen absieht?
Der Befehl DIV (Division von Festkommazahlen).
q) Wieviele Taktzyklen benötigen die meisten Befehlen zur Ausführung?
Die meisten Befehle können innerhalb von 1 ⌫, d.h. innerhalb eines Taktes ausgeführt werden.
r)
Was ist der Opcode des JMP-Befehls beim Vorwärts- bzw. beim Rückwärtssprung?
Vorwärts: 0xF0; Rückwärts: 0xF1.
Betrachten Sie die folgenden Befehle:
A
LOC
GREG
OCTA
Data_Segment
@
1000
a
b
IS
IS
$1
$2
LOC
LDB
SUB
OR
BZ
JMP
TRAP
#100
a,A
a,a,1
a,a,0
a,End
Start
0,0,0
Main
Start
s)
Bestimmen Sie das 32 Bit breite Befehlswort des Befehls ‘‘JMP Start’’.
0xF1FFFFFD. (3 Befehle zurückspringen; FFFD ist -3 im 2er-Komplement)
2.3 MMIX Befehle
43
2.3 MMIX Befehle
Definitionen
Wort
w b ist ein Wort der Länge b Byte. wxb repräsentiert Bit Nr. x im Datenwort w b , wobei das
b
niederwertigste Bit in w b an Bitposition x = 0 liegt. wx...y
meint Bits x...y des Datenworts
b
w .
Befehlswort
Sei ◆ ein 32 Bit breites MMIX Befehlswort.
•
•
•
•
•
•
X = ◆23...16
Y = ◆15...8
Z = ◆7...0
YZ = ◆15...0
XY = ◆23...8
XYZ = ◆23...0
Allzweckregister
• Der MMIX-Prozessor verfügt über 256 Allzweckregister, die mit 0, 1, ... 255
durchnummeriert werden.
• Zur Adressierung eines Allzweckregisters im Befehlswort wird die als vorzeichenlose 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 adressierten Register gespeichert ist.
44
2 Assemblerprogrammierung
Spezialregister
Spezialregister werden im Befehlswort wie folgt codiert:
rB:
rD:
rE:
rH:
rJ:
rM:
rR:
rBB:
0x00
0x01
0x02
0x03
0x04
0x05
0x06
0x07
rC:
rN:
rO:
rS:
rI:
rT:
rTT:
rK:
0x08
0x09
0x0A
0x0B
0x0C
0x0D
0x0E
0x0F
rQ:
rU:
rV:
rG:
rL:
rA:
rF:
rP:
0x10
0x11
0x12
0x13
0x14
0x15
0x16
0x17
rW:
rX:
rY:
rZ:
rWW:
rXX:
rYY:
rZZ:
0x18
0x19
0x1A
0x1B
0x1C
0x1D
0x1E
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
Operationen
•
•
•
•
•
•
•
•
•
•
•
•
•
x
y : Weise x den Wert y zu
x , y : Ausdruck x ist äquivalent zum Ausdruck y
x ) y : Wenn x, dann y
x||y : Logische operation x ODER y
x = y : Vergleich ob x den gleichen Wert hat wie y ; liefert wahr (d.h. 1), wenn x
den selben Wert hat wie y , sonst falsch (d.h. 0)
x ⌧ y : Schiebe x um y Stellen nach links; fülle frei werdende Bitstellen mit 0
auf
x u y : Schiebe x um y Bitstellen nach rechts; fülle frei werdende Bitstellen
mit 0 auf
x s y : Schiebe x um y Bitstellen nach rechts; fülle frei werdende Bitstellen mit
dem Wert des Vorzeichenbits (MSB) auf.
x % y : Rest der Festkomma-Division x/y .
⇠ x: Invertiere alle Bits von x, d.h. berechne das 1er-Komplement
x & y : Bitweise UND-Verknüpfung von x und y
x | y : Bitweise ODER-Verknüpfung von x und y
x ⌦ y : Bitweise XOR-Verknüpfung von x und y
Umwandlung Festkommazahl $ Gleitkommazahl
• f32 (w 4 ): Nimmt an, dass das vier Byte breite Datenwort w 4 im 32 Bit IEEE 754
Gleitkommaformat codiert ist und gibt den entsprechenden Zahlenwert zurück
(z.B. 1,75).
0 (x): Codiert die Zahl x als 32 Bit breite Gleitkommazahl und gibt das
• f32
entsprechende 32 Bit breite Bitmuster zurück.
• f64 (w 8 ): Nimmt an, dass das acht Byte breite Datenwort w 8 im 64 Bit IEEE 754
Gleitkommaformat codiert ist und gibt den entsprechenden Zahlenwert zurück
(z.B. 1,75).
0 (x): Codiert die Zahl x als 64 Bit breite Gleitkommazahl und gibt das
• f64
entsprechende 64 Bit breite Bitmuster zurück.
• r (x): Rundet eine reelle Zahl gemäß dem in Register rA ausgewählten Rundungsmodus auf eine ganze Zahl.
45
46
2 Assemblerprogrammierung
(De-) Codierung von Festkommazahlen
• s(w b ): Nimmt an, dass das b Byte breite Wort w b im 2er-Komplement codiert
ist und gibt den entsprechenden Wert zurück (z.B. 1, 0, -3)
• u(w b ): Nimmt an, dass das b Byte breite Wort w b als vorzeichenlose Festkommazahl codiert ist und gibt den entsprechenden Wert zurück (z.B. 0, 1)
• sb0 (x): Gibt das b Bit breite im 2er-Komplement codiert Bitmuster zurück das
dem Wert x entspricht.
• ub0 (x): Gibt das b Bit breite Bitmuster (vorzeichenlose Codierung) zurück das
dem Wert x, x 0, entspricht.
Zusammenfassen von in Registern gespeicherten Werten
Wenn $X das 64 Bit breite in Register X gespeicherte Bitmuster ist und $Y das 64 Bit breite
in Register Y gespeicherte Bitmuster ist, dann ist $X$Y das 128 Bit breite Bitmuster das
aus der Aneinanderreihung der beiden Bitmuster $X und $Y entsteht. ($X$Y)127...64 = $X
und ($X$Y)63...0 = $Y.
Programm beenden
• TRAP 0,Halt,0 beendet ein MMIX-Programm und gibt die Kontrolle zurück an
das Betriebssystem.
2.3 MMIX Befehle
47
Lade- und Speicherbefehle
Daten vom Speicher in ein Register laden
Befehl Operanden Name/Aktion
Definition
0 (s(M [u($Y) + u($Z)]))
s64
1
0
s64 (s(M1 [u($Y) + u(Z)]))
LDB
$X,$Y,$Z
$X,$Y,Z
Load byte
Load byte immediate
$X
$X
LDBU
$X,$Y,$Z
$X,$Y,Z
Load byte unsigned
Load byte uns. immed.
$X
$X
LDW
$X,$Y,$Z
$X,$Y,Z
Load wyde
Load wyde immediate
$X
$X
LDWU
$X,$Y,$Z
$X,$Y,Z
Load wyde unsigned
Load wyde uns. immed.
$X
$X
LDT
$X,$Y,$Z
$X,$Y,Z
Load tetra
Load tetra immediate
$X
$X
LDTU
$X,$Y,$Z
$X,$Y,Z
Load tetra unsigned
Load tetra uns. immed.
$X
$X
LDO
$X,$Y,$Z
$X,$Y,Z
Load octa
Load octa immediate
$X
$X
M8 [u($Y) + u($Z)]
M8 [u($Y) + u(Z)]
LDOU
$X,$Y,$Z
$X,$Y,Z
Load octa unsigned
Load octa uns. immed.
$X
$X
M8 [u($Y) + u($Z)]
M8 [u($Y) + u(Z)]
0 (u(M [u($Y) + u($Z)]))
u64
1
0
u64 (u(M1 [u($Y) + u(Z)]))
0 (s(M [u($Y) + u($Z)]))
s64
2
0
s64 (s(M2 [u($Y) + u(Z)]))
0 (u(M [u($Y) + u($Z)]))
u64
2
0
u64 (u(M2 [u($Y) + u(Z)]))
0 (s(M [u($Y) + u($Z)]))
s64
4
0
s64 (s(M4 [u($Y) + u(Z)]))
0 (u(M [u($Y) + u($Z)]))
u64
4
0
u64 (u(M4 [u($Y) + u(Z)]))
48
a)
2 Assemblerprogrammierung
Welche Wortgrößen kann der MMIX vom Speicher in Register laden?
Die MMIX-Ladebefehle unterstützen Wortbreiten von 8, 16, 32 und 64 Bit.
b) Was ist der Unterschied zwischen vorzeichenbehaftetem (signed) und vorzeichenlosen (unsigned) Laden?
• Vorzeichenbehaftet: Wenn die Breite des zu ladenden Datenwort kleiner
ist als die Registerwortbreite (d.h. 8, 16 oder 32 Bit breites Datenwort in
64 Bit breites Register laden), werden die oberen Bits des Registers mit
dem MSB (Most Significant Bit) des zu ladenden Wortes aufgefüllt.
• Vorzeichenlos: Wenn die Breite des zu ladenden Datenworts kleiner ist
als die Registerwortbreite, werden die oberen Bits des Registers mit 0
aufgefüllt.
c)
Warum muss man zwischen vorzeichenlosem und vorzeichenbehaftetem Laden
unterscheiden?
Vor vorzeichenlosen Zahlen hat man implizit unendlich viele 0-er stehen, vor
vorzeichenbehafteten Zahlen entweder unendlich viele 0-er (positive Zahl) oder
unendlich viele 1-er (negative Zahl). Wenn man vor eine vorzeichenbehaftete,
negative Zahl 0-er schreibt (was bei den vorzeichenlosen Ladebefehlen der Fall
wäre) würde aus der negativen Zahl plötzlich eine andere (falsche) positive Zahl
werden (! Fehler).
d) Wie unterscheiden sich die Namen der vorzeichenlosen und vorzeichenbehafteten
Ladebefehle?
Bei vorzeichenlosen Ladebefehlen wird ein zusätzliches U an den Namen angefügt.
2.3 MMIX Befehle
e)
49
Wie unterscheiden sich die Opcodes von vorzeichenlosen und vorzeichenbehafteten Ladebefehlen?
Opcode vorzeichenlos = Opcode vorzeichenbehaftet + 2
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.
64 als positive Festkommazahl: 0100 0000
1er-Komplement: 1011 1111
2er-Komplement: 1100 0000
Hexadezimal: 0xC0
Auf 64 Bit aufgefüllt: 0xFFFFFFFFFFFFFFC0
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.
0xC0 = 128 + 64 = 192
h)
Wie können die Ladebefehle 64 Bit breite Speicheradressen adressieren, obwohl
im Befehlswort nur 16 Bit zur Darstellung der Adresse verfügbar sind?
Von den 16 Bit (Y und Z) werden 8 Bit (Y) verwendet um ein Allzweckregister zu
adressieren, das eine 64 Bit breite Basisadresse enthält. Mit den anderen 8 Bit (Z)
wird der Offset bestimmt, der zur Basisadresse hinzuaddiert wird. Abhängig vom
Opcode des Ladebefehls ist dieser Offset entweder
• der Wert eines Allzweckregisters, das mit Z adressiert wird, oder
• der Direktoperand u(Z).
50
i)
2 Assemblerprogrammierung
Zeichnen Sie in die nachfolgende Darstellung ein, wie die 64 Bit breite Adresse
generiert wird.
Spezial-
Register
Allzweck-
Register
Speicher
Laden
64 Bit
Quell-/Ziel-Register
8, 16, 32, 64 Bit
Basis-Adress-Register
OP
X
Y
Z
Offset
32 Bit Befehlswort
8, 16, 24 Bit
64 Bit
Rechen-
werk (ALU)
j)
Adresse
Vervollständigen Sie den nachfolgenden MMIX-Code um die Bereitstellung und
Initialisierung eines Basisregisters zur Adressierung von A, B und C.
A
B
C
Main
k)
Speichern
64 Bit
LOC
#2000000000000000
GREG
@
BYTE
OCTA
OCTA
0
#FFFF
LOC
#100
LDO
...
$0,B
In welches Befehlswort übersetzt der MMIX-Assembler den Befehl LDO $0,B?
0x8D00FE08.
2.3 MMIX Befehle
l)
51
Tragen Sie in nachfolgende Tabelle den Speicherinhalt ein, der sich nach Ausführung der angegebenen MMIX-Befehle im Falle von Big- und Little-EndianAdressierung ergibt.
LOC
GREG
BYTE
TETRA
TETRA
BYTE
WYDE
Adresse
Data_Segment
@
1
#23456789
#ABCDEF01
#77
#0123
Niederwert. vier Adress-Bits
Big Endian
Little Endian
0x2000000000000000
0000
0x01
0x01
0x2000000000000001
0001
?
?
0x2000000000000002
0010
?
?
0x2000000000000003
0011
?
?
0x2000000000000004
0100
0x23
0x89
0x2000000000000005
0101
0x45
0x67
0x2000000000000006
0110
0x67
0x45
0x2000000000000007
0111
0x89
0x23
0x2000000000000008
1000
0xAB
0x01
0x2000000000000009
1001
0xCD
0xEF
0x200000000000000A
1010
0xEF
0xCD
0x200000000000000B
1011
0x01
0xAB
0x200000000000000C
1100
0x77
0x77
0x200000000000000D
1101
?
?
0x200000000000000E
1110
0x01
0x23
0x200000000000000F
1111
0x23
0x01
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:
n)
LDB $0,$254,0:
0x0000 0000 0000 0001
LDB $0,$254,4:
0x0000 0000 0000 0023
LDB $0,$254,9:
0xFFFF FFFF FFFF FFCD
LDBU $0,$254,9:
0x0000 0000 0000 00CD
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,4:
0x0000 0000 2345 6789
LDT $0,$254,5:
0x0000 0000 2345 6789
LDT $0,$254,9:
0xFFFF FFFF ABCD EF01
LDTU $0,$254,9:
0x0000 0000 ABCD EF01
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:
0x01?? ???? 2345 6789
LDO $0,$254,1:
0x01?? ???? 2345 6789
LDO $0,$254,12:
0xABCD EF01 77?? 0123
2.3 MMIX Befehle
53
Adressen in ein Register laden
Befehl Operanden Name/Aktion
Definition
LDA
$X,$Y,$Z
$X,$Y,Z
Get address (absolute)
Get address immed. (absolute)
GETA
$X,YZ
Get address (relativ)
a)
$X
$X
$X
0 (u($Y) + u($Z))
u64
0 (u($Y) + u(Z))
u64
0 (u(@) + 4 · s(YZ))
u64
Was ist der Unterschied zwischen dem Befehl LDA und den Ladebefehlen LDB, ... ?
Die Ladebefehle LDB, ... laden Datenworte vom Speicher in ein Register. Der Befehl
LDA lädt eine Adresse in ein Register.
Nehmen Sie die folgenden Befehle an:
A
Main
LOC
GREG
BYTE
Data_Segment
@
#12
LOC
LDA
TRAP
#100
$0,A
0,Halt,0
$254
@
b) In welches hexadezimale Befehlswort wird der Befehl LDA $0,A übersetzt? Warum?
0x2300FE00. Der Assembler löst die Marke A in $254 + 0 auf und ersetzt den
Befehl LDA $0,A durch ADDUI $0,$254,0. Der Befehl ADDUI addiert den Wert im
Basisregister 254 und den Offset 0 und speichert das Ergebnis in Register 0. Damit
enthält Register 0 dann die Adresse der Marke A.
c)
In welches hexadezimale Befehlswort sollte der Befehl LDA $0,Main übersetzt
werden?
0x2300FF00
54
2 Assemblerprogrammierung
!"#"$% &'()*+,-.%(*/%012'(*/%
!
&'(!)*+*,-(#.*-/!01234/*5!67*8434/*9!:;</!=*8>((!7'3,+4-=*7/*<!?'@*--*[email protected]*<(*BCBD!
!
0x..0
0x0..
0x1..
0x2..
0x3..
0x4..
0x5..
0x6..
0x7..
0x8..
0x9..
0xA..
0xB..
0xC..
0xD..
0xE..
0xF..
0x..1
TRAP 5ν
FCMP ν
FLOT[I] 4ν
FMUL 4ν
FCMPE 4ν
MUL[I] 10ν
ADD[I] ν
2ADDU[I] ν
CMP[I] ν
SL[I] ν
BN[B] ν+π
BNN[B] ν+π
PBN[B] 3ν-π
PBNN[B] 3ν-π
CSN[I] ν
CSNN[I] ν
ZSN[I] ν
ZSNN[I] ν
LDB[I] µ+ν
LDT[I] µ+ν
LDSF[I] µ+ν
LDVTS[I] ν
STB[I] µ+ν
STT[I] µ+ν
STSF[I] µ+ν
SYNCD[I] ν
OR[I] ν
AND[I] ν
BDIF[I] ν
MUX[I] ν
SETH ν
SETMH ν
ORH ν
ORMH ν
JMP[B] ν
POP 3ν
RESUME 5ν
0x..8
0x..9
0x..2
0x..3
0x..4
FUN ν
FEQL ν
FLOTU[I] 4ν
FUNE ν
FEQLE 4ν
MULU[I] 10ν
ADDU[I] ν
4ADDU[I] ν
CMPU[I] ν
SLU[I] ν
BZ[B] ν+π
BNZ[B] ν+π
PBZ[B] 3ν-π
PBNZ[B] 3ν-π
CSZ[I] ν
CSNZ[I] ν
ZSZ[I] ν
ZSNZ[I] ν
LDBU[I] µ+ν
LDTU[I] µ+ν
LDHT[I] µ+ν
PRELD[I] ν
STBU[I] µ+ν
STTU[I] µ+ν
STHT[I] µ+ν
PREST[I] ν
ORN[I] ν
ANDN[I] ν
WDIF[I] ν
SADD[I] ν
SETML ν
SETL ν
ORML ν
ORL ν
PUSHJ[B] ν
[UN]SAVE 20µ+ν
0x..A
0x..B
0x..5
0x..6
0x..7
FADD 4ν
FIX 4ν
FSUB 4ν
FIXU 4ν
SFLOT[I] 4ν
SFLOTU[I] 4ν
FDIV 40ν FSQRT 40ν FREM 4ν
FINT 4ν
DIV[I] 60ν
DIVU[I] 60ν
SUBU[I] ν
SUB[I] ν
8ADDU[I] ν
16ADDU[I] ν
NEG[I] ν
NEGU[I] ν
SR[I] ν
SRU[I]ν
BP[B] ν+π
BOD[B] ν+π
BNP[B] ν+π
BEV[B] ν+π
PBP[B] 3ν-π
PBOD[B] 3ν-π
PBNP[B] 3ν-π
PBEV[B] 3ν-π
CSP[I] ν
CSOD[I] ν
CSNP[I] ν
CSEV[I] ν
ZSP[I] ν
ZSOD[I] ν
ZSNP[I] ν
ZSEV[I] ν
LDW[I] µ+ν
LDWU[I] µ+ν
LDO[I] µ+ν
LDOU[I] µ+ν
CSWAP[I] 2µ+2ν
LDUNC[I] µ+ν
PREGO[I] ν
GO[I] 3ν
STW[I] µ+ν
STWU[I] µ+ν
STO[I] µ+ν
STOU[I] µ+ν
STCO[I] µ+ν
STUNC[I] µ+ν
SYNCID[I] ν
PUSHGO[I] 3ν
NOR[I] ν
XOR[I] ν
NAND[I] ν
NXOR[I] ν
TDIF[I] ν
ODIF[I] ν
MOR[I] ν
MXOR[I] ν
INCH ν
INCHM ν
INCML ν
INCL ν
ANDNH ν
ANDNMH ν ANDNML ν
ANDNL ν
GETA[B] ν
PUT[I] ν
SYNC ν
SWYM ν
GET ν
TRIP 5ν
0x..C
0x..D
0x..E
0x..F
0x0..
0x1..
0x2..
0x3..
0x4..
0x5..
0x6..
0x7..
0x8..
0x9..
0xA..
0xB..
0xC..
0xD..
0xE..
0xF..
!
!
!
&'(!*<(B*!E;@@-*!0F!);B#G*<B9!/*(!1234/*(!*7B(2<;3,B!/*<!&422*-C*;-*[email protected];(!IJ95!;7!/*<!(;3,!/*<!)*#
+*,-(34/*[email protected]*+;7/*BD!
Gegeben
sind die folgenden Befehle:
!
!
&'(!C:*;B*!E;@@-*!/*(!1234/*(!*<=;@B!(;3,!:;*!+4-=BK!
LOC
Data_Segment
!
GREG
@
−! 6L)!0);B!E<D!"9!/*(!C:*;B*7!E;@@-*(!
!"#$"[email protected]*+;7/*B!
A+! H5!:*77!(;3,!/*<!)*+*,-!;[email protected]*<*7!?*;-!/*<!&422*BYTE
#12
+! I5!:*77!(;3,!/*<!)*+*,-!;8!M7B*<*7!?*;-!/*<!&422*-!"#$"[email protected]*+;7/*B!!
!
LOC
#100
−! );B(!$5!I!M7/!H!/*(!C:*;B*7!E;@@-*(!*7B(2<*3,*7!/*<!
%&'$("[email protected];(!%95!;7!/*8!(;3,!/*<!)*+*,-(#
34/*[email protected]*+;7/*B!
Main
LDA
$0,A
!
GETA
$0,Main
[I][email protected]*/*MB*BK!N88*/;'B*#O'<;'7B*!/*(!)*+*,-(!
−! ;88*/;'B*!⇔!&;<*PB42*<'7/!
TRAP
0,Halt,0
−! 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#
d) In
welches 32 Bit breite Befehlswort wird der Befehl GETA $0,Main übersetzt?
;88*/;'B*#O'<;'7B*!/*(!)*+*,-(!0(B*,B!;7!/*<!&422*-)&'$("!'-(4!<*3,B(9!
−! *;7*! ;88*/;'B*#O'<;'7B*! /*(! )*+*,-(!:;</! T48! U((*[email protected]*<!'MB48'B;(3,! '7,'7/! /*(! +*,-*7/*7!
&4--'<#R*;3,*7(! 0$9! *<P'77B5! :*(,'[email protected]! ;8! V<4=<'88! 7;3,B! *W2-;C;B! ADDI! =*(3,<;*@*7! :*</*7!
0xF500FFFF
8M((!!!
!
"#$%
2.3 MMIX Befehle
55
Daten vom Register in den Speicher schreiben (speichern)
Befehl Operanden Name/Aktion
$X,$Y,$Z
Store byte; with overflow
$X,$Y,Z
Store byte immed.; ovf.
$X,$Y,$Z
$X,$Y,Z
Store byte unsigned
Store byte uns. imm.
STB
STBU
$X,$Y,$Z
Store wyde; with overflow
$X,$Y,Z
Store wyde immed.; ovf.
$X,$Y,$Z
$X,$Y,Z
Store wyde unsigned
Store wyde uns. imm.
STW
STWU
Definition
M1 [u($Y) + u($Z)]
($X)7...0
7
0 (26 )
s($X) 2 ) rA
rA | u64
0 (26 )
s($X) < 27 ) rA
rA | u64
M1 [u($Y) + u(Z)]
($X)7...0
7
0 (26 )
s($X) 2 ) rA
rA | u64
0 (26 )
s($X) < 27 ) rA
rA | u64
M1 [u($Y) + u(Z)]
M1 [u($Y) + u(Z)]
($X)7...0
($X)7...0
M2 [u($Y) + u(Z)]
s($X) 215 ) rA
s($X) < 215 ) rA
M2 [u($Y) + u(Z)]
s($X) 215 ) rA
s($X) < 215 ) rA
($X)15...0
0 (26 )
rA | u64
0 (26 )
rA | u64
($X)15...0
0 (26 )
rA | u64
0 (26 )
rA | u64
M2 [u($Y) + u(Z)]
M2 [u($Y) + u(Z)]
($X)15...0
($X)15...0
M4 [u($Y) + u(Z)]
s($X) 231 ) rA
s($X) < 231 ) rA
M4 [u($Y) + u(Z)]
s($X) 231 ) rA
s($X) < 231 ) rA
($X)31...0
0 (26 )
rA | u64
0 (26 )
rA | u64
($X)31...0
0 (26 )
rA | u64
0 (26 )
rA | u64
M4 [u($Y) + u(Z)]
M4 [u($Y) + u(Z)]
($X)31...0
($X)31...0
$X,$Y,$Z
Store tetra; with overflow
$X,$Y,Z
Store tetra immed.; ovf.
STTU
$X,$Y,$Z
$X,$Y,Z
Store byte unsigned
Store byte uns. imm.
STO
$X,$Y,$Z
$X,$Y,Z
Store octa
Store octa immediate
M8 [u($Y) + u(Z)]
M8 [u($Y) + u(Z)]
$X
$X
STOU
$X,$Y,$Z
$X,$Y,Z
Store octa unsigned
Store octa uns. imm.
M8 [u($Y) + u(Z)]
M8 [u($Y) + u(Z)]
$X
$X
STT
56
a)
2 Assemblerprogrammierung
Wie unterscheidet sich die Verwendung von X, Y und Z bei Speicher-Befehle von
derjenigen aller anderen MMIX-Befehle?
Die Speicher-Befehle des MMIX verwenden Y und Z als Ziel und X als Quelle. Alle
anderen MMIX-Befehle verwenden Y und Z als Quelle und X als Ziel.
b) Was ist beim MMIX der Unterschied zwischen vorzeichenbehaftetem und vorzeichenlosem Speichern?
• Die vorzeichenbehafteten Speicherbefehle zeigen einen FestkommaÜberlauf an, wenn die abgespeicherten Werte
• bei STB kleiner als -128 oder größer als 127,
• bei STW kleiner als -32.768 oder größer als 32.767,
• bei STT kleiner als 2,147,483,648 oder größer als 2,147,483,647
sind.
• Die vorzeichenlosen Speicherbefehle erzeugen keinen Überlauf.
• STO und STOU sind äquivalent.
In folgendem Programmcode wird XXX XXXXXXXX als Platzhalter für einen einzelnen
Befehl verwendet:
A
B
Main
LOC
GREG
OCTA
TETRA
Data_Segment
@
#FFFF FFFF FFFF FFFF
#8765 4321
LOC
LDTU
XXX
TRAP
#100
$0,B
XXXXXXXX
0,Halt,0
2.3 MMIX Befehle
c)
57
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:
0x21FF FFFF FFFF FFFF
STW $0,A:
0x4321 FFFF FFFF FFFF
STWU $0,A:
0x4321 FFFF FFFF FFFF
STT $0,A:
0x8765 4321 FFFF FFFF
STTU $0,A:
0x8765 4321 FFFF FFFF
STO $0,A:
0x0000 0000 8765 4321
STB $0,$254,5:
0xFFFF FFFF FF21 FFFF
STW $0,$254,1:
0x4321 FFFF FFFF FFFF
STT $0,$254,6:
0xFFFF FFFF 8765 4321
ST0 $0,$254,5:
0x0000 0000 8765 4321
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.
0xA300FE00.
58
e)
2 Assemblerprogrammierung
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.
Data
Main
LOC
GREG
OCTA
Data_Segement
@
#1234 5678
LOC
LDO
STB
LDA
STB
STT
#100
$1,Data
$1,Data
$2,Data
$1,$2,2
$1,$2,#A
2.3 MMIX Befehle
59
Gegeben ist der folgende Programmcode:
Label
Main
f)
LOC
GREG
OCTA
Data_Segement
@
#1234 5678
LOC
LDO
STB
LDA
STB
STT
#100
$0,Label
$0,Label
$2,Label
$0,$2,2
$0,$2,10
Zeichnen Sie byteweise den Inhalt des Speichers von Adresse 0x20 ... 00 bis
0x20 ... 00F, der sich nach Ausführung des o.g. Programms ergibt.
0x2000 0000 0000 0000
0x2000 0000 0000 0001
0x2000 0000 0000 0002
0x2000 0000 0000 0003
0x2000 0000 0000 0004
0x2000 0000 0000 0005
0x2000 0000 0000 0006
0x2000 0000 0000 0007
0x2000 0000 0000 0008
0x2000 0000 0000 0009
0x2000 0000 0000 000A
0x2000 0000 0000 000B
0x2000 0000 0000 000C
0x2000 0000 0000 000D
0x2000 0000 0000 000E
0x2000 0000 0000 000F
$0:
0000 0000 1234 5678
$2:
2000 0000 0000 0000
0x78
0x00
0x78
0x00
0x12
0x34
0x56
0x78
0x12
0x34
0x56
0x78
?
?
?
?
60
2 Assemblerprogrammierung
Direktoperand in Register schreiben
Befehl Operanden Name/Aktion
Definition
$X,YZ
Set to low wyde
SETML
$X,YZ
Set to med. low wyde
$X
0 (u(YZ ⌧ 16))
u64
SETMH
$X,YZ
Set to med. high wyde
$X
0 (u(YZ ⌧ 32))
u64
SETH
$X,YZ
Set to high wyde
INCL
$X,YZ
Increase by low wyde
INCML
$X,YZ
Inc. by med. low wyde
$X
0 (u($X) + u(YZ ⌧ 16))
u64
INCMH
$X,YZ
Inc. by med. high wyde
$X
0 (u($X) + u(YZ ⌧ 32))
u64
INCH
$X,YZ
Increase by high wyde
$X
0 (u($X) + u(YZ ⌧ 48))
u64
a)
$X
0 (u(YZ))
u64
SETL
$X
$X
0 (u((YZ ⌧ 48))
u64
0 (u($X) + u(YZ))
u64
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.
SETH
INCMH
INCML
INCL
$0,#123
$0,#4567
$0,#89AB
$0,#CDEF
2.3 MMIX Befehle
61
Gegeben ist der folgende Anfang eines Programms:
Pi32
Pi32t
LOC
GREG
TETRA
TETRA
Data_Segment
@
#40490FDB
⇡ als 32 Bit Gleitk.
⇡ als 32 Bit Gleitk.
b) Schreiben Sie ein MMIX-Programm, mit dem Sie die 32 Bit breite Gleitkommazahl ⇡
von Marke Pi32 in Register 0 einlesen, dann mit einem SETxx oder INCxx Befehl das
Vorzeichen der Gleitkommazahl ändern und ⇡ dann als 32 Bit Gleitkommazahl
an Marke Pi32t schreiben.
Main
LOC
LDTU
INCML
STTU
TRAP
#100
$0,Pi32
$0,#8000
$0,Pi32t
0,Halt,0
62
c)
2 Assemblerprogrammierung
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 werden. Anschließend soll Register 0 an Adresse 0x2000 0000 0000 0100 abgelegt
werden.
12,341 8,192 (= 213 ) = 4,149
4,149 4,096 (= 212 ) = 53
53 32 (= 25 ) = 21
21 16 (= 24 ) = 5
5 4 (= 21 ) = 1
1 1 (= 20 ) = 0
) 12,34110 = 110000001101012
0.3125 0.2500 (= 2 2 ) = 0.0625
0.0625 0.0625 (= 2 4 ) = 0
) 0.312510 = 0.01012
) 12,341.312510 = 11000000110101.01012
Normalization: 11000000110101.01012 ! 1.100000011010101012 · 213
10
Exponent: e 1,023 = 13 ) e = 1036 = 1024 + 8 + 4 = 100000011002
Floating point representation:
63
62
52
0
10000001100
51
0
1000000110101010100 ... 0
Hexadecimal representation: 0x40C81AA800000000
Result
Main
LOC
GREG
OCTA
#2000000000000100
@
LOC
SETH
INCMH
STO
TRAP
#100
$0,#40C8
$0,#1AA8
$0,Result
0,Halt,0
2.3 MMIX Befehle
63
Umwandlung Gleitkommazahl $ Festkommazahl
Befehl Operanden Name/Aktion
Definition
FLOT
$X,$Z
$X,Z
Convert fixed to floating
Conv. fixed to float. imm.
$X
$X
0 ( s($Z) )
f64
0 ( u(Z) )
f64
FLOTU
$X,$Z
$X,Z
Conv. uns. fixed to floating
Conv. uns. fixed to float.
imm.
$X
$X
0 ( u($Z) )
f64
0 ( u(Z) )
f64
FIX
$X,$Z
Convert floating to fixed
with overflow
FIXU
$X,$Z
Convert floating to fixed
without overflow
a)
0 ( r ( f ($Z) ) )
$X
s64
64
63
0 (25 )
f64 ($Z) < 2 ) rA
rA|u64
0 (25 )
f64 ($Z) > 263 1 ) rA
rA|u64
$X
0 ( r ( f ($Z) ) )
s64
64
Welche Aktion führt der Operator r () aus?
r () rundet eine Gleitkommazahl in eine Festkommazahl. Das Runden erfolgt wie in
Spezialregister rA eingestellt.
b) Geben Sie den Befehl an, mit dem Sie Register 0 die Gleitkommazahl 15,0
zuweisen.
FLOT
c)
$0,15
Geben Sie den Befehl an, mit dem Sie eine Gleitkommazahl in Register 1 in eine
Festkommazahl umwandeln.
FIX
$1,$1
64
2 Assemblerprogrammierung
Arithmetische Befehle
Arithmetische Befehle auf Festkommazahlen
BefehlOperanden
Name/Aktion
Definition
$X,$Y,$Z
Add; signed, with overflow
$X,$Y,Z
Add immediate; signed, with overflow
$X,$Y,$Z
$X,$Y,Z
Add unsigned; no overflow
Add unsigned; no overflow
ADD
ADDU
$X,$Y,$Z
Subtract; signed, with overflow
$X,$Y,Z
Subtract immediate; signed, with overflow
$X,$Y,$Z
$X,$Y,Z
Subtract unsigned; no overflow
Subtract unsigned immed.; no ovf.
SUB
SUBU
0 (s($Y) + s($Z))
$X
s64
(s($Y) + s($Z) < 263 ) ||
(s($Y) + s($Z) 263 ) )
0 (25 )
rA
rA|u64
0 (s($Y) + u(Z))
$X
s64
(s($Y) + s(Z) < 263 ) ||
(s($Y) + s(Z) 263 ) )
0 (25 )
rA
rA|u64
$X
$X
0 (u($Y) + u($Z))
u64
0 (u($Y) + u(Z))
u64
0 (s($Y)
$X
s64
s($Z))
(s($Y) s($Z) < 263 ) ||
(s($Y) s($Z) 263 ) )
0 (25 )
rA
rA|u64
0 (s($Y)
$X
s64
u(Z))
63
(s($Y) s(Z) < 2 ) ||
(s($Y) s(Z) 263 ) )
0 (25 )
rA
rA|u64
$X
$X
0 (u($Y)
u64
u($Z))
0
u64 (u($Y) u(Z))
0 (u(Y)
$X
s64
s($Z))
u(Y) s($Z 263 ) )
0 (25 )
rA
rA|u64
$X,Y,$Z
Negate; signed, with overflow
$X,Y,Z
Negate immediate; signed, with overflow
NEGU
$X,Y,$Z
$X,Y,Z
Negate unsigned; no overflow
Negate unsigned immed.; no overflow
$X
$X
0 (u(Y)
s64
s($Z))
0 (u(Y)
s64
u(Z))
MUL
$X,$Y,$Z
$X,$Y,Z
Multiply; signed, with overflow
Multiply immediate; signed, with ovf.
$X
$X
0 (s($Y) · s($Z))
s64
0 (s($Y) · u(Z))
s64
MULU
$X,$Y,$Z
$X,$Y,Z
Multiply unsigned; rH
Multiply uns. imm.; rH
NEG
($Y · $Z)127...64
($Y · Z)127...64
$X
rH$X
rH$X
0 (u(Y)
s64
s(Z))
0 (u($Y) · u($Z))
u128
0 (u($Y) · u(Z))
u128
2.3 MMIX Befehle
DIV
$X,$Y,$Z
$X,$Y,Z
$X,$Y,$Z
DIVU
$X,$Y,Z
a)
65
$X
rR
Divide; signed, with overflow
(case $Z 6= 0)
Divide immediate; signed, with ovf.
(case $Z = 0)
Divide unsigned; no overflow;
(case u($Z) > u(rD) )
Divide unsigned; no overflow;
no overflow (case u($Z)  u(rD) )
Divide unsigned immediate;
no overflow; (case u(Z) > u(rD) )
Divide unsigned immedediate;
no overflow (case u(Z)  u(rD) )
0 (bs($Y)/s($Z)c)
s64
0 ( s($Y) % s($Z) )
s64
0 (0)
$X
u64
rR
$Y
0 ( bu(rD$Y)/u($Z)c )
u128
0 ( u(rD$Y) % u($Z) )
u128
$X
rD
rR
$Y
0
$X
u128 ( bu(rD$Y)/u(Z)c )
0 ( u(rD$Y) % u(Z) )
rR
u128
$X
rD
rR
$Y
$X
rR
In welchem Wertebereich können die Direktoperanden bei den Arithmetischen
Befehlen liegen?
0 ... 255 sowohl für vorzeichenlose als auch für vorzeichenbehaftete Operationen.
b) Kann mit dem ADD Befehl 3 + 5 in einer einzigen Codezeile berechnet werden?
Nein, da der ADD-Befehl nur einen Direktoperanden unterstützt, muss der zweite
Operand zuvor in ein Allzweckregister geladen werden.
c)
Wie kann man 5
3 in einer einzigen Codezeile berechnen?
NEG
$0,5,3
d) Was ist der Unterschied zwischen den Befehlen MUL und MULU?
• MUL: Quell- und Zieloperanden haben jeweils 64 Bit
• MULU: Die Quelloperanden haben jeweils 64 Bit, der Zieloperand hat 128
Bit. Die oberen 64 Bit des Ergebnisses werden im Spezialregister rH
abgelegt.
66
e)
2 Assemblerprogrammierung
Geben Sie die MMIX-Befehle an, mit denen Sie x = a2 + 2 · a · b + b 2 mit Festkommazahlen 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.
MUL
MUL
MUL
ADD
MUL
ADD
buf1,a,a
buf2,a,2
buf2,buf2,b
buf1,buf1,buf2
buf2,b,b
x,buf1,buf2
buf1
a2
buf2
2·a
buf2
2·a·b
buf1
a2 + 2ab
buf2
b2
x
a2 + 2ab + b 2
Gegeben ist der folgende Programmcode:
a
b
c
d
buf1
buf2
Main
f)
IS
IS
IS
IS
IS
IS
$0
$1
$2
$3
$4
$5
LOC
SET
SET
SET
#100
b,1
c,2
d,3
Geben Sie MMIX-Befehle an, mit denen Sie a =
berechnen.
MUL
SUB
ADD
ADD
DIV
buf1,c,d
buf1,buf1,b
buf2,b,c
buf2,buf2,d
a,buf1,buf2
c·d b
b+c+d
mit Festkommazahlen
2.3 MMIX Befehle
67
Arithmetische Befehle auf Gleitkommazahlen
Befehl Operanden Name/Aktion
Definition
FADD
$X,$Y,$Z
Floating point add
$X
0 ( f ($Y) + f ($Z) )
f64
64
64
FSUB
$X,$Y,$Z
Floating point subtract
$X
0 ( f ($Y)
f64
64
FMUL
$X,$Y,$Z
Floating point multiplication
$X
FDIV
$X,$Y,$Z
Floating point divide
$X
FSQRT
$X,$Z
Square root
a)
0 ( f ($Y) · f ($Z) )
f64
64
64
0 ( f ($Y)/f ($Z) )
f64
64
64
p
0 (
$X
f64
f64 ($Z) )
Geben Sie MMIX-Befehle an, die ⇡ = 3.1415 in Register a ablegen.
SET
FLOT
SET
FLOT
FDIV
a,31415
a,a
buf,10000
buf,buf
a,a,buf
f64 ($Z) )
68
2 Assemblerprogrammierung
b) Geben Sie MMIX-Befehle an, die e = 2.718281828 in Register b ablegen.
SET
SET
buf1,10000
a,27
MUL
SET
ADD
a,a,buf1
buf2,1828
a,a,buf2
MUL
ADD
a,a,buf1
a,a,buf2
FLOT
FLOT
a,a
buf1,buf1
FDIV
FDIV
FLOT
FDIV
a,a,buf1
a,a,buf1
buf1,10
a,a,buf1
2.3 MMIX Befehle
c)
69
Geben Sie MMIX-Befehle an, mit denen Sie x = a2 + 2 · a · b + b 2 mit GleitkommaOperationen berechnen. Nehmen Sie an, dass Register a und b mit Festkommazahlen 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.
FLOT
FLOT
FMUL
FLOT
FMUL
FMUL
FADD
FMUL
FADD
a,a
b,b
buf1,a,a
buf2,2
buf2,a,buf2
buf2,buf2,b
buf1,buf1,buf2
buf2,b,b
x,buf1,buf2
buf1
a2
buf2
2·a
buf2
2·a·b
buf1
a2 + 2ab
buf2
b2
x
a2 + 2ab + b 2
70
2 Assemblerprogrammierung
Das Volumen einer Kugel berechnet sich zu V =
4
· ⇡ · r 3.
3
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.
PI
V
LOC
GREG
OCTA
OCTA
Data_Segment
@
#400921FB54442D18
r
buf1
buf2
IS
IS
IS
$0
$1
$2
LOC
#100
SET
FLOT
FLOT
FDIV
FMUL
FMUL
FLOT
FMUL
FLOT
r,1537
r,r
buf1,100
r,r,buf1
buf1,r,r
buf1,buf1,r
buf2,4
buf1,buf1,buf2
buf2,3
FDIV
buf1,buf1,buf2
LDO
buf2,PI
FMUL
buf1,buf1,buf2
STO
TRAP
buf1,V
0,Halt,0
Main
⇡ as float64
float
cm
r2
r3
4 · r3
4 3
·r
3
4 3
·r ·⇡
3
2.3 MMIX Befehle
71
Schiebe-Befehle
Befehl Operanden Name/Aktion
Definition
0 ( u($Y ⌧ u($Z)) )
u64
u($Y) · 2u($Z) 264 )
0 (25 )
rA
rA|u64
0 ( u($Y ⌧ u(Z)) )
$X
u64
u($Y) · 2u(Z) 264 )
0 (25 )
rA
rA|u64
$X
$X,$Y,$Z
Shift left; with overflow
$X,$Y,Z
Shift left immediate; with ovf.
SLU
$X,$Y,$Z
$X,$Y,Z
Shift left uns., no overflow
Shift left uns. immed.; no ovf.
$X,$Y,$Z
$X,$Y,Z
Shift right; fill with sign
Shift right imm.; fill with sign
$X
$X
$Y
$Y
s
SR
$X,$Y,$Z
$X,$Y,Z
Shift right unsigned; fill with 0
Shift right uns. imm.; fill w. 0
$X
$X
$Y
$Y
u
SRU
SL
$X
$X
0 ( u($Y ⌧ u($Z)) )
u64
0 ( u($Y ⌧ u(Z)) )
u64
u($Z)
u(Z)
s
u($Z)
u(Z)
u
72
a)
2 Assemblerprogrammierung
Wie unterscheiden sich der SR und der SRU Befehl?
• SR: Freiwerdende Bit-Positionen werden mit dem Vorzeichen (Bit 63)
aufgefüllt
• SRU: Freiwerdende Bit-Positionen werden mit 0 aufgefüllt
b) In Register fpn ist eine 64 Bit Gleitkommazahl abgelegt.
63
Inhalt Register fpn:
s
62
52
e
51
0
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.
SRU
s,fpn,63
s
SLU
SRU
e,fpn,1
e,e,53
e
SLU
SRU
f,fpn,63-51
f,f,63-51
2.3 MMIX Befehle
73
Logische Operationen auf Bit-Ebene
Befehl Operanden Name/Aktion
Definition
AND
$X,$Y,$Z
$X,$Y,Z
Bitwise AND
Bitwise AND immediate
ANDN
$X,$Y,$Z
$X,$Y,Z
Bitwise AND NOT
Bitww AND NOT immed.
ANDNL
$X,YZ
Bitw. AND NOT low wyde
ANDNML $X,YZ
Bw. AND NOT med. l. wd.
$X
0 ( u(YZ) ) ⌧ 16)
$X & ⇠ ( u64
ANDNMH $X,YZ
Bw. AND NOT med. h. wd.
$X
0 ( u(YZ) ) ⌧ 32)
$X & ⇠ ( u64
ANDNH
$X,YZ
Bw. AND NOT high wyde
$X
0 ( u(YZ) ) ⌧ 48)
$X & ⇠ ( u64
NAND
$X,$Y,$Z
$X,$Y,Z
Bitwise NOT AND
Bitwise NOT AND immed.
OR
$X,$Y,$Z
$X,$Y,Z
Bitwise OR
Bitwise OR immediate
ORL
$X,YZ
Bitwise OR low wyde
ORML
$X,YZ
Bitw. OR med. low wyde
$X
0 ( u(YZ) ) ⌧ 16)
$X | ( u64
ORMH
$X,YZ
Bitw. OR med. high wyde
$X
0 ( u(YZ) ) ⌧ 32)
$X | ( u64
ORH
$X,YZ
Bitwise OR high wyde
$X
0 ( u(YZ) ) ⌧ 48)
$X | ( u64
ORN
$X,$Y,$Z
$X,$Y,Z
Bitwise OR NOT
Bitwise OR NOT immediate
NOR
$X,$Y,$Z
$X,$Y,Z
Bitwise NOT OR
Bitwise NOT OR immediate
XOR
$X,$Y,$Z
$X,$Y,Z
Bitwise XOR
Bitwise XOR immediate
NXOR
$X,$Y,$Z
$X,$Y,Z
Bitwise NOT XOR
Bitw. NOT XOR immediate
$X
$X
$Y & ⇠ $Z
0 ( u(Z) )
$Y & ⇠ u64
$X
0 ( u(YZ) )
$X & ⇠ u64
$X
$X
⇠ ($Y & $Z)
0 ( u(Z) ) )
⇠ ( $Y & u64
$X
$X
$X
$Y | ⇠ $Z
0 ( u(Z) )
$Y | ⇠ u64
$X
$X
$X
$Y | $Z
0
$Y | u64 ( u(Z) )
0 ( u(YZ) )
$X | u64
$X
$X
⇠ ($Y | $Z)
0 ( u(Z) ) )
⇠ ($Y | u64
$X
$X
$X
$Y & $Z
0
$Y & u64 ( u(Z) )
$X
$Y ⌦ $Z
0
$Y ⌦ u64 ( u(Z) )
$X
⇠ ($Y ⌦ $Z)
0 ( u(Z) ) )
⇠ ($Y ⌦ u64
74
2 Assemblerprogrammierung
Bits löschen
a)
Welche Befehle verwendet man typischerweise um einzelne Bits zu löschen?
Befehle, die UND-Operationen implementieren.
Für die nachfolgenden Aufgaben soll jeweils dieses Programm verwendet werden:
A
LOC
GREG
OCTA
Data_Segment
@
#AAAA AAAA AAAA AAAA
a
IS
$0
Main
LOC
LDO
#100
a,A
XXX
XXX
XXX
XXX
XXXXX
XXXXX
XXXXX
XXXXX
STO
TRAP
a,A
0,Halt,0
hier
MMIXBefehle
einsetzen
b) Ersetzen Sie in obigem Programm XX... durch MMIX-Befehle, die in Register a Bit
21 mit einem AND-Befehl löschen.
SETL
INCML
INCMH
INCH
AND
$1,#FFFF
$1,#FFDF
$1,#FFFF
$1,#FFFF
a,a,$1
2.3 MMIX Befehle
c)
75
Ersetzen Sie in obigem Programm XX... durch MMIX-Befehle, die in Register a Bit
21 mit einem ANDN-Befehl löschen.
SETL
SLU
ANDN
$1,1
$1,$1,21
a,a,$1
d) Ersetzen Sie in obigem Programm XX... durch MMIX-Befehle, die in Register a Bit
21 mit einem ANDNML-Befehl löschen.
ANDNML
a,#20
Bits setzen
a)
Welche Befehle verwendet man typischerweise um Bits zu setzen?
ODER-Befehle
b) Ersetzen Sie in obigem Programm XX... durch MMIX-Befehle, die in Register a Bit
20 mit einem OR-Befehl auf 1 setzen.
SET
SLU
OR
c)
$1,1
$1,$1,20
a,a,$1
Ersetzen Sie in obigem Programm XX... durch MMIX-Befehle, die in Register a Bit
20 mit einem ORML-Befehl auf 1 setzen.
ORML
a,#10
76
2 Assemblerprogrammierung
XOR
a)
Erklären Sie den Effekt einer XOR-Operation.
XOR-Operationen setzen ein Ziel-Bit auf 1, wenn die beiden Quell-Bits unterschiedlich sind.
b) Was wird dem Ziel-Operanden einer XOR-Operation zugewiesen, wenn alle Bits
des einen Quell-Operanden gelöscht (0) sind?
Dem Ziel-Operanden werden die Bits des anderen Quell-Operanden zugewiesen.
c)
Was wird dem Ziel-Operanden einer XOR-Operation zugewiesen, wenn alle Bits
des einen Quell-Operanden gesetzt (1) sind?
Dem Ziel-Operanden werden die invertierten Bits des anderen Quell-Operanden
zugewiesen.
2.3 MMIX Befehle
77
Gegeben ist das folgende Programm:
A
B
C
LOC
GREG
OCTA
OCTA
OCTA
Data_Segment
@
#AAAA AAAA AAAA AAAA
#1111 1111 1111 1111
a
b
c
IS
IS
IS
$0
$1
$2
Main
LOC
LDO
LDO
#100
a,A
b,B
XXX
XXX
XXX
XXX
XXXXX
XXXXX
XXXXX
XXXXX
STO
TRAP
c,C
0,Halt,0
hier
MMIXBefehle
einfügen
d) Ersetzen Sie XX... durch MMIX-Befehle die a invertieren und das Ergebnis in c
ablegen.
NEG
XOR
$3,0,1
c,a,$3
78
2 Assemblerprogrammierung
Zugriff auf Spezialregister
Befehl Operanden Name/Aktion
Definition
GET
$X,Z
Get value of special purpose register
$X
PUT
X,$Z
X,Z
Put value to special purpose register
Put immed. value to spec. purp. reg.
r [X]
$Z
0
u64 (u(Z))
a)
r [X]
r [Z]
Tragen Sie in nachfolgender Befehlssequenz Befehle zur Berechnung der Festkommadivisioni dividend/divisor ein und speichern Sie das Ergebnis an der
Marke Quotient und den Divisionsrest an der Marke Remainder ab.
Dividend
Divisor
Quotient
Remainder
LOC
GREG
OCTA
OCTA
OCTA
OCTA
Data_Segment
@
7
3
dividend
divisor
quotient
remainder
IS
IS
IS
IS
$0
$1
$2
$3
Main
LOC
LDO
LDO
#100
dividend,Dividend
divisor,Divisor
DIV
GET
STO
STO
quotient,dividend,divisor
remainder,rR
quotient,Quotient
remainder,Remainder
TRAP
0,Halt,0
2.3 MMIX Befehle
79
Gegeben ist das Format des Spezialregisters rA.
Interrupt Enable (Freischalten)
0 R1 R0 D V W
I
O
U Z
X
D V W
I
O
U Z
X
Gleitkommazahl ungenau
(z.B. 1.0 / 3.0)
Gleitkomma-Division durch 0
Gleitkomma-Unterlauf
Gleitkomma-Überlauf
Unerlaubte GleitkommaOperation, z.B. sqrt(-1.0)
Überlauf bei Wandlung Gleitkomma- in Festkommazahl
Festkomma-Überlauf
Festkomma-Division durch 0
Nicht verwendet
Gleitkomma-Rundungsmodus
00: Nächster Wert (standard)
01: Abrunden (Richtung 0)
10: Aufrunden (Richtung + )
11: Abrunden (Richtung - )
8 8
0
Interrupt Event (Auftreten)
b) Geben Sie den MMIX-Code an, mit dem Sie den Gleitkomma-Rundungsmodus
auf ‘‘aufrunden’’ setzen.
Bits die geändert werden müssen: 17, 16
GET
ANDNML
ORML
PUT
c)
$0,rA
$0,3
$0,2
rA,$0
Ändern Sie das Interrupt-Enable Bit ‘‘integer overflow’’ (0 ) 1, 1 ) 0) .
GET
SET
XOR
PUT
$0,rA
$1,#4000
$0,$0,$1
rA,$0
80
2 Assemblerprogrammierung
Verzweigungsbefehle
Unbedingte Verzweigung
Befehl Operanden Name/Aktion
JMP
XYZ
Definition
@
Jump
0 ( u(@) + 4 · s(XYZ) )
u64
Bedingte Verzweigungen
Befehl Operanden Name/Aktion
Definition
BZ
$X,YZ
Branch if zero
s($X) = 0 ) @
0 ( u(@) + 4 · s(YZ) )
u64
PBZ
$X,YZ
Probable br. if zero
s($X) = 0 ) @
0 ( u(@) + 4 · s(YZ) )
u64
BNZ
$X,YZ
Branch if nonzero
s($X) 6= 0 ) @
0 ( u(@) + 4 · s(YZ) )
u64
PBNZ
$X,YZ
Prob. br. if nonzero
s($X) 6= 0 ) @
0 ( u(@) + 4 · s(YZ) )
u64
BN
$X,YZ
Branch if negative
s($X) < 0 ) @
0 ( u(@) + 4 · s(YZ) )
u64
PBN
$X,YZ
Prob. br. if negative
s($X) < 0 ) @
0 ( u(@) + 4 · s(YZ) )
u64
BNN
$X,YZ
Branch if nonneg.
s($X)
0)@
0 ( u(@) + 4 · s(YZ) )
u64
PBNN
$X,YZ
Prob. br. if nonneg.
s($X)
0)@
0 ( u(@) + 4 · s(YZ) )
u64
BP
$X,YZ
Branch if positive
s($X) > 0 ) @
0 ( u(@) + 4 · s(YZ) )
u64
PBP
$X,YZ
Prob. br. if positive
s($X) > 0 ) @
0 ( u(@) + 4 · s(YZ) )
u64
BNP
$X,YZ
Branch if nonpositive
s($X)  0 ) @
0 ( u(@) + 4 · s(YZ) )
u64
PBNP
$X,YZ
Prob. br. if nonpos.
s($X)  0 ) @
0 ( u(@) + 4 · s(YZ) )
u64
BEV
$X,YZ
Branch if even
s($X) % 2 = 0 ) @
0 ( u(@)+4·s(YZ) )
u64
PBEV
$X,YZ
Prob. branch if even
s($X) % 2 = 0 ) @
0 ( u(@)+4·s(YZ) )
u64
BOD
$X,YZ
Branch if odd
s($X) % 2 = 1 ) @
0 ( u(@)+4·s(YZ) )
u64
PBOD
$X,YZ
Prob. branch if odd
s($X) % 2 = 1 ) @
0 ( u(@)+4·s(YZ) )
u64
2.3 MMIX Befehle
a)
81
Benutzen Sie MMIX Verzweigungs-Befehle um folgenden C-Code zu implementieren:
C-Code:
if(a == 0)
{
a = 1;
}
MMIX-Code:
End
BNZ
SET
...
a,End
a,1
...
b) Benutzen Sie MMIX Verzweigungs-Befehle um folgenden C-Code zu implementieren:
C-code:
int a;
...
if(a <= 0)
{
a = 1;
}
else
{
a = 2;
}
MMIX-Code:
Pos
End
BP
SET
JMP
SET
...
a,Pos
a,1
End
a,2
...
82
c)
2 Assemblerprogrammierung
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:
L1
L2
End
BNP
BNN
SET
JMP
BP
BZ
SET
JMP
SET
...
a,L1
b,L1
a,1
End
a,L2
b,L2
a,3
End
a,2
...
2.3 MMIX Befehle
83
Befehle für Funktionsaufrufe
Befehl Operanden Name/Aktion
Definition
Go to location
$X,$Y,Z
Go to location immediate
GO
a)
0 ( u(@) + 4) );
u64
0 ( u($Y) + u($Z) )
@
u64
0 ( u(@) + 4) );
$X
u64
0 ( u($Y) + u(Z) )
@
u64
$X
$X,$Y,$Z
Was ist der Haupt-Unterschied zwischen dem JMP-Befehl und dem GO-Befehl?
• JMP benutzt Relative Adressierung, während GO Absolute Adressierung
verwendet.
• GO speichert die Rücksprungadresse ab, JMP nicht.
b) Wo speichern GO-Befehle die Rücksprungadresse ab?
Die Rücksprungadresse wird in Register X abgelegt.
c)
Was ist die ‘‘Rücksprungadresse’’?
Die Rücksprungadresse ist die Adresse des nächsten Befehlsworts. Wenn GO an
einer durch vier teilbaren Adresse a steht, dann ist die Rücksprungadresse a + 4.
d) Wenn GO Absolute Adressierung verwendet: Wie wird die Abolute Adresse (64 Bit)
im 32 Bit breiten Befehlswort abgelegt?
Genauso wie es allgemein bei Marken gemacht wird: Der Assembler transformiert
die Adresse der Marke in eine Basisadresse, die in Register Y gespeichert wird,
und einem Offset, der in Register Z oder im Direktoperanden Z gespeichert wird.
e)
Geben Sie den Befehl an, mit dem Sie die Funktion fkt aufrufen und die Rücksprungadresse in Register 0 ablegen.
GO
$0,fkt
84
2 Assemblerprogrammierung
Namensräume
a)
Wozu dient der PREFIX-Befehl?
Der PREFIX-Befehl dient zur Generierung von Namensräumen.
• Kommt ein Name im selben Namensraum vor, beschreibt er die selbe
Variable/Funktion.
• Kommt ein Name in unterschiedlichen Namensräumen vor, beschreibt er
unterschiedliche Variable/Funktionen.
Hat jede Funktion einen eigenen Namensraum, kann man dieselben Variablennamen in unterschiedlichen Funktionen verwenden, ohne dass damit auf dieselben
Variablen zugegriffen wird.
b) Welche Auswirkung hat der Befehl PREFIX mein_prefix auf darauf folgende MMIXAnweisungen?
Nach der Anweisung PREFIX myprefix wird jeder Marke bzw. jedem Registernamen die Zeichenkette mein_prefix vorangestellt. Gibt es z.B. eine Marke/einen
Registernamen yy, so wird dieser in mein_prefixyy umgewandelt. Dabei handelt es
sich um eine reine Textersetzung.
c)
Wie kann man einen Namensraum beenden, d.h. wie kann man den Assembler
anweisen, Marken/Namen nicht mehr umzuwandeln?
Wird PREFIX mit dem Operanden ‘‘:’’ aufgerufen, wird der zugehörige Namensraum
geschlossen.
d) Wie kann man – innerhalb eines Namensraums – verhindern, dass der Assembler
einer bestimmten Marke bzw. einem bestimmten Namen die im PREFIX-Befehl
angegebene Zeichenkette voranstellt?
Man muss vor die Marke bzw. vor den Namen einen Doppelpunkt schreiben.
2.3 MMIX Befehle
85
Gegeben ist folgender Programmcode:
label0
label1
label2
a
b
c
XXX
e)
LOC
GREG
OCTA
PREFIX
OCTA
PREFIX
OCTA
PREFIX
Data_Segment
@
1
x
2
y
3
:
IS
PREFIX
IS
IS
PREFIX
$0
z
$1
$2
:
PREFIX
LOC
XXX
XXX
XXX
PREFIX
main:
#100
XXX
XXX
XXX
:
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.
:Main
LDO
LDO
LDO
:a,:label0
:zb,:xlabel1
:zc,:xylabel2
86
2 Assemblerprogrammierung
Stack
a)
Was ist der Stack?
Der Stack ist ein Bereich im Arbeitsspeicher der lokale Programmdaten wie
• lokale Variable,
• in den Arbeitsspeicher gesicherte Register und
• Rücksprungadressen
enthält. Der englische Begriff ‘‘Stack’’ bedeutet ‘‘Stapel’’ und rührt daher, dass
die Daten dort ‘‘gestapelt’’ werden.
b) Wo beginnt der Stack und in welche Richtung wächst er?
Der Stack beginnt am Ende des Datensegments und wächst in Richtung kleinerer
Adressen.
c)
Was ist der Stack-Pointer?
Der Stack-Pointer ist ein Register das die Adresse des zuletzt auf dem Stack
abgelegten Elements enthält.
d) Wie werden Daten adressiert, die auf dem Stack liegen?
Daten auf dem Stack werden immer über den Stack-Pointer adressiert. Der StackPointer dient dabei als Basis-Adresse, auf die ein Offset addiert wird um andere
Elemente als das oberste Element des Stacks zu adressieren.
2.3 MMIX Befehle
e)
Welche Operationen muss man ausführen um die Werte zweier Register (acht Byte
breite Datenworte) auf dem Stack abzulegen?
• Den Wert des Stack-Pointers um 2 · 8 = 16 verringern
• Die beiden Datenworte an die Adresse Stack-Pointer und Stack-Pointer
+ 8 speichern
f)
87
Wie wird der Stack bei Funktionsaufrufen verwendet?
Beim Aufruf der Funktion die
• Parameter auf dem Stack ablegen.
In der Funktion
• die Rücksprungadresse auf den Stack sichern (push),
• diejenigen Register, die von der Funktion geändert werden, auf den Stack
sichern (push),
• Parameter vom Stack in die Register einlesen,
• Parameter verarbeiten um ein Ergebnis zu berechnen,
• das Ergebnis auf dem Stack ablegen, damit der Funktionsaufrufer es
auslesen kann,
• die zuvor auf den Stack gesicherten Register wiederherstellen (pop),
• die zuvor auf den Stack gesicherte Rücksprungadresse wieder vom Stack
auslesen (pop),
• den Stackpointer so anpassen, dass er aufs Ergebnis zeigt,
• zum Funktionsaufrufer zurückspingen.
Nach Rückkehr zum Funktionsaufrufer
• das berechnete Ergebnis vom Stack auslesen (pop).
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 0000 0000 0000 initialisieren.
SP
h)
GREG
#4000 0000 0000 0000
Warum initialisieren wir den Stack-Pointer mit 0x4000 0000 0000 0000, d.h. mit
dem Beginn des Poolsegments, und nicht mit dem Ende des Datensegments?
Bevor Daten auf den Stack gesschrieben werden (push), wird der Wert des StackPointers um die Anzahl der zu schreibenden Byte verringert. Wird bspw. ein Octa
(64 Bit ) 8 Byte) auf den Stack geschrieben, so wird der Stack-Pointer um 1 · 8
verringert und zeigt dann auf die Adresse #3FFF FFFF FFFF FFF8. Das ist genau
das letzte Octa-Datenwort im Datensegment.
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 :fkt
angelegt wurde. Sichern Sie die Rücksprungadresse in Register 0.
SUB
STO
STO
GO
:SP,:SP,2*8
$1,:SP,0
$2,:SP,1*8
$0,:fkt
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.
SUB
STO
STO
STO
STO
LDO
LDO
k)
:SP,:SP,4*8
$0,:SP,0
$1,:SP,1*8
$2,:SP,2*8
$3,:SP,3*8
$1,:SP,4*8
$2,:SP,5*8
Zeichnen Sie, wie der Stack nach diesen Operationen aussieht.
SP ! 0x3FFF FFFF FFFF FFD0
0x3FFF FFFF FFFF FFD8
0x3FFF FFFF FFFF FFE0
0x3FFF FFFF FFFF FFE8
0x3FFF FFFF FFFF FFF0
0x3FFF FFFF FFFF FFF8
$0
$1
$2
$3
$1
$2
90
l)
2 Assemblerprogrammierung
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?
Das Unterprogramm hat in der Regel keine Informationen darüber, in welchen
Registern der Funktionsaufrufer die Parameter abgelegt hatte, da beispielsweise
Funktionsaufrufer und Unterprogramm von unterschiedlichen Personen entwickelt
wurden. Wenn man aber die Anzahl und Reihenfolge der Parameter kennt, weiß
man, wie man diese vom Stack auslesen muss und kann diese auch ohne Kenntnis
der verwendeten Register auslesen.
m) Warum speichert man die Rücksprungadresse auf dem Stack?
Falls die aufgerufene Funktion ihrerseits wieder eine Funktion aufruft und dabei
das Register, in dem die Rücksprungadresse gespeichert ist, überschreibt, dann
würde die Rücksprungadresse verloren gehen.
n)
Was würde passieren, wenn der Stack so groß wird, dass er mit den Daten
zusammenstößt, die am Beginn des Datensegments liegen?
Das Programm würde wahrscheinlich abstürzen, da möglicherweise die Rücksprungadressen überschrieben werden würden und dann zu völlig falschen Speicheradressen verzweigt werden würde.
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.
STO
LDO
LDO
LDO
LDO
ADD
GO
$3,:SP,5*8
$0,:SP,0
$1,:SP,1*8
$2,:SP,2*8
$3,:SP,3*8
:SP,:SP,5*8
$0,$0,0
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.
LDO
ADD
$1,:SP,0
:SP,:SP,8
q) Warum muss der Stack-Pointer angepasst werden nachdem das Ergebnis vom
Stack geladen wurde?
Würde man das nicht machen, würde der Stack-Pointer nicht auf die selbe Stelle
zeigen wie vor dem Funktionsaufruf. Dadurch hätte man beim Zugriff auf StackInhalte, die vom Stack-Pointer aus gesehen an höheren Adressen liegen, immer
einen Versatz, in unserem Beispiel um acht Byte.
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 det A = det ba dc = 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 0000 0000, acht Byte im Speicher 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, C
und D ansprechbar.
A
B
C
D
LOC
GREG
OCTA
OCTA
OCTA
OCTA
Data_Segment
@
4
3
2
1
b) Reservieren Sie an Adresse 0x2000 0000 0000 0100 ein acht Byte breites Datenwort für das Ergebnis und machen Sie es über die Marke Erg ansprechbar.
Erg
LOC
GREG
OCTA
#2000 0000 0000 0100
@
94
c)
2 Assemblerprogrammierung
Warum benötigen Sie für das Ergebnis einen separaten Befehl GREG @ ?
Mit dem ersten Aufruf von GREG @ wurde ein globales Register reserviert und die
Adresse 0x2000 0000 0000 0000 hineingeschrieben. Das Ergebnis ist jedoch 256
Byte von dieser Adresse entfernt. Der Assembler kann es somit nicht mit einem
Direktoperanden erreichen, da mit 8 Bit nur ein maximaler Offset von 255 möglich
ist, nicht aber 256.
d) Was passiert, wenn einem durch viele Variable die globalen Register ausgehen?
Wenn man soviele Variable anlegt, muss man die Adressierung dynamisch gestalten, d.h. der Offset ist dann kein Direktoperand, sondern er liegt in einem anderen
globalen Register das dann dynamisch aktualisiert wird. Das wird im Rahmen der
Vorlesung jedoch nicht betrachtet.
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.
a
b
c
d
buf1
buf2
IS
IS
IS
IS
IS
IS
$1
$2
$3
$4
$5
$6
2.4 MMIX Programme
f)
95
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.
Main
LOC
LDO
LDO
LDO
LDO
#100
a,A
b,B
c,C
d,D
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.
MUL
MUL
SUB
STO
TRAP
buf1,a,d
buf2,b,c
buf1,buf1,buf2
buf1,Res
0,Halt,0
96
2 Assemblerprogrammierung
Quadratische Gleichung
In dieser Übung schreiben Sie ein MMIX Programm zur
Lösung der Quadratischen
p
b± b 2 4·a·c
2
Gleichung a · x + b · x + c = 0 mit der Formel x1,2 =
zu lösen. Die Variable
2·a
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.
SP
GREG
#4000000000000000
Zunächst soll das Hauptprogramm implementiert werden.
b) Geben Sie den MMIX-Befehl an, mit dem Sie den Namensraum Main: eröffnen.
PREFIX
c)
Main:
Reservieren Sie an Adresse 0x2000 0000 0000 0000 die 64 Bit breiten Speicherworte
A, B, C, X1 und X2 und initialisieren Sie A mit 2, B mit 4 und C mit 8.
A
B
C
X1
X2
LOC
GREG
OCTA
OCTA
OCTA
OCTA
OCTA
#2000 0000 0000 0000
@
2
4
8
d) Geben Sie den Befehl an, mit dem Sie Register 1 durch buf ansprechbar machen.
buf
IS
$1
2.4 MMIX Programme
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.
:Main
f)
97
SUB
LDO
STO
LDO
STO
LDO
STO
GO
:SP,:SP,3*8
buf,A
buf,:SP,0
buf,B
buf,:SP,8
buf,C
buf,:SP,2*8
$0,:QuadGleich
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.
LDO
STO
LDO
STO
ADD
buf,:SP,0
buf,X1
buf,:SP,8
buf,X2
:SP,:SP,2*8
g) Geben Sie die Anweisungen an, mit denen Sie das Programm und den Namensraum Main: beenden.
TRAP
PREFIX
0,:Halt,0
:
98
2 Assemblerprogrammierung
Im Folgenden soll die Funktion QuadGleich implementiert werden, von der folgender
Programm-Code bereits gegeben ist:
a
b
c
x1
x2
disk
buf1
buf2
PREFIX
QuadGleich:
IS
IS
IS
IS
IS
IS
IS
IS
$1
$2
$3
$4
$5
$6
$7
$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 verwendeten Register auf den Stack sichern und die Parameter a, b und c dann vom Stack
in die Register a, b und c einlesen.
:QuadGleich
SUB
STO
STO
STO
STO
STO
STO
STO
STO
LDO
LDO
LDO
:SP,:SP,8*8
a,:SP,0
b,:SP,8
c,:SP,2*8
x1,:SP,3*8
x2,:SP,4*8
disk,:SP,5*8
buf1,:SP,6*8
buf2,:SP,7*8
a,:SP,8*8
b,:SP,9*8
c,:SP,10*8
2.4 MMIX Programme
i)
99
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.
BNZ
FLOT
NEG
FLOT
FDIV
SET
JMP
j)
a,Anicht0
b,b
c,0,c
c,c
x1,c,b
x2,x1
Speichern
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
MUL
SLU
MUL
SUB
buf1,a,c
buf1,buf1,2
buf2,b,b
disk,buf2,buf1
100
k)
2 Assemblerprogrammierung
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.
BN
BZ
JMP
l)
disk,Dneg
disk,D0
Dpos
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
SET
SUB
SET
JMP
x1,0
x1,x1,1
x2,x1
Speichern
NaN: Exponent alle Bits gesetzt und f > 0
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
NEG
FLOT
SL
FLOT
FDIV
SET
JMP
buf1,0,b
buf1,buf1
buf2,a,1
buf2,buf2
x1,buf1,buf2
x1,x2
Speichern
2.4 MMIX Programme
n)
101
Geben Siepan Marke Dpos die MMIX Befehle an, mit denen Sie x1 und x2 gemäß
b 2 4·a·c
x1,2 = b± 2·a
berechnen und das Ergebnis in x1 und x2 ablegen. Springen
Sie dann an die Marke Speichern. Beachten Sie, dass die Diskriminante bereits
berechnet wurde und als Festkommazahl in Register disk abgelegt ist.
Dpos
SL
FLOT
NEG
FLOT
FLOT
FSQRT
FADD
FDIV
FSUB
FDIV
JMP
buf2,a,1
buf2,buf2
buf1,0,b
buf1,buf1
disk,disk
disk,disk
x1,buf1,disk
x1,x1,buf2
x2,buf1,disk
x2,x2,buf2
Speichern
x1 berechnen
x2 berechnen
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
STOU
STOU
ADD
GO
x1,:SP,9*8
x2,:SP,10*8
:SP,:SP,9*8
$0,$0,0
PREFIX
:
8 Variable gesichert +
3 Param. = 11 => 0..10
die letzten beiden
sind offset 9 und 10
102
2 Assemblerprogrammierung
3.1 Datenpfad
103
3 Mikroarchitektur
3.1 Datenpfad
In 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 1 wird der auszuführende Befehl aus dem Befehlsspeicher 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?
Eingang: Adressen; Ausgang: Befehle.
b) Welche Wortbreiten haben der Eingangs- und Ausgangsbus des MMIX Befehlsspeichers?
Eingang: 64 Bit; Ausgang: 32 bit
c)
Entwerfen Sie ein geeignetes Symbol für den MMIX-Befehlsspeicher.
Adresse
64
Befehls-
Speicher
Befehl
32
104
3 Mikroarchitektur
d) Wie wird die Adresse gespeichert, mit der der Befehlsspeicher adressiert wird?
Der aktuelle Adresswert steht in einem Register, dem sog. Befehlszähler.
e)
Wie muss sich der Wert des Befehlszählers ändern, damit der auf den aktuellen
Befehl im Speicher folgende Befehl adressiert wird?
Befehlszähler um 4 erhöhen.
3.1 Datenpfad
f)
105
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:
4
Add
64
64
BZ
Adresse
64
Befehls-
Speicher
Befehl
32
Musterlösung:
4
Add
64
64
BZ
Adresse
64
Befehls-
Speicher
Befehl
32
106
3 Mikroarchitektur
g) Erweitern Sie nachfolgende Abbildung um das Befehlsregister und verdrahten Sie
das Befehlsregister mit dem Befehlsspeicher.
Eigener Lösungsweg:
Adresse
64
Befehls-
Speicher
Befehl
BR
32
Musterlösung:
Adresse
64
Befehls-
Speicher
Befehl
BR
32
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.
Bits 31...24:
Opcode
- legt fest, um welchen Befehl es sich handelt
31...24
Bits 23...16:
X
- legt fest, in welchem Register das Ergebnis abgelegt
werden soll; - Bei Speicherbefehlen: legt das Register fest, dessen Inhalt in den Arbeitsspeicher abgelegt werden soll
23...16
Bits 15...08:
Y
- legt fest, in welchem Register der erste Operand steht
- beim NEG-Befehl: 8 Bit vorzeichenloser Direktoperand
15...8
BR
32
Bits 7...0:
Z
- falls Bit 24 = 0: legt fest, in welchem Register der zweite Operand steht
7...0
- falls Bit 24 = 1: zweiter Operand als 8 Bit vorzeichenloser Direktoperand,
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?
Y und Z werden nur gelesen, d.h. man braucht jeweils einen 8 Bit breiten AdressEingang und einen 64 Bit breiten Daten-Ausgang.
c)
Welche Ein- und Ausgänge benötigt der Registerblock für die durch X adressierten
Register?
Die durch X adressierten Register können sowohl gelesen als auch geschriebn
werden, d.h. man benötigt
• einen 8 Bit breiten Adress-Eingang (Auswahl des durch X adressierten
Registers)
• einen 64 Bit breiten Daten-Eingang (Schreiben in Register X)
• einen 64 Bit breiten Daten-Ausgang (Lesen von Register X)
• eine Taktleitung (Übernahme der Eingangsdaten in Register X beim
Schreiben)
d) Skizzieren Sie ein für den Allzweck-Registerblock passendes Blockschaltbild
Allzweck-
Registerblock
Schreiben
64
Schreib-
Daten $X
$X
64
X
8
8
8
$Y
64
Y
Z
$Z
64
3.1 Datenpfad
e)
109
Wie kann man aus dem Allzweck-Registerblock den Wert eines Registers auslesen?
Man legt an einen der drei Eingänge X, Y bzw. Z die Adresse des gewünschten
Registers an, d.h. eine 8 Bit Zahl zwischen 0 und 255. Am entsprechenden Ausgang
$X, $Y bzw. $Z wird dann automatisch der im adressierten Register gespeicherte
Wert ausgegeben.
f)
Wie kann man in den Allzweck-Registerblock schreiben?
• Man legt am Eingang X die Adresse des Registers an, in das geschrieben werden soll. Will man in Register 5 schreiben, legt man z.B. die
Bitkombination 00000101 an den Eingang X an.
• Desweiteren legt man am Eingang Schreibdaten $X das 64 Bit breite
Datenwort an, das in das durch X adressierte Register geschrieben
werden soll.
• Bei einer positiven Flanke am Takteingang Schreiben wird das Datenwort
im entsprechenden Register des Allzweck-Registerblocks abgespeichert
und auch sofort an den Ausgang $X weitergeleitet.
!"!# $%&'(%#)*+#,%-./01-2*0-3*0/*-#(%&#40.+1(+530/*./%+67'*-*#
110
3 Mikroarchitektur
!"!"#$ %&'()*'+$
−! &'()'*+',-+'.!
−! /01)2'*+',-+'.!
−! /0'(34'.512.(6!
g)! Skizzieren Sie, wie sich der Allzweck-Registerblock aus 256 einzelnen Registern
→!7-.)'89*:8;-)('*!
zusammensetzen
lässt.
!
!
!
!"!",$ -'.(/0'+123)4$
−! <9;=19!198!$>[email protected]':(82'.*A!B!C9)2(0)'6'.*!9*+!'(*'5!D'59)2(0)'6'.!!
!
/34.'(='*
$>>
H
$ F %
%
F
$
E
%
F
$
/34.'(=#
D12'*!$X
?B
?"
H
G%
GF
G$
D?B G?B
%
F
$
?"
?"
?"
?B
I'8'#
D12'*!$X
$>>
E
%
F
$
/34.'(='*J
I'8'*!$X
D%
DF
D$
?B
•
D%
DF
D$
G%
GF
G$
D?B G?B
H
%
F
$
?"
%
F
$
?B
?"
E
?"
%
F
$
D%
DF
D$
?B
D?B G?B
I'8'*!$Y
I'8'#
D12'*!$Y
G%
GF
G$
F
$
?"
$>>
?B
H
H
%
F
$
E
I'8'*!$Z
%
F
$
D%
DF
D$
?"
G%
GF
G$
?"
F
$
?"
H
?B
D?B G?B
I'8'#
D12'*!$Z
$>>
?B
H
!
$''"#8!9:#$%&'(%#)*2#;*<02/*+'=15.2#(%2#;*<02/*+->#4%=/0?=*@*+-#%-)#*0-*A#B*A%=/0?=*@*+#
!
!
"#$%
3.1 Datenpfad
111
Unsere Implementierung des Allzweck-Registerblocks verwendet ausschließlich Register
und Multiplexer.
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:
0
0
1
1
64
64
...
h)
63
63
112
3 Mikroarchitektur
Musterlösung:
0
0
1
1
64
...
64
63
63
3.1 Datenpfad
i)
113
Tragen Sie in nachfolgende Abbildung ein, wie sich ein taktflankengesteuertes DFlipflop nach dem Master-Slave-Prinzip aus taktzustandsgesteuerten D-Flipflops
aufbauen lässt.
Eigener Lösungsweg:
C
D
D
Q
Q
C
D
Q
C
Musterlösung:
C
D
D
Q
C
Q
D
C
Q
114
j)
3 Mikroarchitektur
Tragen Sie in nachfolgende Abbildung ein, wie sich ein taktzustandsgesteuertes
D-Flipflop aus einem RS-Flipflop aufbauen lässt.
Eigener Lösungsweg:
D
C
S
Q
C
Q
R
Musterlösung:
D
C
S
Q
C
R
Q
3.1 Datenpfad
k)
115
Tragen Sie in nachfolgende Abbildung ein, wie sich ein RS-Flipflop aus einfachen
Logikgattern zusammensetzen lässt.
Eigener Lösungsweg:
S
C
Q
R
Musterlösung:
S
C
R
Q
116
l)
3 Mikroarchitektur
Skizzieren Sie, wie sich ein vierfach 4 Bit Multiplexer aus vier vierfach 1 Bit
Multiplexern aufbauen lässt.
Eigener Lösungsweg:
2
2
0
1
2
3
2
0
1
2
3
2
0
1
2
3
2
0
1
2
3
3.1 Datenpfad
117
Musterlösung:
2
2
0
1
2
3
2
0
1
2
3
2
0
1
2
3
2
0
1
2
3
118
3 Mikroarchitektur
m) Skizzieren Sie, wie sich ein vierfach 1 Bit Multiplexern aus Logikgattern aufbauen
lässt.
Eigener Lösungsweg:
2
1
0
1
1
1
1
1
3.1 Datenpfad
119
Musterlösung:
2
1
0
1
1
1
1
1
120
n)
3 Mikroarchitektur
Tragen Sie in nachfolgende Abbildung geeignete Verbindungen ein, damit X,
Y und Z (aus dem Befehlsregister) die entsprechenden Register des AllzweckRegisterblocks adressieren und die ausgelesenen Registerinhalte ins OperandenRegister OR geschrieben werden können.
Eigene Lösung:
4
Add
64
64
OR
Allzweck-
Registerblock
BZ
Schreiben
$X
64
64
Adresse
64
23...16
Befehls-
Speicher
Befehl
Schreib-
Daten $X
X
$Y
8
BR
15...8
o1
64
o2
Y
8
32
32
7...0
8
Z
$Z
64
o3
Musterlösung:
4
Add
64
64
OR
Allzweck-
Registerblock
BZ
Schreiben
$X
64
64
Adresse
64
23...16
Befehls-
Speicher
Befehl
Schreib-
Daten $X
X
$Y
8
BR
15...8
o1
64
o2
Y
8
32
32
7...0
8
Z
$Z
64
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
0 (u(Z )) annehmen kann, so dass nicht nur Befehle mit
$Z auch den Wert u64
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
32
7...0
8
7...0
$Z
Z
64
0
o3
1
0
56
64
63...8
Musterlösung:
BR
32
7...0
8
7...0
$Z
Z
64
0
o3
1
0
56
63...8
64
p) Was ist beim NEG-Befehl anders als bei allen anderen Befehlen?
Beim NEG-Befehl ist Y ein vorzeichenloser 8 Bit Direktoperand, d.h. u(Y).
q) Wie berechnet sich beim JMP-Befehl die Sprungziel-Adresse?
@
r)
@ + s(XYZ)
Wie berechnet sich bei den Befehlen zur bedingten Verzweigung (BZ, BNZ, ...) die
Sprungziel-Adresse?
@
@ + s(YZ)
122
3 Mikroarchitektur
Erweitern Sie nachfolgende Schaltung um die Möglichkeit, dass o2 statt $Y auch
s)
0 (u(Y )) und
• den Wert u64
• den Wert @ annehmen kann und
Operand o3 statt $Y auch
0 (u(Z )),
• u64
0 (s(YZ )) und
• s64
0 (s(XYZ )) annehmen kann.
• s64
Eigene Lösung:
4
Add
64
64
OR
Allzweck-
Registerblock
BZ
Schreiben
o1
$X
64
64
Adresse
64
23...16
Befehls-
Speicher
Befehl 32
Schreib-
Daten $X
X
$Y
8
BR
64
15...8
0
1
2
3
o2
0
1
2
3
o3
Y
8
32
7...0
8
7...0
15...8
0
56
7...0
63...8
56
63...8
15...0
64
64
64
15...0
0
...
47
48
23...0
63...16
64
15...0
0
...
23
64
7...0
0
15
$Z
Z
39
40
63...16
3.1 Datenpfad
123
Musterlösung:
4
Add
64
64
OR
Allzweck-
Registerblock
BZ
Schreiben
o1
$X
64
64
Adresse
64
23...16
Befehls-
Speicher
Befehl 32
Schreib-
Daten $X
X
$Y
8
BR
64
15...8
0
1
2
3
o2
0
1
2
3
o3
Y
8
32
7...0
8
7...0
15...8
0
56
7...0
63...8
56
63...8
15...0
64
64
64
15...0
0
...
47
48
23...0
63...16
64
15...0
0
...
23
64
7...0
0
15
$Z
Z
39
40
63...16
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:
4
Add
64
64
OR
SR
o1
dat
BZ
Allzw.-Reg.
Schrei-
ben
Adresse
64
64
Befehls-
Speicher
Befehl
23...16
BR
15...8
32
32
Schreib- $X
Daten $X
64
X
Y
$Y
Z
$Z
7...0
64
...
64
15...8
7...0
0
63...8 64
56
7...0
7...0
0
63...8 64
15...0 56
15...0
0
63...16 64
15
47 48
23..0
23...0
0
63...24 64
23
39 40
0
1
2
3
o2
ALU
0
1
2
3
o3
adr
...
3.1 Datenpfad
125
Musterlösung:
4
Add
64
64
OR
SR
o1
dat
BZ
Allzw.-Reg.
Schrei-
ben
Adresse
64
64
Befehls-
Speicher
Befehl
23...16
BR
15...8
32
32
Schreib- $X
Daten $X
64
X
Y
$Y
Z
$Z
7...0
64
o2
ALU
0
1
2
3
o3
...
64
15...8
7...0
0
63...8 64
56
7...0
7...0
0
63...8 64
15...0 56
15...0
0
63...16 64
15
47 48
23..0
23...0
0
63...24 64
23
39 40
0
1
2
3
...
b) Wie wird beim MMIX mit dem Ergebnis der ALU verfahren?
• Schreiben ins Register X (bei den meisten Befehlen)
• Verwendung als Hauptspeicher-Adresse (Lade- und Speicherbefehle)
• Verwendung als neuer Befehlszähler (GO, JMP, BZ, BNZ, ...)
adr
126
c)
3 Mikroarchitektur
Passen Sie nachstehende Abbildung so an, dass das Ergebnis der ALU an die
benötigten Stellen geschrieben werden kann.
Eigene Lösung:
4
Add
64
0
BZ
1
Allzw.-Reg.
Schrei-
ben
Adresse
64
64
Befehls-
Speicher
Befehl
BR
23...16
15...8
32
Schreib- $X
Daten $X
$Y
Z
$Z
7...0
SR
o1
dat
64
X
Y
OR
64
...
64
15...8
7...0
0
63...8 64
56
7...0
7...0
0
63...8 64
15...0 56
15...0
0
63...16 64
15
47 48
23..0
23...0
0
63...24 64
23
39 40
0
1
2
3
o2
ALU
0
1
2
3
o3
adr
...
3.1 Datenpfad
127
Musterlösung:
4
Add
64
0
BZ
1
Allzw.-Reg.
Schrei-
ben
Adresse
64
64
Befehls-
Speicher
Befehl
BR
23...16
15...8
32
Schreib- $X
Daten $X
$Y
Z
$Z
7...0
SR
o1
dat
64
X
Y
OR
64
...
64
15...8
7...0
0
63...8 64
56
7...0
7...0
0
63...8 64
15...0 56
15...0
0
63...16 64
15
47 48
23..0
23...0
0
63...24 64
23
39 40
0
1
2
3
o2
ALU
0
1
2
3
o3
adr
...
128
3 Mikroarchitektur
d) Zeichnen Sie in nachstehende Abbildung ein, wie beim GO-Befehl die Rücksprungadresse ins Register $X geschrieben werden kann.
Eigene Lösung:
4
Add
64
0
BZ
1
0
1
Allzw.-Reg.
Schrei-
ben
Adresse
64
64
Befehls-
Speicher
Befehl
BR
23...16
15...8
32
Schreib- $X
Daten $X
$Y
Z
$Z
7...0
SR
o1
dat
64
X
Y
OR
64
...
64
15...8
7...0
0
63...8 64
56
7...0
7...0
0
63...8 64
15...0 56
15...0
0
63...16 64
15
47 48
23..0
23...0
0
63...24 64
23
39 40
0
1
2
3
o2
ALU
0
1
2
3
o3
adr
...
3.1 Datenpfad
129
Musterlösung:
4
Add
64
0
BZ
1
0
1
Allzw.-Reg.
Schrei-
ben
Adresse
64
64
Befehls-
Speicher
Befehl
BR
23...16
15...8
32
Schreib- $X
Daten $X
$Y
Z
$Z
7...0
SR
o1
dat
64
X
Y
OR
64
...
64
15...8
7...0
0
63...8 64
56
7...0
7...0
0
63...8 64
15...0 56
15...0
0
63...16 64
15
47 48
23..0
23...0
0
63...24 64
23
39 40
0
1
2
3
o2
ALU
0
1
2
3
o3
adr
...
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 VerzweigungsDetektor ein.
Eigene Lösung:
4
Add
OR
64
SR
1
BZ
0
31...24
Verzwei-
gungs-
Detektor
Allzw.-Reg.
Schrei-
ben
1 0
Adresse
64
64
Befehls-
Speicher
Befehl
23...16
BR
32
15...8
7...0
o1
Schreib- $X
Daten $X
X
Y
dat
64
$Y
64
...
$Z
Z
64
15...8
7...0
0
63...8 64
56
7...0
7...0
0
63...8 64
15...0 56
15...0
0
63...16 64
15
47 48
23..0
23...0
0
63...24 64
23
39 40
0
1
2
3
o2
ALU
0
1
2
3
o3
adr
...
3.1 Datenpfad
131
Musterlösung:
4
Add
OR
64
SR
1
BZ
0
31...24
Verzwei-
gungs-
Detektor
Allzw.-Reg.
Schrei-
ben
1 0
Adresse
64
64
Befehls-
Speicher
Befehl
23...16
BR
32
15...8
o1
Schreib- $X
Daten $X
X
Y
$Y
Z
$Z
7...0
dat
64
64
...
64
15...8
7...0
0
63...8 64
56
7...0
7...0
0
63...8 64
15...0 56
15...0
0
63...16 64
15
47 48
23..0
23...0
0
63...24 64
23
39 40
0
1
2
3
o2
ALU
0
1
2
3
o3
adr
...
!"#"$% &'()*+,-.%(*/%012'(*/%
!
&'(!)*+*,-(#.*-/!01234/*5!67*8434/*9!:;</!=*8>((!7'3,+4-=*7/*<!?'@*--*[email protected]*<(*BCBD!
!
132
3 Mikroarchitektur
0x..0
0x..1
0x..2
0x..3
0x..4
0x..5
0x..6
0x..7
TRAP 5ν
FCMP ν
FUN ν
FEQL ν
FADD 4ν
FIX 4ν
FSUB 4ν
FIXU 4ν
0x0..
0x0..
FLOT[I] 4ν
FLOTU[I] 4ν
SFLOT[I] 4ν
SFLOTU[I] 4ν
FMUL 4ν
FCMPE 4ν
FUNE ν
FEQLE 4ν FDIV 40ν FSQRT 40ν FREM 4ν
FINT 4ν
0x1..
0x1..
MUL[I] 10ν
MULU[I]als
10ν
DIV[I] den
60ν Opcode DIVU[I]
60ν und
Der Verzweigungsdetektor
bekommt
Eingangs-Werte
des Befehls
ADD[I] ν
ADDU[I] ν
SUBU[I] ν
SUB[I] ν
0x2..
den
Inhalt von
Register X. Als Ausgang
liefert der Verzweigungs-Detektor
ein einzelnes0x2..
2ADDU[I] ν
4ADDU[I] ν
8ADDU[I] ν
16ADDU[I] ν
CMP[I]
ν
CMPU[I]
NEG[I]
NEGU[I]
Bit,
das angibt,
ob verzweigt
werden
sollν (Bitwert = 1),
oder νnicht (Bitwert
= 0). ν
0x3..
0x3..
SL[I] ν
SLU[I] ν
SR[I] ν
SRU[I]ν
BN[B] ν+π
BZ[B] ν+π
BP[B] ν+π
BOD[B] ν+π
0x4..
0x4..
BNN[B] ν+π
BNZ[B] ν+π
BNP[B] ν+π
BEV[B] ν+π
PBN[B] 3ν-π
PBZ[B] 3ν-π
PBP[B] 3ν-π
PBOD[B] 3ν-π
0x5..
0x5..
PBNN[B] 3ν-π
PBNZ[B] 3ν-π
PBNP[B] 3ν-π
PBEV[B] 3ν-π
CSN[I] ν
CSZ[I] ν
CSP[I] ν
CSOD[I] ν
0x6..
0x6..
CSNN[I] ν
CSNZ[I] ν
CSNP[I] ν
CSEV[I] ν
ZSN[I] ν
ZSZ[I] ν
ZSP[I] ν
ZSOD[I] ν
f)0x7..
Wie können
Sie im Datenpfad
detektieren, ob einer
der gezeigten Verzweigungs0x7..
ZSNN[I] ν
ZSNZ[I] ν
ZSNP[I] ν
ZSEV[I] ν
befehle LDB[I]
ins Befehlsregister
geladen
wurde?
µ+ν
LDBU[I] µ+ν
LDW[I] µ+ν
LDWU[I] µ+ν
0x8..
0x8..
LDT[I] µ+ν
LDTU[I] µ+ν
LDO[I] µ+ν
LDOU[I] µ+ν
LDSF[I]
LDHT[I]
CSWAP[I]
2µ+2ν
LDUNC[I]
µ+ν BeBits 7...4
des µ+ν
Opcodes, d.h.
Bits µ+ν
31...28 des
im Befehlsregister
stehenden
0x9..
0x9..
LDVTS[I] ν
PRELD[I] ν
PREGO[I] ν
GO[I] 3ν
fehlsworts
müssen
den Wert
0100 µ+ν
haben.
STB[I]
µ+ν
STBU[I]
STW[I] µ+ν
STWU[I] µ+ν
0xA..
0xA..
STT[I] µ+ν
STTU[I] µ+ν
STO[I] µ+ν
STOU[I] µ+ν
STSF[I] µ+ν
STHT[I] µ+ν
STCO[I] µ+ν
STUNC[I] µ+ν
0xB..
0xB..
SYNCD[I]
ν Datenpfad
PREST[I]
ν
SYNCID[I]
ν
PUSHGO[I]
3ν
g) Wie können
Sie im
detektieren,
welcher
der gezeigten
VerzweigungsOR[I] ν
ORN[I] ν
NOR[I] ν
XOR[I] ν
0xC..
0xC..
befehle im
Befehlsregister
steht?
AND[I]
ν
ANDN[I] ν
NAND[I] ν
NXOR[I] ν
BDIF[I] ν
WDIF[I] ν
TDIF[I] ν
ODIF[I] ν
0xD..
0xD..
ν
ν
MOR[I] ν
MXOR[I]
ν
Bits 3...1MUX[I]
des Opcodes,
d.h.SADD[I]
Bits 27...25
des Befehlsworts
geben an,
um welchen
SETH ν
SETMH ν
SETML ν
SETL ν
INCH ν
INCHM ν
INCML ν
INCL ν
0xE..
0xE..
Befehl
es sich ORMH
handelt.
ORH ν
ν
ORML ν
ORL ν
ANDNH ν
ANDNMH ν ANDNML ν
ANDNL ν
JMP[B] ν
PUSHJ[B] ν
GETA[B] ν
PUT[I] ν
0xF..
0xF..
[UN]SAVE 20µ+ν
POP 3ν
RESUME 5ν
SYNC ν
SWYM ν
GET ν
TRIP 5ν
0x..8
0x..9 von s($X)
0x..A wird 0x..B
0x..C verzweigt?
0x..D
0x..E
0x..F
h) Bei welchen
Werten
beim BP-Befehl
!
!
!
Bei Werten s($X) > 0.
&'(!*<(B*!E;@@-*!0F!);B#G*<B9!/*(!1234/*(!*7B(2<;3,B!/*<!&422*-C*;-*[email protected];(!IJ95!;7!/*<!(;3,!/*<!)*#
+*,-(34/*[email protected]*+;7/*BD!
!
i)! Wie können Sie anhand der Bits $X detektieren, ob im Falle eines BP-Befehls
&'(!C:*;B*!E;@@-*!/*(!1234/*(!*<=;@B!(;3,!:;*!+4-=BK!
gesprungen werden muss?
!
−! 6L)!0);B!E<D!"9!/*(!C:*;B*7!E;@@-*(!
•+! Bit
63 darf nicht gesetzt sein UND
H5!:*77!(;3,!/*<!)*+*,-!;[email protected]*<*7!?*;-!/*<!&422*!"#$"[email protected]*+;7/*B!
+
!
I5!:*77!(;3,!/*<!)*+*,-!;8!M7B*<*7!?*;-!/*<!&422*• mindestens ein anderes Bit muss gesetzt sein.!"#$"[email protected]*+;7/*B!!
!
−! );B(!$5!I!M7/!H!/*(!C:*;B*7!E;@@-*(!*7B(2<*3,*7!/*<! %&'$("[email protected];(!%95!;7!/*8!(;3,!/*<!)*+*,-(#
34/*[email protected]*+;7/*B!
!
[email protected]*/*MB*BK!N88*/;'B*#O'<;'7B*!/*(!)*+*,-(!
j)[I]Tragen
Sie in nachfolgende Abbildung eine Implementierung des Verzweigungs−! ;88*/;'B*!⇔!&;<*PB42*<'7/!
ein.
−Detektors
! ADD $1,$2,$3
K!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((*[email protected]*<!'MB48'B;(3,! '7,'7/! /*(! +*,-*7/*7!
&4--'<#R*;3,*7(! 0$9! *<P'77B5! :*(,'[email protected]! ;8! V<4=<'88! 7;3,B! *W2-;C;B! ADDI! =*(3,<;*@*7! :*</*7!
8M((!!!
!
"#$%
3.1 Datenpfad
133
Opcode
8
3...1
8
63
63
6
5
4
8
0=BN
1
1=BZ
1
64
7
1
1
2=BP
64
0
3=BOD
1
1, falls Sprung
0, falls kein Sprung
1
63
5=BNZ
1
64
63
4=BNN
1
1
1
1
64
0
64
$X
6=BNP
1
7=BEV
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?
• Laden: LDB(U), LDW(U), LDT(U), LDO(U)
• Speichern: STB(U), STW(U), STT(U), STO(U)
b) Wie breit sind die Adressen des virtuellen MMIX-Datenspeichers?
64 Bit
c)
Welche Daten-Wortbreiten muss der MMIX-Datenspeicher unterstützen?
•
•
•
•
8 bit (byte)
16 bit (wyde)
32 bit (tetra)
64 bit (octa)
d) Welchen Zugriffsmodus muss der Speicher neben den Wortgrößen noch unterstützen?
• vorzeichenbehafteter Zugriff
• vorzeichenloser Zugriff
3.1 Datenpfad
e)
Über welche Ein- und Ausgänge muss der MMIX-Datenspeicher verfügen?
Eingänge:
•
•
•
•
Adresse
Dateneingang
Schreib-Takt
Zugriffsmodus (Schreiben/Lesen, Vorzeichen, Wortlänge)
Ausgang:
• Datenausgang
f)
Welche Funktion muss der MMIX-Datenspeicher aufweisen?
• Lesen von Daten:
• Benutzer legt Adresse am Adress-Eingang an
• Benutzer
legt
Modus-Information
(vorzeichenbehaftet/vorzeichenlos, Byte-Zugriff, Wyde-Zugriff, Tetra-Zugriff,
Octa-Zugriff) am Eingang Modus an
• Datenspeicher gibt entsprechendes Datenwort am Datenausgang aus
• Schreiben von Daten:
• Benutzer legt Adresse am Adress-Eingang an
• Benutzer
legt
Modus-Information
(vorzeichenbehaftet/vorzeichenlos, Byte-Zugriff, Wyde-Zugriff, Tetra-Zugriff,
Octa-Zugriff) am Eingang Modus an
• Benutzer legt abzuspeichernde Daten am Dateneingang an
• Benutzer erzeugt steigende Flanke am Takteingang
• Datenspeicher speichert bei steigender Flanke am Takteingang
das am Dateneingang anliegende Datenwort in der durch den
Zugriffsmodus ausgewählten Weise an der angelegten Adresse
135
136
3 Mikroarchitektur
g) Entwerfen Sie ein geeignetes Symbol für den MMIX-Datenspeicher
4
1
Modus Takt
64
Daten-
Eingang
64
Daten-
Adr. Ausg.
64
Daten-
Speicher
h)
Integrieren Sie den Datenspeicher in den Datenpfad.
Eigener Lösungsweg:
4
Add
OR
64
SR
64
1
BZ
0
31...24
Allzw.-Reg.
64
Schrei-
ben
012
Adresse
64
Befehls-
Speicher
Befehl
23...16
BR
32
15...8
7...0
o1
Schreib- $X
Daten $X
Mo-
dus
dat
64
X
Y
4
Verzwei-
gungs-
Detektor
$Y
64
...
$Z
Z
64
15...8
7...0
0
63...8 64
56
7...0
7...0
0
63...8 64
15...0 56
15...0 64
0
63...16
15
47 48
23..0
23...0
0
63...24 64
23
39 40
0
1
2
3
Daten-
Eingang
Daten-
Ausgang
o2
Daten-
Speicher
ALU
0
1
2
3
Takt
o3
adr
Adresse
...
3.1 Datenpfad
137
Musterlösung:
4
Add
OR
64
SR
64
1
BZ
0
31...24
Allzw.-Reg.
64
Schrei-
ben
012
Adresse
64
Befehls-
Speicher
Befehl
23...16
BR
32
15...8
o1
Schreib- $X
Daten $X
$Y
Z
$Z
7...0
Mo-
dus
dat
64
X
Y
4
Verzwei-
gungs-
Detektor
64
...
64
15...8
7...0
0
63...8 64
56
7...0
7...0
0
63...8 64
15...0 56
15...0 64
0
63...16
15
47 48
23..0
23...0
0
63...24 64
23
39 40
0
1
2
3
Daten-
Eingang
Daten-
Ausgang
o2
Daten-
Speicher
ALU
0
1
2
3
Takt
o3
adr
Adresse
...
138
3 Mikroarchitektur
Kontrolle aller Phasen: Das Steuerwerk
a)
Tragen Sie in den folgenden Datenpfad ein Blockschaltbild der Steuerung ein und
verdrahten Sie diese.
4
Add
clk_bz
mux_$X
clk_br
mux_bz
Steuerung
OR
clk_or
clk_sr
clk_ds
mo_ds
alu
v_det
mux_o3
mux_o2
SR
64
64
31...24
64
012
clk_ar
BZ
1
0
Adresse
64
Befehls-
Speicher
Befehl
23...16
BR
32
15...8
Allzw.-Reg.
Schrei-
ben
Schreib- $X
Daten $X
o1
$Y
Z
$Z
7...0
Mo-
dus
dat
64
X
Y
4
Verzwei-
gungs-
Detektor
64
...
64
15...8
7...0
0
63...8 64
56
7...0
7...0
0
63...8 64
15...0 56
15...0 64
0
63...16
15
47 48
23..0
23...0
0
63...24 64
23
39 40
0
1
2
3
Daten-
Eingang
Daten-
Ausgang
o2
Daten-
Speicher
ALU
0
1
2
3
Takt
o3
adr
Adresse
...
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.
!"!"!# $%&'%()%*+#
234)-564783798:;
1
$
$Y|Y
'KJ
&
+,- )
&"
.
&"
*
//
+
00
&"
FSG#
.54:?5-
TG.N#
.54:?5-
&"
&"
&"
&"
'
(
$
$X
%
73DC8BB
&"
$Z|Z
&"
@A+#
+BB5?,?,C
<3D-,8:5?#
&"
,?,
EFAF
(
1
@ER#
.,9?5-?,34U
<-8-37#
.54:?5-
'LLL&%
J
&
GHIF
($1
&"
@ T
&"
'
&"
&"
&"K($M
8
&"
"
'LLL&%
D
&"
&"K($M
&"
&"
(
'
('
&"
('
<-8-3754=6,>8-564?4
N?7-!B?,!G5O57564!DP9L
Q5-!&"K($M!B?7!R,6B3)-7
!
!""#$%&&'$(()*+,-./-01-23$
!
−! B5?!+3798:;#A?5-34U!B5?4-!P3,!+3798:;!B?,!U?9V47W:-?4!234)-564!X+BB5?,?4Y!<W:5?D?4!?-WLZ!
−! B5?!<-8-3754=6,>8-564?4!U?D?4!D?57[5?;79?57?!+37)34=-!B8,VD?,Y!6D!?54!*D?,;83=!83=-,8-Y!6D!B87!
.,U?D457!S3;;!57-Y!6D!B87!.,U?D457!4?U8-5O!57-!?-WL!
−! 4?D?4!B?>!+37U84U! $X!D?75-P-!B87!N?W:?49?,)!46W:!?54?4!9?5-?,?4!G8-?4837U84UY!B?,!B?4!
N?7-! B?,! G5O57564! DP9L! B5?! 6D?,?4! &"! Q5-7! B?7! .,U?D4577?7! ?54?,! E3;-5[;5)8-564! 83=45>>-\! 5>!
:&'()*+,&-)./01
2/0+3,4*5
>)*5+*5!$
84.5+*5!$
)
>)*5+*5!C
140
84.5+*5!C
3 Mikroarchitektur
>)*5+*5!*
84.5+*5!'
!
%(("$89:;$-./(01)2.,0345+$<45)=2&1>$
UND- und ODER-Einheit
+3,=4*:,)&*!=!()361,!6)1!>)*5E*51!+4=!6)1!84.5E*51!+(?!D+(1)!5)3,F!
a)
Skizzieren Sie, wie sich die 64 Bit UND-Einheit aus 64 einzelnen 1 Bit UND-
84.5+*5!)!G!=H>)*5+*5!$7!>)*5+*5!C7!I!7!>)*5+*5!*J!!
)*+,-*.!/0'(!1+*.2! Einheiten zusammensetzen lässt.
82012+92.:;%<'6*:=>*+12*-2+%
N#>)*01),!HKON!4*),J!
36
36
5
5
$
36
PQ
PQ
R
R
$
$
34
PS
$
36
34
PQ
36
$
5
34
PQ
PS
36
!
!
%(("$899;$<?/(.=$&1*$%&'()&$*+,[email protected][email protected]$&102I$
!""#$%&'($)*+",-$./0$!.1"2.$034$56789:/;3:<$=!67$./:<>$
b) Skizzieren Sie, wie sich die 64 Bit ODER-Einheit aus 64 einzelnen 1 Bit ODERT#>)*01),!HOT!4*),J! Einheiten zusammensetzen lässt.
%&'(&)*&+,-$.//0&+&+$1)/$2134+5(0&+&+$
PQ
R
89:;9<<*-=-=!
<<*-=.!!"#$!)*+>9+>?#7*.?!/@A-=9+<!$!1+<[email protected]=9+<!%2!
-B-=.!-*+!)=>-;+*?#7*.!1+<!-*+!C;-=.=9>?#7*.!!
PQ
R
$
$
R
$
PQ
PQ
PQ
@A-=9+<!$
@A-=9+<!%
C;-=.=9>!*+!
+DE,?.-!F.-::-
5
5
$
$
5
$
5
$
5
5PQ
5
$
PS)=>-;+*?
PS
PS
%(("$89J;$<?/(.=$&1*$%&'()&$*+,$HKFLEF015+02$GHL$&102I$
!""#$%[email protected]($A34<3<2"3--3$%8B:<$C2-"200:3434$
5
$
$
5
!
!
;-=.=9>!-+.?A=*E,.!&'(#G-=H+IAB1+>!<[email protected]=9+<-+!
"#$$
=>-;+*?!-+.?A=*E,[email protected]#G-=H+IAB1+>!<[email protected]=9+<-+!
$!O9..-=:91BP-*.
80
Σ
LM1.
@A-=9+<!$
@A-=9+<!%
)=>-;+*?
C;-=.=9>
/[email protected]
!
!""#$%?%($)*+",-$./0$D32-:E:34./F$3:/3E$C2-"200:3434E$
QQ.!Q9+!9+R!<9??!<[email protected]#O9..-=!+*E,.!S*-!*+!T9A*.-:!6U%U$!91?!&'(#[email protected]()K#!1+<!'VL8W#
9..-=+!91B>-;91.!S1=<-R!?M+<-=+!9:?!X-E,.-?Y!89=<S9=-#O9..-=!P1=!G-=BI>1+>!?.-,.R!<9++!;-#
D>.! <*-! (1=E,:91BP-*.! <1=E,! <-+! 89:;9<<*-=-=! >-+91! $! O9..-=:91BP-*.R! <9! <9?! &'(#! 1+<! <9?!
@K#O9..-=!A9=9::-:!<1=E,:91B-+!S-=<-+!
3.2 Aufbau des Rechenwerks (ALU)
141
Schiebe-Einheit
a)
Was ist der Unterschied zwischen vorzeichenbehaftetem Rechts-Schieben und
vorzeichenlosem Rechts-Schieben?
• Beim vorzeichenbehafteten Rechts-Schieben wird mit den Bit-Werten des
höchstwertigsten Bits aufgefüllt, d.h. mit den Werten des ursprünglichen
Bit 63.
• Beim vorzeichenlosen Rechts-Schieben werden frei werdende BitPositionen mit 0 aufgefüllt.
b) Was ist der Unterschied zwischen vorzeichenbehaftetem Links-Schieben und
vorzeichenlosem Links-Schieben?
• Bei vorzeichenbehaftetem Links-Schieben kann ein Interrupt ausgelöst
werden, wenn durch das Schieben Bit-Werte 6= 0 gelöscht werden.
• Bei vorzeichenlosem Links-Schieben kann kein Interrupt ausgelöst werden.
142
c)
3 Mikroarchitektur
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 implementieren kann.
2
2
00
01
10
11
SL[I]
SLU[I]
SR[I]
SRU[I]
k
Überlauf
3
0
1
3
3
3
0
Eingang
0
8
7
2
0
0
Ausgang
8
1
7
3
2
3
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 Halbaddierer beschreibt.
Bit 1
Bit 2
Ergebnis
Überlauf
0
0
1
1
0
1
0
1
0
1
1
0
0
0
0
1
b) Welcher logischer Funktion entspricht die Berechnung des Ergenbnis-Bits?
XOR
c)
Welcher logischer Funktion entspricht die Berechnung des Überlauf-Bits?
UND
d) Entwerfen Sie eine Implementierung des Halbaddierers.
Eigene Lösung:
Bit 1
Bit 2
Überlauf
Ergebnis
144
3 Mikroarchitektur
Musterlösung:
e)
f)
Bit 1
Bit 2
Überlauf
Ergebnis
Führen Sie die binäre Addition 0110 1101 + 0011 0110 durch.
0
0
1
0
1
1
0
1
1
0
1
1
1
1
1
1
0
1
0
0
1
1
0
1
1
0
0
1
1
Kann die durchgeführte Addition vom entworfenen Halbaddierer gelöst werden?
Nein. Die Überläufe werden nicht berücksichtigt.
g) Wie müsste ein Addierer aussehen, damit die oben durchgeführte Addition berechnet werden kann?
Der Addierer müsste drei Eingangsbits (2 Operanden-Bits und 1 Bit Überlauf aus
vorheriger Stelle) zu einem Ergebnis-Bit und einem Überlauf-Bit addierern.
3.2 Aufbau des Rechenwerks (ALU)
145
3.2 Aufbau des Rechenwerks (ALU)
145
Addition von drei einzelnen Bits: 1 Bit Volladdierer
Addition
von drei einzelnen
Bits: 1 Bit Volladdierer
a) Entwerfen
Sie eine Wertetabelle,
welche die Addition dreier Eingangsbits (Bit 1, Bit
a)
2 und Überlauf-Eingang) zu einem Ergebnis- und Überlauf-Bit (Ausgang) addiert.
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:
Überlauf (Eing.)
Bit 1
0
0
0
0
0
1
0
1
1
0
1
0
3.2 Aufbau des Rechenwerks (ALU)
1
1
1
1
Bit 2
Überlauf (Ausg.)
0
1
0
1
0
1
0
1
0
0
0
3
1
0
4 1
1
1
a)
1 0
1 wie HA
1
0
1
2
0 invertiert
145
0 wie HA
1
3
Überlauf
1 XOR Bit 2)
Addition von drei einzelnen
Bits:UND
1 Bit(Bit
Volladdierer
Ergebnis
Bit 1 UND Bit 2
Musterlösung:
Entwerfen
Sie eine Wertetabelle, welche die Addition dreier Eingangsbits (Bit 1, Bit
2 und Überlauf-Eingang) zu einem Ergebnis- und Überlauf-Bit (Ausgang) addiert.
Überlauf (Eing.)
Bit 1
Bit 2
Überlauf (Ausg.)
Ergebnis
0
0
0
0
1 0
0
0
1
0
1 wie HA
b) Schauen Sie sich die aufgestellte Wertetabelle gut an und überlegen Sie,
wie man
0
1
0
0
1
das Ergebnis-Bit berechnen könnte. Schreiben Sie
3 es auf!
0
1
1
1
0
1
0
0
0
1
2 wie zuvor
• Für den Fall Überlauf (Eing.) = 0 berechnet 4
man das Ergebnis
1
0
1
1
0 invertiert
mit dem Halbaddierer.
1
1
0
1
0 wie HA
• Für den Fall Überlauf (Eing.) = 1 muss man das Ergebnis einfach invertie1
1
1
1
1
3
ren.
Überlauf UND (Bit 1 XOR Bit 2)
Da die XOR-Funktion
Bit 1 UND Bit 2
• für den Fall, dass ein Eingang auf 0 liegt, den anderen Eingang einfach
an den Ausgang weiterleitet und
• für den Fall, dass ein Eingang auf 1 liegt, den anderen Eingang invertiert
an den Ausgang weiterleitet,
kann man einfach das Ergebnis-Bit des Halbaddierers mit dem Eingangs-Überlauf
Bit XOR-verknüpfen.
b) Schauen Sie sich die aufgestellte Wertetabelle gut an und überlegen Sie, wie man
das Ergebnis-Bit berechnen könnte. Schreiben Sie es auf!
• Für den Fall Überlauf (Eing.) = 0 berechnet man das Ergebnis wie zuvor
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!
• Für den Fall Überlauf (Eing.) = 0 berechnet man das Ergebnis wie zuvor
mit dem Halbaddierer.
• Für den Fall Überlauf (Eing.) = 1 muss man das Ergebnis einfach invertieren.
Da die XOR-Funktion
• für den Fall, dass ein Eingang auf 0 liegt, den anderen Eingang einfach
an den Ausgang weiterleitet und
• für den Fall, dass ein Eingang auf 1 liegt, den anderen Eingang invertiert
an den Ausgang weiterleitet,
kann man einfach das Ergebnis-Bit des Halbaddierers mit dem Eingangs-Überlauf
Bit XOR-verknüpfen.
3.2 Aufbau des Rechenwerks (ALU)
c)
147
Tragen Sie Ihre Lösung in nachstehende Volladdierer-Schaltung ein.
Eigene Lösung:
Bit 1
Überlauf (Ausg.)
Bit 2 Überlauf (Eing.)
Ergebnis
Musterlösung:
Bit 1
Überlauf (Ausg.)
Bit 2 Überlauf (Eing.)
Ergebnis
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!
Das Ausgangs-Überlauf-Bit ist gesetzt,
• wenn beide Operanden-Bits (Bit 1 UND Bit 2) gesetzt sind ODER
• wenn Bit 1 und Bit 2 unterschiedlich sind (d.h. die XOR-Verknüpfung
ergibt 1) UND der Überlauf-Eingang 1 ist.
3.2 Aufbau des Rechenwerks (ALU)
e)
149
Tragen Sie Ihre Lösung in nachstehende Volladdierer-Schaltung ein.
Eigene Lösung:
Bit 1
Überlauf (Ausg.)
Bit 2 Überlauf (Eing.)
Ergebnis
Musterlösung:
Bit 1
Überlauf (Ausg.)
Bit 2 Überlauf (Eing.)
Ergebnis
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:
Zahl 2:
Zahl 1:
X
X
X
X
X
X
X
X
0
Bit 1
Bit 2 Über-
lauf
...
VA 63
Überl.
Bit 1
Erg.
Bit 2 Über-
lauf
Bit 1
VA 2
Überl.
Bit 2 Über-
lauf
Bit 1
VA 1
Erg.
Überl.
Bit 2 Über-
lauf
VA 0
Erg.
Überl.
Erg.
Überlauf Vor-
zeichenlose Zah-
len (beim MMIX nicht verwendet)
Ergebnis:
X
X
X
X
Musterlösung:
Zahl 2:
Zahl 1:
X
X
X
X
X
X
X
X
0
Bit 1
Bit 2 Über-
lauf
...
VA 63
Überl.
Bit 1
Erg.
Bit 2 Über-
lauf
Bit 1
VA 2
Überl.
Bit 2 Über-
lauf
Bit 1
VA 1
Erg.
Überl.
Bit 2 Über-
lauf
VA 0
Erg.
Überl.
Erg.
Überlauf Vor-
zeichenlose Zah-
len (beim MMIX nicht verwendet)
Ergebnis:
X
X
X
X
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?
Um Zahl 2 von Zahl 1 zu subtrahieren, müsste man Zahl 2 negieren, d.h. alle Bits
invertieren und dann 1 addieren. Nach der Negation kann man einfach die beiden
Zahlen addieren und erhält das Ergebnis von Zahl 1 - Zahl 2.
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:
Zahl 2:
Zahl 1:
X
X
X
X
X
X
X
X
sub/add
Überlauf-
Erkennung
Vorzeichen-
behaftete
Zahlen
Überlauf
Vorzeichen-
behaftete
Zahlen
0
Bit 1
1
Bit 2
0
Über-
lauf
...
VA 63
Überl.
Bit 1
Erg.
1
Bit 2
0
Über-
lauf
VA 2
Überl.
Bit 1
1
Bit 2
0
Über-
lauf
VA 1
Erg.
Überl.
Bit 1
1
Bit 2
Über-
lauf
VA 0
Erg.
Überl.
Erg.
Überlauf Vor-
zeichenlose Zah-
len (beim MMIX nicht verwendet)
Ergebnis:
X
X
X
X
152
3 Mikroarchitektur
Musterlösung:
Zahl 2:
Zahl 1:
X
X
X
X
X
X
X
X
sub/add
Überlauf-
Erkennung
Vorzeichen-
behaftete
Zahlen
Überlauf
Vorzeichen-
behaftete
Zahlen
0
Bit 1
1
Bit 2
0
Über-
lauf
...
VA 63
Überl.
Bit 1
Erg.
1
Bit 2
0
Über-
lauf
VA 2
Überl.
Bit 1
1
Bit 2
0
Über-
lauf
VA 1
Erg.
Überl.
Bit 1
1
Bit 2
Über-
lauf
VA 0
Erg.
Überl.
Erg.
Überlauf Vor-
zeichenlose Zah-
len (beim MMIX nicht verwendet)
Ergebnis:
X
X
X
X
3.2 Aufbau des Rechenwerks (ALU)
153
Multiplikation
Multiplikation 11 · 13 = 143 im Binärsystem, Wortbreite = 4
Start
Initialisierung:
MR3..0 ⟵ u'4(Multiplikand)
PR8..4 ⟵ u'5(0)
PR3..0 ⟵ u'4(Multiplikator)
PR0 = 1
ja
nein
PR8..4 ⟵ u'5( u(PR7..4) + u(MR3..0) )
PR ⟵ (PR >>u 1)
viermal
gemacht?
ja
Ende
nein
154
a)
3 Mikroarchitektur
Geben Sie den Inhalt des Multiplikand-Registers MR und den Inhalt des ProduktRegisters PR für den Zeitpunkt nach der Initialisierung an.
Eigene Lösung:
3
2
1
0
1 1 0 1
MR
ADD
8
7
6
5
4
3
2
1
0
0 0 0 0 0 1 0 1 1
PR
Musterlösung:
3
2
1
0
1 1 0 1
MR
ADD
8
7
6
5
4
3
2
1
0
0 0 0 0 0 1 0 1 1
PR
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:
Nach Addition:
Nach Schieben:
3
2
1
0
3
1 1 0 1
7
6
1
0
1 1 0 1
MR
ADD
8
2
MR
ADD
5
4
3
2
1
0
0 1 1 0 1 1 0 1 1
8
PR
7
6
5
4
3
2
1
0
0 0 1 1 0 1 1 0 1
PR
Musterlösung:
Nach Addition:
Nach Schieben:
3
2
1
0
3
1 1 0 1
7
6
5
1
0
1 1 0 1
MR
ADD
8
2
MR
ADD
4
3
2
1
0
0 1 1 0 1 1 0 1 1
8
PR
7
6
5
4
3
2
1
0
0 0 1 1 0 1 1 0 1
PR
156
c)
3 Mikroarchitektur
Tragen Sie in nachfolgende Abbildung die nach der zweiten Runde in den Registern
MR und PR gespeicherten Daten ein.
Eigene Lösung:
Nach Addition:
Nach Schieben:
3
2
1
0
3
1 1 0 1
7
6
1
0
1 1 0 1
MR
ADD
8
2
MR
ADD
5
4
3
2
1
0
1 0 0 1 1 1 1 0 1
8
PR
7
6
5
4
3
2
1
0
0 1 0 0 1 1 1 1 0
PR
Musterlösung:
Nach Addition:
Nach Schieben:
3
2
1
0
3
1 1 0 1
7
6
5
1
0
1 1 0 1
MR
ADD
8
2
MR
ADD
4
3
2
1
0
1 0 0 1 1 1 1 0 1
8
PR
7
6
5
4
3
2
1
0
0 1 0 0 1 1 1 1 0
PR
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:
Nach Addition:
Nach Schieben:
3
2
1
0
3
1 1 0 1
7
6
1
0
1 1 0 1
MR
ADD
8
2
MR
ADD
5
4
3
2
1
0
0 1 0 0 1 1 1 1 0
8
PR
7
6
5
4
3
2
1
0
0 0 1 0 0 1 1 1 1
PR
Musterlösung:
Nach Addition:
Nach Schieben:
3
2
1
0
3
1 1 0 1
7
6
5
1
0
1 1 0 1
MR
ADD
8
2
MR
ADD
4
3
2
1
0
0 1 0 0 1 1 1 1 0
8
PR
7
6
5
4
3
2
1
0
0 0 1 0 0 1 1 1 1
PR
158
e)
3 Mikroarchitektur
Tragen Sie in nachfolgende Abbildung die nach der vierten Runde in den Registern
MR und PR gespeicherten Daten ein.
Eigene Lösung:
Nach Addition:
Nach Schieben:
3
2
1
0
3
1 1 0 1
7
6
1
0
1 1 0 1
MR
ADD
8
2
MR
ADD
5
4
3
2
1
0
1 0 0 0 1 1 1 1 1
8
PR
7
6
5
4
3
2
1
0
0 1 0 0 0 1 1 1 1
PR
Musterlösung:
Nach Addition:
Nach Schieben:
3
2
1
0
3
1 1 0 1
7
6
5
1
0
1 1 0 1
MR
ADD
8
2
MR
ADD
4
3
2
1
0
1 0 0 0 1 1 1 1 1
8
PR
7
6
5
4
3
2
1
0
0 1 0 0 0 1 1 1 1
PR
3.2 Aufbau des Rechenwerks (ALU)
f)
159
Wie lautet das Ergebnis der Multiplikation?
100011112 = 14310
Multiplikation 13 · 5 = 65 im Binärsystem, Wortbreite = 4
Start
Initialisierung:
MR3..0 ⟵ u'4(Multiplikand)
PR8..4 ⟵ u'5(0)
PR3..0 ⟵ u'4(Multiplikator)
PR0 = 1
ja
nein
PR8..4 ⟵ u'5( u(PR7..4) + u(MR3..0) )
PR ⟵ (PR >>u 1)
viermal
gemacht?
ja
Ende
nein
160
a)
3 Mikroarchitektur
Tragen Sie in nachfolgende Abbildung den Inhalt der Register MR und PR bei der
Multiplikation 13 · 5 = 65 ein.
Eigene Lösung:
Multiplikator: 13; Multiplikand: 5
MR:
0 1 0 1
ADD
PR:
0 0 0 0 0 1 1 0 1
Nach Addition:
Nach Schieben:
Initialisierung
0 0 1 0 1 1 1 0 1
0 0 0 1 0 1 1 1 0
Erste Runde
Nach Addition:
Nach Schieben:
0 0 0 0 1 0 1 1 1
Nach Addition:
0 0 1 1 0 0 1 1 1
Nach Schieben:
0 0 0 1 1 0 0 1 1
Nach Addition:
0 1 0 0 0 0 0 1 1
Nach Schieben:
0 0 1 0 0 0 0 0 1
Zweite Runde
Dritte Runde
Vierte Runde
3.2 Aufbau des Rechenwerks (ALU)
161
Musterlösung:
MR:
0 1 0 1
ADD
PR:
0 0 0 0 0 1 1 0 1
Nach Addition:
0 0 1 0 1 1 1 0 1
Nach Schieben:
0 0 0 1 0 1 1 1 0
Initialisierung
Erste Runde
Nach Addition:
Nach Schieben:
0 0 0 0 1 0 1 1 1
Nach Addition:
0 0 1 1 0 0 1 1 1
Nach Schieben:
0 0 0 1 1 0 0 1 1
Nach Addition:
0 1 0 0 0 0 0 1 1
Nach Schieben:
0 0 1 0 0 0 0 0 1
Zweite Runde
Dritte Runde
Vierte Runde
162
3 Mikroarchitektur
Multiplikations-Hardware
Nachfolgende Abbildung zeigt noch einmal den Multiplikationsalgorithmus und das
verwendete Prinzip-Schaltbild.
Start
Initialisierung:
MR3..0 ⟵ u'4(Multiplikand)
PR8..4 ⟵ u'5(0)
PR3..0 ⟵ u'4(Multiplikator)
PR0 = 1
ja
nein
PR8..4 ⟵ u'5( u(PR7..4) + u(MR3..0) )
PR ⟵ (PR >>u 1)
nein
viermal
gemacht?
ja
Ende
3
2
1
0
MR
ADD
8
7
6
5
4
3
2
1
0
PR
3.2 Aufbau des Rechenwerks (ALU)
a)
163
Vervollständigen Sie nachfolgende Schaltung so, dass sie den gezeigten Multiplikationsalgorithmus implementiert.
Eigene Lösung:
Steuerung
1
0
n
n
n
Multiplikator
n
Init/>>1
0
n 0..n-1
PR
0..n-1
2n
1
n..2n
n..2n-1
Produkt
0
n+1
1
2n
n+1
0
n
Addierer
MR
Multiplikand
n
n
n
164
3 Mikroarchitektur
Musterlösung:
Steuerung
1
0
n
n
n
Multiplikator
n
Init/>>1
0
n 0..n-1
PR
0..n-1
2n
1
n..2n
n..2n-1
Produkt
0
n+1
1
2n
n+1
0
n
Addierer
MR
Multiplikand
n
n
n
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.
Steuerung
1 PR
0
clk_mkand
multiplexer
init/>>1
clk_produkt
0
Multiplikator
n
n
n
n
Init/>>1
0
n 0..n-1
PR
0..n-1
2n
1
n..2n
n..2n-1
Produkt
0
n+1
1
2n
n+1
0
n
Addierer
MR
Multiplikand
n
Start
n
n
Initialisierung:
MR3..0 ⟵ u'4(Multiplikand)
PR8..4 ⟵ u'5(0)
PR3..0 ⟵ u'4(Multiplikator)
PR0 = 1
ja
nein
PR8..4 ⟵ u'5( u(PR7..4) + u(MR3..0) )
PR ⟵ (PR >>u 1)
viermal
gemacht?
ja
Ende
nein
166
a)
3 Mikroarchitektur
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:
immer
1
Initialisierung
clk_mkand= 0
PR0 = 1
2
Initialisierung
clk_mkand= 1
3
Addieren
clk_mkand= 0
clk_produkt= 0
clk_produkt= 1
clk_produkt= 0
multiplexer= 0
multiplexer= 0
multiplexer= 1
init/>>1= 0
init/>>1= 0
init/>>1= 0
immer
PR0 = 0
Runde_n = 0 && PR0 = 0
6
Schieben
clk_mkand= 0
5
Schieben
clk_mkand= 0
4
Addieren
clk_mkand= 0
clk_produkt= 1
clk_produkt= 0
clk_produkt= 1
multiplexer= X
multiplexer= X
multiplexer= 1
init/>>1= 1
immer
init/>>1= 1
immer
Runde_n = 1
7
Ende
clk_mkand= 0
Runde_n = 0 && PR0 = 1
clk_produkt= 0
multiplexer= X
init/>>1= X
immer
init/>>1= 0
3.2 Aufbau des Rechenwerks (ALU)
167
Musterlösung:
immer
1
Initialisierung
clk_mkand= 0
PR0 = 1
2
Initialisierung
clk_mkand= 1
3
Addieren
clk_mkand= 0
clk_produkt= 0
clk_produkt= 1
clk_produkt= 0
multiplexer= 0
multiplexer= 0
multiplexer= 1
init/>>1= 0
init/>>1= 0
init/>>1= 0
immer
PR0 = 0
Runde_n = 0 && PR0 = 0
6
Schieben
clk_mkand= 0
5
Schieben
clk_mkand= 0
4
Addieren
clk_mkand= 0
clk_produkt= 1
clk_produkt= 0
clk_produkt= 1
multiplexer= X
multiplexer= X
multiplexer= 1
init/>>1= 1
immer
init/>>1= 1
immer
Runde_n = 1
7
Ende
clk_mkand= 0
Runde_n = 0 && PR0 = 1
clk_produkt= 0
multiplexer= X
init/>>1= X
immer
init/>>1= 0
168
3 Mikroarchitektur
Multiplexer-basierte Implementierung der Steuerung
Für den Fall n = 4 soll die Steuerung wie folgt implementiert werden:
clk_mkand
clk_produkt
multiplexer
Kombinatorische
Schaltung
init/>>1
3
...
clk
...
D0 Q0
D2 Q2
D3 Q3
D4 Q4
2
2
3
PR0
Das Zustandsregister speichert die Information über
• den aktuellen Zustand (d.h. in welchem Zustand des Zustandsdiagramms sich
die Steuerung gerade befindet) und
• den Rundenzähler (d.h. welche Iterations-Runde (vgl. Ablauf-Diagramm) gerade
ausgeführt wird).
a)
In welchen Bits des Zustandsregisters wird
• der aktuelle Zustand und
• die aktuelle Runde
gespeichert?
• Zustand: 3 Bits notwendig, da dld(7)e = 3 ) Bits 0, 1, 2
• Runde: 2 Bits notwendig, da ld(4) = 2; ) Bits 3 and 4
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 Steuereingang des Multiplexers verbunden werden?
Eigene Lösung:
Aktueller Zustand
3
0 0 0 0
0 0 0 0
1 1 0 0
0 0 1 0
0 1 1 0
0 0 X 1
0 1 X 1
0 0 X X
4
4
4
4
4
4
4
4
0
1
2
3
clk_mkand
3
2
clk_produkt
1
multiplexer
0
init/>>1
4
5
6
7
4
170
3 Mikroarchitektur
Musterlösung:
Aktueller Zustand
3
0 0 0 0
0 0 0 0
1 1 0 0
0 0 1 0
0 1 1 0
0 0 X 1
0 1 X 1
0 0 X X
4
4
4
4
4
4
4
4
0
1
2
3
clk_mkand
3
2
clk_produkt
1
multiplexer
0
init/>>1
4
5
6
7
4
3.2 Aufbau des Rechenwerks (ALU)
c)
171
Tragen Sie in nachfolgende Abbildung diejenigen Eingangswerte ein, welche die
Zustands-Übergangs-Funktion aller unbedinger Verzweigungen implementieren.
Eigene Lösung:
Aktueller
Zustand
3
0 0 1
0 1 0
3
3
3
1 0 0
1 0 1
1 1 0
3
3
3
3
1 1 1
3
0
1
2
2
3
1
4
5
6
7
3
0
172
3 Mikroarchitektur
Musterlösung:
Aktueller
Zustand
3
0 0 1
0 1 0
0
3
1
3
2
3
1 0 0
1 0 1
1 1 0
3
1
4
3
3
0
5
3
6
3
1 1 1
2
3
7
3
d) Tragen Sie in nachfolgende Abbildung ein Schaltung ein, die den Folgezustand
des Zustands 2 liefert.
Eigene Lösung:
2
PR0
1
1
3
1
PR0 = 1 => 011 (3); PR0 = 0 => 101 (5)
0
Folgezustand
von Zustand 2
3.2 Aufbau des Rechenwerks (ALU)
173
Musterlösung:
2
1
PR0
1
3
0
1
PR0 = 1 => 011 (3); PR0 = 0 => 101 (5)
e)
Folgezustand
von Zustand 2
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)
0
1
3
0
2
1
0
2
ADD
2
Runde
(Bit 4, 3)
2
2
2
Neue Runde
(Bit 4, 3)
174
3 Mikroarchitektur
Musterlösung:
Zustand
(Bit 2 ... 0)
0
1
0
3
1
0
2
2
ADD
2
2
Runde
(Bit 4, 3)
f)
2
Neue Runde
(Bit 4, 3)
2
Tragen Sie in nachfolgende Abbildung eine Implementierung des Runde_nDetektors 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)
2
1
2
1
Runde_n
Musterlösung:
Runde
(Bit 4,3)
Runde_n
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
1
7
3
1
1
3
0
3
3
5
0
3
Folgezustand
von Zustand 6
3
PR0
1
Musterlösung:
Runde_n
1
7
3
1
1
3
0
3
3
5
3
PR0
1
0
3
Folgezustand
von Zustand 6
176
h)
3 Mikroarchitektur
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:
Runde_n
1
1
2
3
Folgezustand
von Zustand 6
3
Folgezustand
von Zustand 6
1
1
PR0
1
Runde_n = 0 && PR0 = 0:
Runde_n = 0 && PR0 = 1:
Runde_n = 1:
101
011
111
1
0
3
1
Musterlösung:
Runde_n
1
1
2
1
1
PR0
1
Runde_n = 0 && PR0 = 0:
Runde_n = 0 && PR0 = 1:
Runde_n = 1:
101
011
111
1
1
0
3
3.2 Aufbau des Rechenwerks (ALU)
177
ROM-basierte Implementierung der Steuerung
In diesem Abschnitt soll die Multiplizierer-Steuerung mit nachfolgend abgebildeter ROMbasierten Schaltung implementiert werden.
clk_mkand
clk_produkt
multiplexer
init/>>1
Q0
Q1
Q2
Q3
Q4
ROM
5 4 3 2 1 0
clk
D0
D1
D2
D3
D4
8 7 6 5 4 3 2 1 0
PR0
1
Initialisierung
clk_mkand= 0
immer
2
Initialisierung
clk_mkand= 1
PR0 = 1
3
Addieren
clk_mkand= 0
clk_produkt= 0
clk_produkt= 1
clk_produkt= 0
multiplexer= 0
multiplexer= 0
multiplexer= 1
init/>>1= 0
init/>>1= 0
init/>>1= 0
Runde_n = 0 && PR0 = 0
immer
PR0 = 0
6
Schieben
clk_mkand= 0
5
Schieben
clk_mkand= 0
4
Addieren
clk_mkand= 0
clk_produkt= 1
clk_produkt= 0
clk_produkt= 1
multiplexer= X
multiplexer= X
multiplexer= 1
init/>>1= 1
init/>>1= 1
immer
immer
Runde_n = 1
7
Ende
clk_mkand= 0
clk_produkt= 0
Runde_n = 0 && PR0 = 1
multiplexer= X
init/>>1= X
immer
init/>>1= 0
178
a)
3 Mikroarchitektur
Welche Organisation hat das ROM?
Das ROM kann 64 Datenworte zu je 9 Bit speichern.
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:
PR0
Runde
Zust.
Ausgang
Folgerunde
Folgezust.
Zust. 0:
0
1
00
00
000
000
0000
0000
00
00
001
001
Zust. 1:
0
1
00
00
001
001
0000
0000
00
00
010
010
Zust. 2:
0
1
00
00
010
010
1100
1100
00
00
101
011
PR0
Runde
Zust.
Ausgang
Folgerunde
Zust. 0:
0
1
00
00
000
000
0000
0000
00
00
001
001
Zust. 1:
0
1
00
00
001
001
0000
0000
00
00
010
010
Zust. 2:
0
1
00
00
010
010
1100
1100
00
00
101
011
Musterlösung:
Folgezust.
3.2 Aufbau des Rechenwerks (ALU)
c)
179
Geben Sie den Inhalt des ROM-Speichers für Zustand 3 an.
Eigene Lösung:
Hinweis: Da in Zustand 3 nur im Fall PR0 = 1 verzweigt wird, kommt PR0 = 0 nicht
vor ) nur PR0 berücksichtigen.
Zustand 3:
PR0
Runde
Zust.
Ausgang
Folgerunde
1
1
1
1
00
01
10
11
011
011
011
011
0010
0010
0010
0010
00
01
10
11
PR0
Runde
Zust.
Ausgang
Folgerunde
1
1
1
1
00
01
10
11
011
011
011
011
0010
0010
0010
0010
00
01
10
11
Folgezust.
100
100
100
100
Musterlösung:
Zustand 3:
Folgezust.
100
100
100
100
180
3 Mikroarchitektur
d) Geben Sie den Inhalt des ROM-Speichers für Zustand 4 an.
Eigene Lösung:
Hinweis: In Zustand 4 müssen sowohl PR0 = 0 als auch PR0 = 1 berücksichtigt
werden, da sich die Werte während der Addition ändern können.
Zustand 4:
PR0
Runde
Zust.
Ausgang
Folgerunde
0
0
0
0
1
1
1
1
00
01
10
11
00
01
10
11
100
100
100
100
100
100
100
100
0110
0110
0110
0110
0110
0110
0110
0110
00
01
10
11
00
01
10
11
PR0
Runde
Zust.
Ausgang
Folgerunde
0
0
0
0
1
1
1
1
00
01
10
11
00
01
10
11
100
100
100
100
100
100
100
100
0110
0110
0110
0110
0110
0110
0110
0110
00
01
10
11
00
01
10
11
Folgezust.
101
101
101
101
101
101
101
101
Musterlösung:
Zustand 4:
Folgezust.
101
101
101
101
101
101
101
101
3.2 Aufbau des Rechenwerks (ALU)
e)
181
Geben Sie den Inhalt des ROM-Speichers für Zustand 5 an.
Eigene Lösung:
Zustand 5:
PR0
Runde
Zust.
Ausgang
Folgerunde
0
0
0
0
1
1
1
1
00
01
10
11
00
01
10
11
101
101
101
101
101
101
101
101
00X1
00X1
00X1
00X1
00X1
00X1
00X1
00X1
01
10
11
00
01
10
11
00
PR0
Runde
Zust.
Ausgang
Folgerunde
0
0
0
0
1
1
1
1
00
01
10
11
00
01
10
11
101
101
101
101
101
101
101
101
00X1
00X1
00X1
00X1
00X1
00X1
00X1
00X1
01
10
11
00
01
10
11
00
Folgezust.
110
110
110
110
110
110
110
110
Musterlösung:
Zustand 5:
Folgezust.
110
110
110
110
110
110
110
110
182
f)
3 Mikroarchitektur
Geben Sie den Inhalt des ROM-Speichers für Zustand 6 an.
Eigene Lösung:
Zustand 6:
PR0
Runde
Zust.
Ausgang
Folgerunde
0
0
0
0
1
1
1
1
00
01
10
11
00
01
10
11
110
110
110
110
110
110
110
110
01X1
01X1
01X1
01X1
01X1
01X1
01X1
01X1
00
01
10
11
00
01
10
11
PR0
Runde
Zust.
Ausgang
Folgerunde
0
0
0
0
1
1
1
1
00
01
10
11
00
01
10
11
110
110
110
110
110
110
110
110
01X1
01X1
01X1
01X1
01X1
01X1
01X1
01X1
00
01
10
11
00
01
10
11
Folgezust.
111
101
101
101
111
011
011
011
Musterlösung:
Zustand 6:
Folgezust.
111
101
101
101
111
011
011
011
3.2 Aufbau des Rechenwerks (ALU)
183
g) Geben Sie den Inhalt des ROM-Speichers für Zustand 7 an.
Eigene Lösung:
Zustand 7:
PR0
Runde
Zust.
Ausgang
Folgerunde
0
0
0
0
1
1
1
1
00
01
10
11
00
01
10
11
111
111
111
111
111
111
111
111
00XX
00XX
00XX
00XX
00XX
00XX
00XX
00XX
00
00
00
00
00
00
00
00
PR0
Runde
Zust.
Ausgang
Folgerunde
0
0
0
0
1
1
1
1
00
01
10
11
00
01
10
11
111
111
111
111
111
111
111
111
00XX
00XX
00XX
00XX
00XX
00XX
00XX
00XX
00
00
00
00
00
00
00
00
Folgezust.
111
111
111
111
111
111
111
111
Musterlösung:
Zustand 7:
Folgezust.
111
111
111
111
111
111
111
111
184
3 Mikroarchitektur
3.3 Pipelining
185
3.3 Pipelining
Rückblick: Bisheriger Datenpad = Multicycle-Datenpfad
Nachfolgende Abbildung zeigt den bisherigen Datenpfad:
4
Add
clk_bz
mux_$X
clk_br
mux_bz
Steuerung
OR
clk_or
clk_sr
clk_ds
mo_ds
alu
v_det
mux_o3
mux_o2
SR
64
64
31...24
64
012
clk_ar
BZ
1
0
Adresse
64
Befehls-
Speicher
Befehl
23...16
BR
32
15...8
7...0
Allzw.-Reg.
Schrei-
ben
Schreib- $X
Daten $X
o1
Mo-
dus
dat
64
X
Y
4
Verzwei-
gungs-
Detektor
$Y
64
Daten-
Ausgang
o2
Daten-
Speicher
ALU
0
1
2
3
Daten-
Eingang
adr
Adresse
o3
...
$Z
Z
64
15...8
7...0
0
63...8 64
56
7...0
7...0
0
63...8 64
15...0 56
15...0 64
0
63...16
15
47 48
23..0
23...0
0
63...24 64
23
39 40
0
1
2
3
Takt
...
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
a)
3 Mikroarchitektur
Beschreiben Sie den Ablauf der Befehlsausführung.
• Die Steuerung taktet den Befehlszähler BZ, um die Adresse des als
nächstes auszuführenden Befehls in den Befehlszähler zu laden.
• Der Befehls-Speicher gibt an seinem Ausgang den durch den Befehlszähler adressierten Befehl aus
• Die Steuerung taktet das Befehlsregister BR, um den vom Befehlsspeicher
ausgegebenen Befehl im Befehlsregister abzulegen.
• Im Zustandsautomat der der Steuerung wird zum UnterZustandsautomaten des aktuellen Befehls verzweigt.
• Die Steuerung führt diesen Unter-Zustandsautomaten aus. Dabei macht
sie folgendes:
• Anlegen der richtigen Werte an mux_o2 und mux_o3 um die dem
aktuellen Befehl entsprechenden Werte in das Operandenregister OR zu schreiben.
• Takten des Operandenregisters um die anliegenden Operanden
zu übernehmen.
• Auswahl der richtigen ALU-Funktion über die Steuerleitung alu.
• Ggf. Schreiben des ALU-Ergebnisses in den AllzweckRegisterblock, dazu Auswahl mux_$X = 1 und steigende Flanke
an clk_ar.
• Ggf. Speicherzugriff, dazu takten von SR und anlegen des richtigen Zugriffs-Modus über Steuerleitung mo_ds.
• Bei Lese-Befehlen: Auswahl mux_$X = 2, dann steigende Flanke an clk_ar.
• Bei Schreib-Befehl: Steigende Flanke an clk_ds.
3.3 Pipelining
187
b) Warum ist der Multicycle-Datenpfad nicht besonders effizient?
Beim Multicycle-Datenpfad werden die Komponenten des Datenpfads (Befehlsspeicher, Allzweck-Registerblock, ALU, Datenspeicher, Multiplexer, Register)
nicht optimal ausgelastet. Es ist oft nur 1 Komponente aktiv. Während beispielsweise die ALU rechnet, werden der Allzweck-Registerblock oder der Datenspeicher
nicht genutzt.
c)
Wie könnte man den Datenpfad effektiver gestalten?
Gleichzeitige Verwendung der Datenpfad-Komponenten. Beispiel: Operanden aus
Allzweck-Register laden, während die ALU rechnet.
d) Welche Probleme/Konflikte können dabei auftreten?
Es kann zu verschiedenen Konflikten kommen:
• Daten-Konflikt: Aus dem Allzweck-Registerblock soll ein Register-Wert
ausgelesen werden, der sich durch einen vorangehenden Befehl geändert
hat, wobei der neue Wert noch nicht im Allzweck-Register abgelegt wurde.
• Struktur-Konflikt: Verschiedene Komponenten wollen auf nur einmal verfügbare Ressourcen gleichzeitig zugreifen.
• Steuerungs-Konflikt: Es müssen Entscheidungen getroffen werden basierend auf Ergebnissen, die noch nicht bekannt sind.
188
e)
3 Mikroarchitektur
Welche Folgerungen ergeben sich daraus für die Steuerung?
Die Steuerung wird wesentlich komplizierter:
• Die Steuerung benötigt eine Art Gedächtnis, welcher Befehl gerade von
welchen Komponenten ausgeführt wird.
• Es müssen alle möglichen Befehlskombinationen abgedeckt werden.
• Die Steuerung muss Konflikte erkennen auf auflösen können.
f)
Wie lässt sich die Steuerung vereinfachen?
Man kann das ‘‘Gedächtnis’’ in den Datenpfad verlagern:
• Sobald der Befehl im Befehlsregister steht, bestimmt die Steuerung alle
für den Befehl notwendigen Steuersignale.
• Jedem Befehl werden die zugehörigen Steuersignale über die Register
OR und SR ‘‘mitgeschickt’’.
3.3 Pipelining
189
Pipeline-Datenpfad
Nachfolgende Abbildung zeigt eine Implementierung des MMIX-Prozessors.
Sp.-Puls
Reg.-Schreiben
Ergebnisauswahl ES
Sp.-Schreiben
Zugriffs-Art 2 SP
Reg.-Puls
4
Clk1
64
Add
24..31
Direktoperand
32
64
BZ
X-Auswahl
64
64
ES
Steuerung ALU-Funktion 8
AF
SP
Clk2
2
Clk3
Clk4
Registerblock
Zugriffs- SchreiArt
ben
Schreiben
64
16..23
0
32
Adresse
BR
BefehlsSpeicher
1
8..15
Daten
32
0..7
ES
Schreib64
Daten $X LeseDaten $X
$X
Schreiben/ LeseLesen $X Daten $Y
$Y
LeseDaten $Z
Lesen $Y
Lesen $Z
8
0
16..23
8
64
64
64
8
$X
SchreibDaten
Erg
ALU
Adr.
64
64
$Z
0
Dir
Op.
1
ALU
64
DatenSpeicher
Lese
Dat.
0
Erg
ALU
1
64
64
56
LeseDaten
X
8
X
8
X
8
64
a)
Wie unterscheidet sich diese Implementierung vom bisher kennengelernten Datenpfad in Bezug auf die unterstützten Befehle?
• Kein Verzweigungen möglich; es wird immer der im Speicher nachfolgende Befehl ausgeführt
• Folglich auch keine Sichererung der Rücksprungadresse
0 (u(X )) unterstützt
• Als Direktoperand wird nur u64
190
3 Mikroarchitektur
b) Wieviele Stufen/Phasen hat die Pipeline? Was passiert in den einzelnen Stufen/Phasen?
5 Stufen:
• Befehl holen (BH)
• Befehl dekodieren (BD) und Operanden bereitstellen
• Befehl ausführen durch ALU-Operation (AF = AusFühren bzw. ALUFunktion)
• Speicherzugriff (SP)
• Ergebnis in Allzweck-Registerblock schreiben (ES = Ergebnis schreiben).
Die Register des Datenpfads, die die einzelnen Stufen voneinander abtrennen, werden
Pipeline-Register genannt.
c)
Welches ist das erste Pipeline-Register?
Das erste Pipeline-Register ist das Befehlsregister BR.
d) Was bedeuten die Abschnitte ES, SP und AF des zweiten, dritten und vierten
Pipeline-Registers?
• AF = Steuersignale für die AF-Phase
• SP = Steuersignale für die SP-Phase
• ES = Steuersignale für die ES-Phase
3.3 Pipelining
e)
191
Was unterscheidet die Befehlsausführung des gezeigten Pipelining-Datenpfads
vom zuvor kennengelernten Datenpfad?
• Zuvor kennengelernter Datenpfad:
• Ergebnis der ALU wird sofort in den Registerblock geschrieben
• Aus Datenspeicher ausgelesenes Datenwort wird sofort in den
Registerblock geschrieben.
• Hier gezeigter Datenpfad:
• Jeder Befehl durchläuft alle Stufen, d.h. ALU-Ergebnis durchläuft auch die Speicherzugriffs-Phase, bevor das von der ALU
berechnete Ergebnis in den Registerblock geschrieben wird.
• Aus dem Speicher ausgelesenes Datenwort bzw. von der ALU
weitergeleitetes Ergebnis wird erst in Pipeline-Register zwischengespeichert, bevor es in den Registerblock geschrieben
wird.
Gegeben sind zwei Datenpfade:
• Hiergezeigter Datenpfad mit 5-stufiger Pipeline, bei dem in allen Stufen gleichzeitig 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?
5
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?
n
h)
Welche Anforderung muss man an die einzelnen Stufen eines PipeliningDatenpfads stellen, damit man die Komponenten des Datenpfads bestmöglichst
ausnutzt und den maximalen Performance-Gewinn erzielen kann?
Die Ausführungszeit der einzelnen Stufen muss möglichst identisch sein.
Gegeben ist der folgende Auszug aus einem MMIX-Programm:
ADD
SUB
MUL
DIV
LDW
LDO
OR
AND
NEG
$1,$2,3
$2,$2,$3
$3,$3,5
$4,$4,4
$5,$254,0
$6,$254,8
$7,$7,#AC
$8,$8,#DC
$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?
Ab Zeitpunkt t5 .
k)
Was bedeutet es, dass die Pipeline gefüllt ist?
Ab diesem Zeitpunkt werden sind alle Pipeline-Stufen in Betrieb, d.h. die Pipeline
arbeitet maximal parallel; ab diesem Zeitpunkt wird bei jedem Takt ein Befehl
fertig.
3.3 Pipelining
193
t1
t2
t3
t4
t5
t6
t7
t8
t9
BH
BD
AF
SP
ES
BH
BD
AF
SP
ADD
ADD
ADD
ADD
ADD
LDO
LDO
LDO
LDO
BH
BD
AF
SP
ES
BH
BD
AF
SUB
SUB
SUB
SUB
SUB
OR
OR
OR
BH
BD
AF
SP
ES
BH
BD
MUL
MUL
MUL
MUL
MUL
AND
AND
BH
BD
AF
SP
ES
BH
DIV
DIV
DIV
DIV
DIV
NEG
BH
BD
AF
SP
ES
LDW
LDW
LDW
LDW
LDW
Betrachten Sie nachfolgend angegebene MMIX-Befehls-Folge.
ADD
SUB
MUL
l)
$1,$2,$3
$3,$2,$1
$4,$5,6
Was für ein Konflikt tritt hier auf?
Es tritt ein Datenkonflikt auf: Der SUB-Befehl benötigt den Wert von Register $1.
Der vorausgehende ADD-Befehl hat diesen Wert geändert, das Ergebnis jedoch
noch nicht in den Registerblock zurückgeschrieben. Zu dem Zeitpunkt, zu dem
sich der SUB-Befehl in der BD-Phase befindet, ist im Registerblock noch der alte
Wert, so dass der SUB-Befehl den alten Wert von $1 verwendet.
t
6.2.4
Pipeline-Konflikte (Hazards)
• Daten-Konflikte (data hazards)
− Register wird als Quelle verwendet, ist aber von vorausgegangenem Befehl als Ziel verwendet
194 worden, wobei das Zieldatum (das Ergebnis) noch nicht in den Registerblock
3 Mikroarchitektur
zurückgeschrieben wurde
Beispiel:
m) −Wie
könnte man den Konflikt lösen?
Man kann
im Datenpfad zusätzliche Leitungen einfügen, mit denen die bereits
LDO
$1,P1
LDO
$2,P2
berechneten
Werte anderen Stellen des Datenpfads verfügbar gemacht werden
ADD
können.$4,$2,$1
Man nennt solche Leitungen Forwarding-Pfade, da sie berechnete Ergebnisse ‘‘forwarden’’, d.h. weiterleiten.
− Lösung
+ Forwarding-Pfade
Forwarding-Pfade
sind zusätzliche Leitungen im Datenpfad, die bereits berechnete bzw.
• Zusätzliche Datenleitungen im Datenpfad, die Ergebnis weiterleiten können
ermittelte Datenwerte
an andere Stellen
weiterleiten können.
• Vor ALU Quellauswahl
durch Multiplexer
n)
Skizzen Sie Forwarding-Pfade, mit denen Sie sowohl Ergebnisse der ALU als
AF ausgelesene Werte an den
SPEingängen der
ESALU
auch aus dem Datenspeicher
Ergebnis
Befehlsausführung
Speicherzugriff
bereitstellen können.
(zurück-)
schreiben
Konflikt-Steuer-Einheit
64
64
$X
64
64
$Y
64
$Z
0
Dir
Op.
1
64
Zugriffs- SchreiArt
ben
8
0
1
2
64
64
ALU
$X
SchreibDaten
Erg
ALU
Adr.
LeseDaten
DatenSpeicher
64
0
1
2
64
6-6
Lese
Dat.
0
Erg
ALU
1
3.3 Pipelining
195
Betrachten Sie folgende Befehle:
ADD
SUB
$1,$2,$3
$3,$2,$1
o) Kann der SUB-Befehl durch Forwarding-Pfade so auf den vom ADD-Befehl berechneten Wert zugreifen, dass in der AF-Phase der SUB-Befehl direkt nach dem
ADD-Befehl bearbeitet werden kann?
Ja. Der Wert kann an der ALU bereitstehen, sobald der SUB-Befehl in die AF-Phase
eintritt.
Betrachten Sie folgende Befehle:
LDO
SUB
$1,$254,0
$3,$2,$1
p) Was ist hier anders?
Der Wert für Register 1 ist im Datenpfad erst dann verfügbar, wenn der LDO-Befehl
die SP-Phase abgeschlossen hat, d.h. wenn sich der LDO-Befehl in der ES-Phase
befindet.
q) Was für Konsequenzen ergeben sich daraus?
Der SUB-Befehl muss solange in der AF-Phase bleiben, bis der ausgelesene Wert
verfügbar ist. Erst wenn sich der LDO-Befehl in der ES-Phase befindet, kann
die ALU auf den aktuellen Wert $1 zugreifen. Die Ausführung der AF-Phase wird
für die Dauer des Speicherzugriffs angehalten, man sagt auch ‘‘es wird ein Stall
eingefügt’’
196
3 Mikroarchitektur
Gegeben ist der nachfolgend abgebildete Ausschnitt aus einer MMIX-Codesequenz.
LDT
SUB
OR
STO
r)
$3,$2,32
$2,$4,8
$1,$2,$3
$2,$254,$1
Zeile
Zeile
Zeile
Zeile
1
2
3
4
Geben Sie alle auftretenden Datenkonflikte an. Nehmen Sie dabei an, dass der Registerblock ein Datum, das gerade in ihn hineingeschrieben wird, nicht gleichzeitig
am Ausgang ausgeben kann.
Eigene Lösung:
•
•
•
•
Datenkonflikt zwischen Zeile 1 und 3 wg. $3
Datenkonflikt zwischen Zeile 2 und 3 wg. $2
Datenkonflikt zwischen Zeile 2 und 4 wg. $2
Datenkonflikt zwischen Zeile 3 und 4 wg. $1
Musterlösung:
•
•
•
•
s)
Datenkonflikt zwischen Zeile 1 und 3 wg. $3
Datenkonflikt zwischen Zeile 2 und 3 wg. $2
Datenkonflikt zwischen Zeile 2 und 4 wg. $2
Datenkonflikt zwischen Zeile 3 und 4 wg. $1
Welcher zusätzliche Konflikt tritt bei der gegebenen Codesequenz auf? Wie kann
dieser behoben werden?
Zwischen Zeile 1 und 4 tritt ein sog. Strukturkonflikt auf: Der LDT-Befehl aus
Zeile 1 befindet sich in der ES-Phase und der STO-Befehl aus Zeile 4 in der
BD-Phase; beide Befehle müssen auf eine gemeinsame Resource zugreifen, den
Adress-Eingang X (Schreiben/Lesen $X). Zur Konfliktlösung muss der STO-Befehl
zurückgestellt werden, d.h. es muss ein Stall eingefügt werden.
3.3 Pipelining
t)
197
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
LDT
LDT
LDT
LDT
LDT
BH
BD
AF
SP
ES
SUB
SUB
SUB
SUB
SUB
BH
BD
AF
SP
ES
OR
OR
OR
OR
OR
BH
BD
AF
SP
ES
STO
Stall
Stall
Stall
Stall
BH
BD
AF
SP
ES
STO
STO
STO
STO
STO
198
3 Mikroarchitektur
Musterlösung:
BH
BD
AF
SP
ES
LDT
LDT
LDT
LDT
LDT
BH
BD
AF
SP
ES
SUB
SUB
SUB
SUB
SUB
BH
BD
AF
SP
ES
OR
OR
OR
OR
OR
BH
BD
AF
SP
ES
STO
Stall
Stall
Stall
Stall
BH
BD
AF
SP
ES
STO
STO
STO
STO
STO
3.3 Pipelining
199
Gegeben ist der folgende Ausschnitt aus einer MMIX Codesequenz:
SUB
LDO
OR
STO
u)
$2,$5,10
$5,$0,2*8
$1,$2,$5
$1,$5,$2
Zeile
Zeile
Zeile
Zeile
1
2
3
4
Geben Sie alle auftretenden Datenkonflikte an. Nehmen Sie dabei an, dass der Registerblock ein Datum, das gerade in ihn hineingeschrieben wird, nicht gleichzeitig
am Ausgang ausgegeben werden kann. Nehmen Sie an, dass auf den Registerblock innerhalb einer Phase erst lesend, dann schreibend zugegriffen wird.
Berücksichtigen Sie ggf. einzufügende Stalls.
Eigene Lösung:
•
•
•
•
•
Datenkonflikt zwischen Zeile 1 und 3 wg. $2
Datenkonflikt zwischen Zeile 2 und 3 wg. $5
Datenkonflikt zwischen Zeile 2 und 4 wg. $5
Datenkonflikt zwischen Zeile 3 und 4 wg. $1
Kein Datenkonflikt zwischen Zeile 1 und 4 wg. $2, da wg. Strukturkonflikt
zwischen Zeile 1 und 4 zwischen Zeile 3 und 4 ein Stall eingefügt werden
muss
Musterlösung:
•
•
•
•
•
Datenkonflikt zwischen Zeile 1 und 3 wg. $2
Datenkonflikt zwischen Zeile 2 und 3 wg. $5
Datenkonflikt zwischen Zeile 2 und 4 wg. $5
Datenkonflikt zwischen Zeile 3 und 4 wg. $1
Kein Datenkonflikt zwischen Zeile 1 und 4 wg. $2, da wg. Strukturkonflikt
zwischen Zeile 1 und 4 zwischen Zeile 3 und 4 ein Stall eingefügt werden
muss
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 OCTAAdresse 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.:
1
Erg. Ausw.:
1
Sp. Schr.:
0
Reg. Schr.:
0
Zugr.-Art:
egal
Erg. Ausw.:
egal
ALU:
Dir. Op.:
$X:
0x21
Sp. Schr.:
0
Reg. Schr.:
1
1
Zugr.-Art:
egal
Erg. Ausw.:
0
0x01
Lese-Daten:
0x01
$X:
$Y: 0x01234567
STT $1,$254,0
STT $1,$254,0
$Z:
0x22
Dir. Op.:
0x02
X:
0x01
ADD $1,$3,2
0x01234567
Erg. ALU:
0x05
Erg. ALU:
0x20..01
X:
0x01
Stall
X:
0x03
LDT $3,$254,$1
3.3 Pipelining
201
Musterlösung:
Reg. Schr.:
1
Erg. Ausw.:
1
Sp. Schr.:
0
Reg. Schr.:
0
Zugr.-Art:
egal
Erg. Ausw.:
egal
ALU:
Dir. Op.:
$X:
0x21
Sp. Schr.:
0
Reg. Schr.:
1
1
Zugr.-Art:
egal
Erg. Ausw.:
0
0x01
Lese-Daten:
0x01
$X:
$Y: 0x01234567
STT $1,$254,0
STT $1,$254,0
$Z:
0x22
Dir. Op.:
0x02
X:
0x01
ADD $1,$3,2
0x01234567
Erg. ALU:
0x05
Erg. ALU:
0x20..01
X:
0x01
Stall
X:
0x03
LDT $3,$254,$1
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.:
1
Erg. Ausw.:
1
Sp. Schr.:
0
Reg. Schr.:
1
Zugr.-Art:
X
Erg. Ausw.:
1
0x05
Sp. Schr.:
0
Reg. Schr.:
1
0
Zugr.-Art:
X
Erg. Ausw.:
1
ALU:
Dir. Op.:
ADD $3,$254,0
ADD $3,$254,0
$X:
0x11
$Y:
0x00
$Z:
0x26
Dir. Op.:
0x02
X:
0x01
SUB $1,$3,$2
$X:
0x22
Lese-Daten:
<0x00>
Erg. ALU:
Erg. ALU:
0x26
X:
0x02
OR $2,$2,36
0x00
X:
0x03
AND $3,$2,28
3.3 Pipelining
203
Musterlösung:
Reg. Schr.:
1
Erg. Ausw.:
1
Sp. Schr.:
0
Reg. Schr.:
1
Zugr.-Art:
X
Erg. Ausw.:
1
0x05
Sp. Schr.:
0
Reg. Schr.:
1
0
Zugr.-Art:
X
Erg. Ausw.:
1
ALU:
Dir. Op.:
ADD $3,$254,0
ADD $3,$254,0
$X:
0x11
$Y:
0x00
$Z:
0x26
Dir. Op.:
0x02
X:
0x01
SUB $1,$3,$2
$X:
0x22
Lese-Daten:
<0x00>
Erg. ALU:
Erg. ALU:
0x26
X:
0x02
OR $2,$2,36
0x00
X:
0x03
AND $3,$2,28
204
3 Mikroarchitektur
3.4 Cache
205
3.4 Cache
Motivation
Betrachten Sie den folgenden Pipelining-Datenpfad:
Sp.-Puls
Reg.-Schreiben
Ergebnisauswahl ES
Sp.-Schreiben
Zugriffs-Art 2 SP
Reg.-Puls
4
Clk1
64
Add
24..31
Direktoperand
32
64
BZ
X-Auswahl
64
64
ES
Steuerung ALU-Funktion 8
AF
SP
Clk2
2
Clk3
Clk4
Registerblock
Zugriffs- SchreiArt
ben
Schreiben
64
16..23
0
32
Adresse
BR
BefehlsSpeicher
1
8..15
Daten
32
0..7
ES
Schreib64
Daten $X LeseDaten $X
$X
Schreiben/ LeseLesen $X Daten $Y
$Y
LeseDaten $Z
Lesen $Y
0
16..23
8
$Z
Dir
Op.
Lesen $Z
8
64
64
8
64
$X
SchreibDaten
Erg
ALU
Adr.
64
64
0
ALU
64
DatenSpeicher
1
Lese
Dat.
0
Erg
ALU
1
64
64
56
LeseDaten
X
8
X
8
X
8
64
a)
Wie muss der Pipelining-Datenpfad getaktet werden, damit möglichst viele Befehle
pro Zeiteinheit abgearbeitet werden können?
Um maximale Performance zu erreichen, müssen alle Pipeline-Register immer
gleichzeitig getaktet werden, so dass – ohne Verzögerung – ein Befehl nach dem
anderen durch den Datenpfad durchgeschoben werden kann.
206
3 Mikroarchitektur
b) Wenn alle Pipeline-Stufen gleichzeitig getaktet werden: Was folgt daraus hinsichtlich der Ausführungszeit der einzelnen Stufen?
• Jede Stufe wird so lange ausgeführt, wie die langsamste Stufe zur
Ausführung benötigt.
• Langsame Stufen bremsen den Datenpfad aus.
• Idealerweise benötigen alle Stufen von sich aus dieselbe Ausführungszeit,
so dass beim Angleich an die langsamste Stufe keine Zeit verloren geht.
c)
Welche Pipeline-Stufen sind von sich aus eher schnell, welche eher langsam?
Begründen Sie Ihre Antwort.
• BD- und ES-Phase: Sehr schnell; es wird nur über Multiplexer auf Register
zugegriffen, vgl. Aufbau Registerblock
• AF-Phase: Befehlsabhängig; bei manchen Befehlen sehr schnell (z.B. ORBefehl), bei anderen Befehlen langsamer (MUL/DIV-Befehle benötigen
mehrere Runden zur Abarbeitung); ) bei vielen Befehlen sicher langsamer
als der Registerblock
• BH- und SP-Phase: extrem langsam. Der Arbeitsspeicher ist auf dem
Mainboard, d.h. ausserhalb des Prozessors untergebracht. Zugriffe erfolgen über den langsamen Bus. Aus Platz- und Kostengründen ist der
Arbeitsspeicher in DRAM-Technologie (man braucht nur einen Transistor
und einen Kondensator, um ein Bit zu speichern) ausgeführt. Das macht
ihn wesentlich kleiner und kostengünstiger als SRAM (6 Transistoren pro
Bit), jedoch auch langsamer.
3.4 Cache
207
d) Wo liegt der Flaschenhals des Datenpfads?
Der Flaschenhals beim Datenpfad liegt bei den Speicherzugriffen.
e)
Wie könnte man diesen Flaschenhals beseitigen?
• Speicher als SRAM ausführen ) schneller
• Speicher in den Prozessor integrieren ) man muss nicht über den
langsamen Bus
f)
Was beschränkt eine Total-Integration des Arbeitsspeichers in den Prozessor?
• SRAM ) braucht viel Platz; Platz ist auf Prozessor-Die jedoch kritische
Komponente, da bei größerer Chipfläche auch die Wahrscheinlichkeit für
Halbleiterfehler steigt
• Große räumliche Ausdehnung ) lange Signallaufzeiten, hohe parasitäre
Kapazitäten ) großer Speicher ist von Haus aus langsamer und kann
deshalb auch gleich ausserhalb des Prozessors untergebracht werden.
g) Macht es Sinn, auf dem Prozessor eine kleine Menge an schnellem Arbeitsspeicher
zu integrieren? Warum?
Ja. Klein ) schnell. Bei der Ausführung von Programmen wird oft nur auf einen
kleinen Bereich des Arbeitsspeichers zugegriffen ) kleiner Speicher ausreichend.
208
3 Mikroarchitektur
Direkt abgebildeter Cache
Der ‘‘Cache’’ ist ein kleiner, sehr schneller SRAM-Speicher, der direkt auf dem ProzessorDie 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 kann man feststellen, auf welche Cache-Adresse eine Arbeitsspeicher-Adresse
abgebildet wird?
Wenn im Cache-Speicher 2n Elemente gespeichert werden können, legen die
letzten n Bit der Arbeitsspeicher-Adresse fest, auf welches Cache-Element das
adressierte Arbeitsspeicher-Element abgebildet wird.
210
3 Mikroarchitektur
Nachfolgende Abbildung zeigt, wie beim sog. Direktabgebildeten Cache jede
Arbeitsspeicher-Adresse direkt auf eine Cache-Adresse abgebildet wird.
Arbeitsspeicher-Adresse (k + f + b Bits)
k Bits
f Bits
Schlüssel
b Bits
Rahmen-Nr.
k (key)
f (frame)
0
v
1
v
Byte-Auswahl
b
Rahmen (frame)
b
2 - 1 ...
...
2
bytes
1
0
v
v
v
v
v
f
2-1
v
k Bits
In diesen k⋅2 f Bits des sog.
Tag-RAMs ist der von jedem Cache-Rahmen verwendete
Schlüssel abgespeichert
In diesen 2f+b Byte sind die Cache-Daten abgespeichert
(Cache-Inhalt)
Bei einem Cache-Zugriff, wird zunächst die Rahmen-Nummer aus der ArbeitsspeicherAdresse 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?
220 = 1M
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?
0xABC
3.4 Cache
e)
211
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:
01 1010 1011 1100 11 = 0110 1010 1111 0011 = 0x6AF3.
Musterlösung:
01 1010 1011 1100 11 = 0110 1010 1111 0011 = 0x6AF3.
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?
k Bit
g) Warum werden bei einem Arbeitsspeicher-/Cache-Zugriff die oberen k Bits der
Arbeitsspeicher-Adresse im Tag-RAM abgelegt?
Da ein Cache-Rahmen für sehr viele Arbeitsspeicher-Rahmen zuständig ist, muss
man sich irgendwie merken, welcher der vielen möglichen Arbeitsspeicher-Rahmen
gerade im Cache abgespeichert ist.
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 = 4096 Byte = 4 kByte
212
i)
3 Mikroarchitektur
In einem Cache-Rahmen können 16 Octas abgelegt werden. Wieviele Bits werden
zur Codierung der Byteauswahl benötigt?
16 · 8 Byte = 128 Byte ) 7 Bits
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?
Es muss kein Rahmen ausgewählt werden ) die Arbeitsspeicher-Adresse wird
nur in Schlüssel und Byteauswahl unterteilt.
b) Ein vollassoziativer MMIX-Cache-Speicher verwendet eine Rahmengröße von 256
Byte. Wieviele Bits werden zur Codierung des Schlüssels verwendet?
64 - 8 = 56.
c)
Ein 32 kByte großer vollassoziativer MMIX-Cache-Speicher verwendet eine Rahmengröße von 256 Byte. Wieviele 1-Bit-Vergleicher sind zum Vergleich des Schlüssels mit den Tags notwendig?
Eigene Lösung:
Anzahl der Tag-RAM-Einträge: 32 kByte / 256 Byte = 215
1-Bit-Vergleicher: 128 * (64 - 8) = 128 * 56 = 7.168.
8
= 27 = 128. Anzahl der
8
= 27 = 128. Anzahl der
Musterlösung:
Anzahl der Tag-RAM-Einträge: 32 kByte / 256 Byte = 215
1-Bit-Vergleicher: 128 * (64 - 8) = 128 * 56 = 7.168.
3.4 Cache
213
Set-Assoziativer/Mengen-Assoziativer Cache
Beim Set-Assoziativen Cache kann ein Arbeitsspeicher-Rahmen in einen von a ausgewählten Cache-Rahmen abgelegt werden. a wird die Assoziativität des Caches genannt.
Arbeitsspeicher-Adresse (k + s + b Bits)
k Bits
s Bits
Schlüssel
k (key)
Set-Nr.
Assoziativität
a=2
v
0
b Bits
s (set)
Byte-Auswahl
b
Rahmen (frame)
b
2 - 1 ...
...
2
bytes
1
0
v
v
1
v
v
2
v
v
2 s- 1
v
k Bits
In diesen k⋅2s Bits des sog.
Tag-RAMs ist der von jedem Cache-Rahmen verwendete
Schlüssel abgespeichert
In diesen a⋅2s+b Byte sind die Cache-Daten abgespeichert
(Cache-Inhalt)
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?
Zugriff auf dasselbe Set jede 228 -ste Arbeitsspeicher-Adresse ) s + b = 28 ) s =
28 - b = 28 - 11 = 17.
) Der Cache hat 217 Sets.
Schlüsselbreite: k = 64 - 28 = 36
Anzahl der Vergleicher: 36 · 4 = 144.
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?
23+13 = 216 = 65.536
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?
• Byteauswahl: ld(32) Bit = 5 Bit
• Anzahl der Sets: 1 MB / (32 · 8) Byte = 220
Codierung der Setnummer
• Schlüssel: 64 - 12 - 5 = 47
5 3
= 212 ) 12 Bits zur
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?
•
•
•
•
Schlüssel: 688 / 16 = 43
Setnummer: ld(2048) = 11
Byteauswahl: 64 - 43 - 11 = 10
Rahmengröße: 210 Byte = 1024 Byte
3.4 Cache
215
Ein Set-Assoziativer Cache verwendet zur Codierung des Schlüssels 41 Bit, zur Codierung 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: 0x0000
0x2000 0000 0123 4567: 0x468A
0x2000 0000 478B 0228: 0x1604

Vergelijkbare documenten