06 Ss 2004 Ct+Cs (Ei+It) Loesung

TECHNISCHE UNIVERSITÄT MÜNCHEN
Fakultät für Elektrotechnik und Informationstechnik

Lehrstuhl für Datenverarbeitung
Prof. Dr.-Ing. K. Diepold
DIPLOMVORPRÜFUNG FÜR ELEKTROINGENIEURE

DIPLOMHAUPTPRÜFUNG FÜR ELEKTROINGENIEURE
GRUNDLAGEN- UND ORIENTIERUNGSPRÜFUNG FÜR
INFORMATIONSTECHNIKER
Computertechnik/Computersysteme SS 2004
30.07.2004
Prüfungsdauer: 90 Minuten
Bitte ankreuzen:
Name: Musterlösung
EI
Vorname: IT
TUM-BWL
Matr. Nr.: INF
Unterschrift:
DVP
Hörsaal: DHP
GOP
Reihe: Platz:
Hinweise:
• Heftklammern nicht lösen
• Nur die ausgeteilten und gehefteten
Lösungsblätter werden bewertet
• Keine Bleistifte! Punkte
• Die Prüfung besteht aus 18 Seiten
• Die angegebene Anzahl der pro Auf- Aufgabe 1
gabe zu erreichenden Punkten ist als
Aufgabe 2
vorläufiger Richtwert zu betrachten
• Die mit einem Stern (*) gekennzeich-
Aufgabe 3
neten Aufgaben sind unabhängig von der
Lösung vorangegangener Aufgaben lösbar
• Lösungen ohne erkennbaren Lösungs- Aufgabe 4
weg werden mit 0 Punkten bewertet
Gesamt
DVP/DHP Computertechnik
Seite 2 GOP Computersysteme
Aufgabe 1 MMIX-Programmierung (56 Punkte)
In dieser Aufgabe soll ein MMIX-Programm zur Berechnung der Klaus von Klitzing-
Konstanten Rk = h/e2 ≈ 25 812,807 Ω implementiert werden, wobei h dem Planckschen
Wirkungsquantum (6,626 ⋅ 10 – 34 Js) und e der Elementarladung (1,602 ⋅ 10 – 19 C)
entspricht.
Das Programm soll in zwei Teile gegliedert werden

• Die Funktion fdiv32 soll zwei 32 Bit breite Gleitkommazahlen dividieren können
• Das Hauptprogramm (Main) soll die Funktion fdiv32 zweimal aufrufen: Beim
ersten Aufruf soll Rk = h/e berechnet werden, beim zweiten Aufruf Rk = Rk/e
Zunächst müssen einige globale Definitionen vorgenommen werden.
* a) Geben Sie die Anweisung an, die den Stackpointer als globales Register mit dem
Namen SP anlegt und gleichzeitig mit dem Wert 0x4000000000000000 initiali-
siert. (1 Punkt)
SP GREG #4000000000000000
* b) Geben Sie die Anweisungen an, mit denen Sie h und e als 32-Bit breite Gleitkom-
ma-Zahl im Speicher zu Beginn des Datensegments als Tetra ablegen und durch
die Namen H bzw. E ansprechbar machen.
Treffen Sie eine geeignete Maßnahme, so dass Sie die Konstanten später auch
wirklich adressieren können. (4 Punkte)
Hinweis: Die 32 Bit Gleitkomma-Codierung von h lautet 0x85C306B, die von e lau-
tet 0x203D26D0.
LOC Data_Segment
GREG @
H TETRA #85C306B 6.6260757e-34
E TETRA #203D26D0 1.6021765e-19
* c) Geben Sie den Code an, mit dem Sie ein 32-Bit breites Datenwort für das Ergebnis
deklarieren. Das Datenwort soll über den Namen Rk angesprochen werden kön-
nen. (1 Punkt)
Rk TETRA
Im Folgenden soll das Hauptprogramm (Main) implementiert werden.
* d) Geben Sie den Code der Funktion Main an, der den Namensraum Main: bereit-
stellt und innerhalb des Namensraums Main: die Register $1, $2 und $3 durch
die Namen h, e und Rk ansprechbar macht. (3 Punkte)
PREFIX Main:
h IS $1
e IS $2
Rk IS $3
GOP Computersysteme Seite 3
* e) Beginnen Sie das Hauptprogramm, indem Sie das Plancksche Wirkungsquantum

(32 Bit breites Datenwort, das an der globalen Marke H steht) und die Elementarla-
dung (32 Bit breites Datenwort, das an der globalen Marke E steht) in die Register
h und e einlesen. (2 Punkte)
:Main LDT h,:H H -> Register

LDT e,:E E -> Register
Nach dem Einlesen der beiden 32 Bit breiten Konstanten h und e sollen diese der
Funktion fdiv32 zur Division wie folgt auf dem Stack übergeben werden:
Stackpointer 00... ...0 32 Bit breiter Dividend 0x3FFFFFFFFFFFFFF0

00... ...0 32 Bit breiter Divisor 0x3FFFFFFFFFFFFFF8
0x4000000000000000 (BOS)
* f) Führen Sie die Parameterübergabe aus und rufen Sie dann die über die globale
Marke fdiv32 ansprechbare Funktion fdiv32 auf. Legen Sie die Rücksprungad-
resse dabei in Register $0 ab. (4 Punkte)
SUB :SP,:SP,2*8 Stackpointer anpassen

STO h,:SP,0 h -> Stack
STO e,:SP,1*8 e -> Stack
GO $0,:fdiv32 1. Funktionsaufruf
Das Ergebnis wird von der Funktion fdiv32 wie folgt auf dem Stack zurückgegeben:
Stackpointer 00... ...0 32 Bit breites Ergebnis 0x3FFFFFFFFFFFFFF8

0x4000000000000000 (BOS)
* g) Lesen Sie vom Stack das Ergebnis der Division h/e in das Register Rk ein und le-
gen Sie es dann für einen weiteren Aufruf von fdiv32 als Dividend auf dem Stack
ab. Legen Sie als Divisor wieder e auf dem Stack ab und rufen Sie die Funktion
fdiv32 dann wie in der vorangegangenen Teilaufgabe auf. (5 Punkte)
LDO Rk,:SP,0 Ergebnis vom Stack holen

SUB :SP,:SP,1*8 Stackpointer erhöhen
STO Rk,:SP,0 Dividend -> Stack
STO e,:SP,1*8 Divisor -> Stack
GO $0,:fdiv32 2. Funktionsaufruf
* h) Laden Sie die nun berechnete Klitzing-Konstante vom Stack in das Register Rk
und speichern Sie Rk anschliessend in dem in Teilaufgabe c) angelegten 32 Bit
breiten Datenwort mit dem globalen Namen Rk ab. Beenden Sie zum Abschluss
das Hauptprogramm mit einer geeigneten Anweisung. (4 Punkte)
LDO Rk,:SP,0 Rk vom Stack holen

ADD :SP,:SP,1*8 Stackpointer anpassen
STT Rk,:Rk
TRAP 0,:Halt,0 Programm beenden
* i) Beenden Sie den Namensraum Main: mit einer geeigneten Anweisung. (1 Punkt)
PREFIX :
Im Folgenden soll die Funktion fdiv32 implementiert werden, wobei als Pufferregister
bei jeder Aufgabe die Register buf1 und buf2 verwendet werden können.
Nehmen Sie an, dass für die Funktion fdiv32 der Namensraum fdiv32: angelegt
wurde und die in der Funktion fdiv32 verwendeten Register bereits wie folgt auf den
Stack gesichert wurden:
:fdiv32 SUB :SP,:SP,10*8 Stackpointer anpassen
STO dividend,:SP,0
STO divisor,:SP,1*8
STO mant_dividend,:SP,2*8
STO mant_divisor,:SP,3*8
STO exp_dividend,:SP,4*8
STO exp_divisor,:SP,5*8
STO vz,:SP,6*8
STO buf1,:SP,7*8
STO buf2,:SP,8*8
STO $0,:SP,9*8
* j) Geben Sie den MMIX-Code an, mit dem Sie die zuvor in den Teilaufgaben f) und g)
auf den Stack abgelegten Übergabe-Parameter in die Register dividend und
divisor einlesen. (2 Punkte)
LDO dividend,:SP,10*8
LDO divisor,:SP,11*8
Die verwendeten 32 Bit breiten Gleitkommazahlen sind nun wie folgt in den Registern
dividend und divisor abgelegt:
63 32 31 30 23 22 0
00... ...0 vz e f
vz e–127
Wert: (–1) ⋅ 1.f ⋅ 2
Mantisse
* k) Berechnen Sie aus den in den Registern dividend und divisor abgelegten
Parametern das Vorzeichen des Quotienten derart, dass es nach der Berechnung
wie nachfolgend angegeben im Register vz abgelegt ist. (3 Punkte)
63 32 31 30 0
00... ...0 vz 00... ...0
XOR vz,dividend,divisor
SRU vz,vz,31
SLU vz,vz,31
* l) Berechnen Sie aus den in den Registern dividend und divisor abgelegten
Parametern den Exponenten des Quotienten. Führen Sie die Berechnung so durch,
dass der Exponent des Quotienten am Schluss wie nachfolgend angegeben im Re-
gister exp_dividend abgelegt ist. (6 Punkte)
Hinweis: Zur Pufferung der Exponenten können Sie die Register exp_dividend
und exp_divisor verwenden.
63 8 7 0
00... ...0 e
SLU exp_dividend,dividend,33
SRU exp_dividend,exp_dividend,56
SLU exp_divisor,divisor,33
SRU exp_divisor,exp_divisor,56
SUB exp_dividend,exp_dividend,exp_divisor
ADD exp_dividend,exp_dividend,127
* m) Geben Sie den MMIX-Code an, mit dem Sie aus den in den Registern dividend
und divisor stehenden Werten die Mantissen mant_dividend und mant_divisor
extrahieren und in die Register mant_dividend und mant_divisor wie nach-
folgend angegeben ablegen. (6 Punkte)
Hinweis: Als Zwischenpuffer können Sie das Register buf1.
63 24 23 22 0
00... ...0 1 f
Mantisse
SLU mant_dividend,dividend,41
SLU mant_divisor,divisor,41
SRU mant_dividend,mant_dividend,41
SRU mant_divisor,mant_divisor,41
SET buf1,1
SLU buf1,buf1,23
OR mant_dividend,mant_dividend,buf1
OR mant_divisor,mant_divisor,buf1
Damit die Division mant_dividend/mant_divisor ein brauchbares Ergebnis liefert, muss

mant_dividend zunächst um 24 Stellen nach links geschoben werden.
* n) Schieben Sie den Inhalt von mant_dividend um 24 Stellen nach links und Tei-
len Sie die so erhaltene 48 Bit breite Mantisse mant_dividend durch die 24 Bit brei-
te Mantisse mant_divisor. Sorgen Sie dafür, dass das Divisionsergebnis im Regis-
ter mant_dividend abgelegt wird. (2 Punkte)
SLU mant_dividend,mant_dividend,24
DIVU mant_dividend,mant_dividend,mant_divisor
Nach der Division kann die im Register mant_dividend befindliche Mantisse des
Ergebnisses entweder 24 oder 25 Bit breit sein:
63 24 23 22 0
00... ...0 1 f
63 25 24 23 0
00... ...0 1 f
* o) Geben Sie den MMIX-Code an, der die soeben berechnete Mantisse des Quotien-
ten in Abhängigkeit von Bit 24 renormalisiert und den Bruchteil f wie in der nachfol-
genden Skizze angegeben extrahiert. In Abhängigkeit von Bit 24 der Ergebnis-
Mantisse soll dabei auch noch der im Register exp_dividend abgelegte Expo-
nent (vgl. Skizze zu Teilaufgabe l) renormalisiert werden. (7 Punkte)
Hinweis: Als Zwischenpuffer können Sie die Register buf1 und buf2 verwenden.
63 23 22 0
00... ...0 f
SRU buf1,mant_dividend,24
SUB exp_dividend,exp_dividend,1
ADD exp_dividend,exp_dividend,buf1
SET buf2,41
SUB buf2,buf2,buf1
SLU mant_dividend,mant_dividend,buf2
SRU mant_dividend,mant_dividend,41
In den Registern vz, exp_dividend und mant_dividend sind jetzt wie in den
Skizzen zu den Teilaufgaben k), l) und o) angegeben das Vorzeichen, der Exponent
und der Bruchteil f des berechneten Quotienten enthalten.
* p) Geben Sie den MMIX-Code an, mit dem Sie den Exponenten um eine geeignete
Anzahl an Stellen verschieben und dann mit dem Vorzeichen und dem Bruchteil f
im Register buf1 zusammensetzen. (3 Punkte)
SLU exp_dividend,exp_dividend,23
OR buf1,exp_dividend,mant_dividend
OR buf1,buf1,vz
Im Folgenden sind die Anweisungen angegeben, mit denen das Ergebnis auf dem
Stack abgelegt wird und die gesicherten Register wieder hergestellt werden.
STO buf1,:SP,11*8
LDO dividend,:SP,0
LDO divisor,:SP,1*8
LDO mant_dividend,:SP,2*8
LDO mant_divisor,:SP,3*8
LDO exp_dividend,:SP,4*8
LDO exp_divisor,:SP,5*8
LDO vz,:SP,6*8
LDO buf1,:SP,7*8
LDO buf2,:SP,8*8
LDO $0,:SP,9*8
* q) Geben Sie den Code an, der den Stackpointer auf das Ergebnis zeigen lässt und
anschliessend wieder zum Funktionsaufrufer zurückspringt. (2 Punkte)
Hinweis: Die Rücksprungadresse befindet sich in Register $0.
ADD :SP,:SP,11*8
GO $0,$0,0
Aufgabe 2 Multiplikationsalgorithmus und Steuerwerk (41 Pkte)

In dieser Aufgabe wird zunächst der aus der Vorlesung bekannte dritte Multiplikations-
algorithmus zur Multiplikation zweier Zahlen angewendet. Im Anschluss wird für die
aus dem Skript bekannte Hardware-Realisierung eine Steuerung entworfen.
Gegeben ist der nachfolgende Multiplikationsalgorithmus mit zugehöriger Schaltungs-

Skizze.
Start
Multiplikand im Multiplikand-Register ablegen
Multiplikator im rechten Teil des Produkt-Registers ablegen Initialisierung
Linken Teil des Produkt-Registers mit 0 initialisieren
Produkt[0]
Produkt[0] == 1 Produkt[0] == 0
Produkt links = Produkt links + Multiplikand
Produkt = Produkt >> 1
nein
n Runden?
ja
Ende
Multiplikand (n Bit)
n Bit
n Bit n-Bit Addierer
n Bit
rechts schieben Steuerung

Produkt (2n Bit) übernehmen
LSB
rechts schieben
Produkt links Produkt rechts

(mit 0 initialisiert) (mit Multiplikator initialisiert)
* a) Führen Sie den oben angegebenen Algorithmus für die Multiplikation 5 ⋅ 13 = 65 für
die Wortbreite n = 4 im Dualsystem durch. (8 Punkte)
Hinweis: Produkt[0] meint das LSB des Produkt-Registers.
Multiplikand
0 1 0 1
Addierer
Multiplikand ⋅ Multiplikator = Produkt
Summe
0 0 0 0 1 1 0 1 Initialisierung
0 1 0 1 1 1 0 1
1. Runde
0 0 1 0 1 1 1 0
0 0 0 1 0 1 1 1 2. Runde
0 1 1 0 0 1 1 1
3. Runde
0 0 1 1 0 0 1 1
1 0 0 0 0 0 1 1
4. Runde
0 1 0 0 0 0 0 1
Beim gerade durchgeführten Algorithmus wird unmittelbar vor dem Ende das Produkt
noch einmal um eine Stelle nach rechts geschoben.
* b) Wie gross darf das Ergebnis aufgrund dieser Tatsache maximal sein, damit es von
obigem Algorithmus noch korrekt berechnet werden kann? (2 Punkte)
Das MSB des Ergebnisses muss den Wert Null haben. Das Ergebnis darf also ma-
ximal 22n-1 -1 sein, um korrekt berechnet werden zu können.
auch ok: 127

Betrachten Sie die aus dem Skript bekannte und nachfolgend noch einmal abgebildete
Schaltung zur Multiplikation nach dem oben angegebenen Algorithmus:
Produkt[0]
Steuerung
0
Clk_Produkt
Clk
Init/>>1
Multiplikator Init/>>1
0 0..n-1 0..n-1
n
Produkt 2n
1
>>1
n..2n-1
n Produkt
n..2n-1
⇔
Clk_Mkand
MULU Multiplexer
0 1
2n 2n
n n
0
n Clk n Bit
Add n
Multiplikand
Multipli-
n kand
n n
* c) Welcher Term liegt allgemein am Eingang des Produkt-Registers an, wenn die
Steuerleitung Multiplexer auf LOW-Pegel, also auf 0 liegt? (2 Punkte)
Am Eingang des Produkt-Registers liegt dann der von n auf 2n Bit erweiterte Multi-
plikator an.
* d) Welcher Term liegt allgemein am Eingang des Produkt-Registers an, wenn die
Steuerleitung Multiplexer auf HIGH-Pegel, also auf 1 liegt? (3 Punkte)
Am Eingang des Produkt-Registers liegt dann im oberen n Bit breiten Halbwort die
Summe „Multiplikand + oberes Halbwort Produktregister“ an.
Am Eingang des unteren n Bit breiten Halbworts liegt dabei der bereits im Produkt-
Register gespeicherte untere Teil des Halbworts an.
Der nachfolgend angegebene Moore-Automat dient zur Steuerung der links abgebilde-
ten Schaltung.
• Die Zustände 1 und 2 dienen hierbei der Initialisierung (vgl. obere Abb. auf S. 8)
• In den Zuständen 3 und 4 wird die vom Addierer berechnete Summe Produkt
links + Multiplikand in den linken Teil des Produkt-Registers übernommen
• In den Zuständen 5 und 6 wird der im Produkt-Register befindliche Wert um ei-

ne Stelle nach rechts geschoben.
* e) Tragen Sie in den bereits vorgefertigten Moore-Automaten für jeden Zustand die
benötigten Ausgangswerte ein und geben Sie die benötigten Zustandsübergänge
mit geeigneten Bedingungen an, so dass die links abgebildete Schaltung den auf
der Seite 8 oben abgebildeten Algorithmus durchführt. Verwenden Sie hierzu das
Signal Produkt[0] und das Signal Runde_n, das in der n. Runde den Wert „1“ hat
und sonst den Wert „0“ aufweist. (12 Punkte)
Runde_n == 0 UND Produkt[0] == 0
1 2 5 6
Init Init rechtsschieben rechtsschieben
Multiplexer = 0 Multiplexer = 0 Multiplexer = X Multiplexer = X
Clk_Produkt = 0 Clk_Produkt = 1 Clk_Produkt = 0 Clk_Produkt = 1
Clk_Mkand = 0 Clk_Mkand = 1 Clk_Mkand = 0 Clk_Mkand = 0
Init/>>1 = 0 Init/>>1 = 0 Init/>>1 = 1 Init/>>1 = 1
Runde_n = 1
immer Produkt[0] == 0 immer
Produkt[0] == 1
immer
3 4 7
Addition Addition Ende
Multiplexer = 1 Multiplexer = 1 Multiplexer = X
Clk_Produkt = 0 Clk_Produkt = 1 Clk_Produkt = 0
Clk_Mkand = 0 Clk_Mkand = 0 Clk_Mkand = 0
Init/>>1 = 0 Init/>>1 = 0 Init/>>1 = X
immer
immer
Runde_n == 0 UND Produkt[0] == 1

Im Folgenden ist ein anderer, nicht korrekter Zustandsautomat für die Steuerung der
oben abgebildeten Multiplikations-Schaltung angegeben.
In den restlichen beiden Teilaufgaben wird ausschliesslicher dieser Automat betrachtet.
Runde_n == 0
1 2 5 6
Init Init rechtsschieben rechtsschieben
Multiplexer = 0 Multiplexer = 1 Multiplexer = 0 Multiplexer = 1
Clk_Produkt = 0 Clk_Produkt = 0 Clk_Produkt = 0 Clk_Produkt = 0
Clk_Mkand = 0 Clk_Mkand = 1 Clk_Mkand = 0 Clk_Mkand = 1
Init/>>1 = 0 Init/>>1 = 0 Init/>>1 = 1 Init/>>1 = 1
immer Produkt[0] == 1 Produkt[0] == 0 immer
0
==
n
e_
nd
Ru
3 4 7
Addition Addition Ende
Multiplexer = X Multiplexer = X Multiplexer = 1
Clk_Produkt = 0 Clk_Produkt = 1 Clk_Produkt = 0
Clk_Mkand = 0 Clk_Mkand = 1 Clk_Mkand = X
Init/>>1 = 0 Init/>>1 = 0 Init/>>1 = 1
Runde_n = 0
immer
Runde_n = 1
* f) Implementieren Sie für den angegebenen Zustandsautomaten die Ausgangsfunk-

tion mit Hilfe des angegebenen Multiplexers, indem Sie an die Dateneingänge des
Multiplexers geeignete Binärwerte anlegen. (4 Punkte)
Hinweis: Nehmen Sie an, dass an der Auswahlleitung des Multiplexers stets der
aktuelle Zustand anliegt.
aktueller Zustand
3
4
X X X X 0
4
0 0 0 0 1
4
1 0 1 0 2
Bit 3: Multiplexer
4
X 0 0 0 3 4 Bit 2: Clk_Produkt
4 Bit1: Clk_Mkand
X 1 1 0 4
4 Bit 0: Init/<<1
0 0 0 1 5
4
1 0 1 1 6
4
1 0 X 1 7
Nehmen Sie im Folgenden an, dass der 2 Bit breite Rundenzähler wie in der Übung
implementiert wurde (Runde 1 ⇔ 01, Runde 2 ⇔ 10, Runde 3 ⇔ 11, Runde 4 ⇔ 00)
und das Signal Runde_n genau dann den Wert 1 hat, wenn der Rundenzähler auf 00
steht und sonst den Wert 0 hat. (Wortbreite n = 4)
* g) Tragen Sie für den oben gegebenen Moore-Automaten in nachstehendes PLA ge-
eignete Verbindungen ein, mit denen die Zustandsübergangsfunktion für Bit 1 reali-
siert wird. (10 Punkte)
4 UND Runde_n == 0 3 UND Runde_n == 1
1 2 5 7
Produkt [0]
UND-Bereich
Bit 0
Zustand Bit 1
Bit 2
Bit 3
Runden-
zähler
Bit 4
ODER-Bereich
Multiplexer
Clk_Produkt
Clk_Mkand
Init/>>1
Bit 0
Bit 1 Folgezustand
Bit 2
Bit 3 neuer
Bit 4 Rundenzähler
Aufgabe 3 Pipelining (20 Punkte)

Gegeben ist der folgende aus der Übung bekannte MMIX-Pipelining-Datenpfad.
Sp.-Puls
Reg.-Schreiben
Ergebnisauswahl ES
Sp.-Schreiben
4 Reg.-Puls Zugriffs-Art 2 SP ES
64 Clk1
Steuerung ALU-Funktion 8
Add 24..31
64 Direktoperand AF SP ES
Clk2 2
X-Auswahl
64 Clk3
Clk4
32
BZ Registerblock
64 Schreiben Zugriffs- Schrei-
8 Art ben
64 Schreib- 64 64
Daten $X Lese- $X $X Schreib-
Adresse 16..23 Daten $X Daten
32 0 64 64
BR Schreiben/ Lese- $Y
Befehls- Lesen $X Daten $Y 64
1 64 Erg Lese- Lese
Speicher Lese- ALU ALU
Adr.
Daten
0
$Z 0 Dat.
8..15 Daten $Z 64
Daten Lesen $Y Daten- Erg
1
0..7 Dir ALU
32 Lesen $Z 1 Speicher
Op.
8 64
64
0
16..23 56 X X X
8 8 8
64
Betrachten Sie den folgenden Ausschnitt aus einem MMIX-Programm:
LDO $3,$254,0 Zeile 1

SUB $254,$254,8 Zeile 2
STO $3,$254,0 Zeile 3
STO $3,$254,8 Zeile 4
* a) Tragen Sie in das nachfolgend angegebene Pipeline-Füll-Diagramm alle zur Auflö-

sung von Datenkonflikten benötigten Forwarding-Pfade ein. Nehmen Sie dazu an,
dass der Registerblock einen Wert, der gerade nach $X geschrieben wird, nicht
gleichzeitig an seinem Leseausgang wieder bereitstellen kann. (4 Punkte)
B-Sp. Reg ALU D-Sp. Reg

LDO LDO LDO LDO LDO

SUB SUB SUB SUB SUB
Zeile 2-4
Zeile 2-3
Zeile 2-3
Zeile
1-3

STO STO STO STO STO
Zeile
Zeile
2-4
1-4

STO STO STO STO STO
* b) Tritt ein Steuerungskonflikt auf? Begründung! (2 Punkte)
Es tritt kein Steuerungskonflikt auf, da in der Befehlsfolge kein Sprung vorkommt.
* c) Tritt ein Strukturkonflikt auf? Begründung! (2 Punkte)
Es tritt folgender Strukturkonflikt auf: Wenn der LDO-Befehl aus Zeile 1 die ausge-
lesenen Daten in das Register $3 schreiben will, will gleichzeitig der STO-Befehl
aus Zeile 4 den Wert des Registers $3 auslesen.
d) Wie kann der in Teilaufgabe b) oder Teilaufgabe c) aufgetretene Konflikt gelöst

werden? Müssen zur Ausführung der angegebenen Codesequenz Stalls eingefügt
werden? (2 Punkte)
Der Konflikt aus Teilaufgabe c) wird durch die in der Teilaufgabe a) eingezeichne-
ten Forwarding-Pfade automatisch gelöst, da der Wert aus Register $3 direkt aus
dem Datenpfad abgegriffen werden kann, und nicht erst aus dem Registerblock ge-
laden werden muss. Es müssen also keine Stalls eingefügt werden.
Nehmen Sie Im Folgenden an, dass das Register $0 mit dem Wert 0x1F0 belegt ist,
der ALU-Steuercode zur Addition den Wert 0x01 hat und mindestens 10 Befehle vor
dem LDO-Befehl das Register $254 nicht mehr verändert wurde.
* e) Geben Sie die Inhalte der nachfolgend abgebildeten Pipeline-Register für den Zeit-
punkt an, zu dem der LDO-Befehl gerade in das letzte Pipeline-Register geladen
wurde. Nehmen Sie an, dass alle notwendigen Forwarding-Pfade im Datenpfad ge-
schaltet waren. (10 Punkte)
Reg.Schr.: 0
ES
Erg.Ausw.: egal
Sp.Schr.: 1 Reg.Schr.: 1
SP
Zugr.-Art: STO Erg.Ausw.: 1
ALU: 0x01 Sp.Schr.: 0 Reg.Schr.: 1

AF
Dir.Op.: 1 Zugr.-Art: X Erg.Ausw.: 0
$X: $X: 0x3F..F8 Lese-Daten:

0x279500D6
$Y: 0x3F..F0 oder unbestimmt 0x279500D6
STO $3,$254,8 $Z: 0x1F0 Erg.ALU: Erg.ALU:

Dir.Op.: 0x00 0x3FF...F0 0x3FF...F8
X: 0x03 X: 0xFE X: 0x03
STO $3,$254,8 STO $3,$254,0 SUB $254,$254,8 LDO $3,$254,0

Aufgabe 4 Cachespeicher (15 Punkte)
Eine Implementierung des MMIX-Prozessors verfügt über einen 4-fach set-assoziati-

ven Befehls-Cache-Speicher. Die Rahmengrösse beträgt 64 Byte.
* a) Tragen Sie in nachfolgende Skizze die Anzahl der Bits ein, die für den Schlüssel,
die Set-Nummer und die Byteauswahl benötigt werden, wenn der Cachespeicher
über 8192 Sets verfügt. (3 Punkte)
Zugriffsadresse = 64 Bit
MSB Schlüssel Set-Nr. Byteauswahl LSB
45 Bit 13 Bit 6 Bit
v
v
Set 0
v
v Rahmen
v
Set 1
v
v
v
Set 8191
v
Tag-RAM Inhaltsteil des Caches
* b) Wieviele zusätzliche Befehle können beim Laden eines Befehls durch Prefetching
maximal mitgeladen werden? Begründung! (2 Punkte)
Rahmengrösse = 64 Byte ⇒ In einen Rahmen passen 64/4 = 16 Befehle. Neben

dem aktuellen Befehl können somit noch 16 – 1 = 15 zusätzliche Befehle aus dem
Cache geladen werden.
* c) Wieviele 1-Bit-Address-Vergleicher wären für den oben abgebildeten 4 fach set-

assoziativen Cache notwendig, wenn die Schlüsselbreite 44 Bit, die Set-Nr. 12 Bit
und die Byteauswahl 8 Bit umfassen würde? Rechenweg! (2 Punkte)
44 · 4 = 176 1-Bit-Adress-Vergleicher.
Der direkt abgebildete Daten-Cache des MMIX sei wie folgt aufgebaut:
Zugriffsadresse = 64 Bit
MSB Schlüssel Rahmen-Nr. Byteauswahl LSB
42 Bit 16 Bit 6 Bit
Rahmen 0 v
Rahmen 1 v
v
v
v
v
v
Rahmen 65535 v
Tag-RAM Inhaltsteil des Caches
* d) Wieviele 1-Bit-Adress-Vergleicher sind für diesen Cache notwendig? Begründung!

(2 Punkte)
Schlüsselbreite = 42 Bit ⇒ 42 1-Bit-Vergleicher.
* e) Geben Sie die Cache-Grösse in der Einheit MByte an. Rechenweg! (2 Punkte)
216 Rahmen zu je 26 Byte = 222 Byte = 22 MByte = 4 MByte.
Ein Programm führt Zugriffe auf nachfolgend angegebene Adressen durch.
* f) Tragen Sie für die angegebenen Adressen in nachfolgende Tabelle die zugehörige
Rahmennummer hexadezimal ein. (4 Punkte)
Adresse Rahmen
0x2000 0000 0000 0008 0x0000
0x2000 0000 0000 0080 0x0002
0x2000 0000 000A 0010 0x2800
0x2000 0000 07B0 0123 0xC004
Konzeptpapier

06 Ss 2004 Ct+Cs (Ei+It) Loesung

Hochgeladen von

Dokumentinformationen

Copyright

Verfügbare Formate

Dieses Dokument teilen

Dokument teilen oder einbetten

Freigabeoptionen

Stufen Sie dieses Dokument als nützlich ein?

Sind diese Inhalte unangemessen?

Copyright:

Verfügbare Formate

06 Ss 2004 Ct+Cs (Ei+It) Loesung

Hochgeladen von

Copyright:

Verfügbare Formate

TECHNISCHE UNIVERSITÄT MÜNCHEN

Fakultät für Elektrotechnik und Informationstechnik

DIPLOMVORPRÜFUNG FÜR ELEKTROINGENIEURE

Aufgabe 1 MMIX-Programmierung (56 Punkte)

Das Programm soll in zwei Teile gegliedert werden

Zunächst müssen einige globale Definitionen vorgenommen werden.

Im Folgenden soll das Hauptprogramm (Main) implementiert werden.

* e) Beginnen Sie das Hauptprogramm, indem Sie das Plancksche Wirkungsquantum

:Main LDT h,:H H -> Register

Stackpointer 00... ...0 32 Bit breiter Dividend 0x3FFFFFFFFFFFFFF0

SUB :SP,:SP,2*8 Stackpointer anpassen

Stackpointer 00... ...0 32 Bit breites Ergebnis 0x3FFFFFFFFFFFFFF8

LDO Rk,:SP,0 Ergebnis vom Stack holen

LDO Rk,:SP,0 Rk vom Stack holen

TRAP 0,:Halt,0 Programm beenden

:fdiv32 SUB :SP,:SP,10*8 Stackpointer anpassen

Damit die Division mant_dividend/mant_divisor ein brauchbares Ergebnis liefert, muss

Aufgabe 2 Multiplikationsalgorithmus und Steuerwerk (41 Pkte)

Gegeben ist der nachfolgende Multiplikationsalgorithmus mit zugehöriger Schaltungs-

Multiplikand im Multiplikand-Register ablegen

Multiplikator im rechten Teil des Produkt-Registers ablegen Initialisierung

Linken Teil des Produkt-Registers mit 0 initialisieren

Produkt links = Produkt links + Multiplikand

Produkt = Produkt >> 1

n Bit n-Bit Addierer

rechts schieben Steuerung

Produkt links Produkt rechts

auch ok: 127

• In den Zuständen 5 und 6 wird der im Produkt-Register befindliche Wert um ei-

Runde_n == 0 UND Produkt[0] == 0

Runde_n == 0 UND Produkt[0] == 1

In den restlichen beiden Teilaufgaben wird ausschliesslicher dieser Automat betrachtet.

immer Produkt[0] == 1 Produkt[0] == 0 immer

* f) Implementieren Sie für den angegebenen Zustandsautomaten die Ausgangsfunk-

4 UND Runde_n == 0 3 UND Runde_n == 1

Aufgabe 3 Pipelining (20 Punkte)

Betrachten Sie den folgenden Ausschnitt aus einem MMIX-Programm:

LDO $3,$254,0 Zeile 1

* a) Tragen Sie in das nachfolgend angegebene Pipeline-Füll-Diagramm alle zur Auflö-

B-Sp. Reg ALU D-Sp. Reg

B-Sp. Reg ALU D-Sp. Reg

B-Sp. Reg ALU D-Sp. Reg

B-Sp. Reg ALU D-Sp. Reg

* b) Tritt ein Steuerungskonflikt auf? Begründung! (2 Punkte)

Es tritt kein Steuerungskonflikt auf, da in der Befehlsfolge kein Sprung vorkommt.

* c) Tritt ein Strukturkonflikt auf? Begründung! (2 Punkte)

d) Wie kann der in Teilaufgabe b) oder Teilaufgabe c) aufgetretene Konflikt gelöst

ALU: 0x01 Sp.Schr.: 0 Reg.Schr.: 1

$X: $X: 0x3F..F8 Lese-Daten:

STO $3,$254,8 $Z: 0x1F0 Erg.ALU: Erg.ALU:

STO $3,$254,8 STO $3,$254,0 SUB $254,$254,8 LDO $3,$254,0

Aufgabe 4 Cachespeicher (15 Punkte)

Eine Implementierung des MMIX-Prozessors verfügt über einen 4-fach set-assoziati-

MSB Schlüssel Set-Nr. Byteauswahl LSB

45 Bit 13 Bit 6 Bit

Tag-RAM Inhaltsteil des Caches

Rahmengrösse = 64 Byte ⇒ In einen Rahmen passen 64/4 = 16 Befehle. Neben

* c) Wieviele 1-Bit-Address-Vergleicher wären für den oben abgebildeten 4 fach set-

MSB Schlüssel Rahmen-Nr. Byteauswahl LSB

42 Bit 16 Bit 6 Bit

Tag-RAM Inhaltsteil des Caches

* d) Wieviele 1-Bit-Adress-Vergleicher sind für diesen Cache notwendig? Begründung!

Schlüsselbreite = 42 Bit ⇒ 42 1-Bit-Vergleicher.

216 Rahmen zu je 26 Byte = 222 Byte = 22 MByte = 4 MByte.