GOP Computertechnik. Computersysteme Probeklausur 2

Transkript

1 Prüfungsfähigkeit: Weitere Hinweise: Die Prüfungsdauer beträgt 75 Minuten. Es sind keine Hilfsmittel erlaubt, auch keine Taschenrechner! Heftung nicht öffnen - keine Blätter abtrennen! Lösungen bitte immer nur in den dafür vorgesehenen Abschnitt eintragen. An anderen Stellen eingetragene Lösungen werden nicht bewertet. Ggf. zweiten Angabebogen anfordern. Verwenden Sie zum Schreiben bitte einen dunklen Stift - die Prüfungen werden eingescannt! Die Prüfung besteht inkl. Anhang und Konzeptpapier aus Seiten - bitte überprüfen! Die angegebene Anzahl zu erreichender Punkte ist als vorläufig zu betrachten. Alle Aufgaben sind unabhängig von der Lösung vorangegangener Aufgaben lösbar. Vorangegangene Angaben können benötigt werden. Bitte ausfüllen: GOP Computertechnik Computersysteme Probeklausur Hiermit bestätige ich, dass ich vor Prüfungsbeginn darüber in Kenntnis gesetzt wurde, dass ich im Falle einer plötzlich während der Prüfung auftretenden Erkrankung das Aufsichtspersonal umgehend informieren muss. Dies wird im Prüfungsprotokoll vermerkt. Danach muss unverzüglich ein Rücktritt von der Prüfung beim zuständigen Prüfungsausschuss beantragt werden. Ein vertrauensärztliches Attest - ausgestellt am Prüfungstag - ist unverzüglich nachzureichen. Wird die Prüfung hingegen in Kenntnis der gesundheitlichen Beeinträchtigung dennoch regulär beendet, kann im Nachhinein kein Prüfungsrücktritt aufgrund von Krankheit beantragt werden. Wird die Prüfung wegen Krankheit abgebrochen, wird die Klausur mit der Note "5, - nicht erschienen" gemeldet und - unabhängig von einem Rücktrittsantrag - nicht bewertet. Name: Musterlösung Vorname: Matrikel-Nr.: Unterschrift: Hörsaal: Reihe: Platz: Fakultät: EI EDU BWL INF Hier Etikett einkleben (Prüfungsaufsicht): Aufg. Aufg. Aufg. Aufg. 4 Aufg. 5 Aufg. 6 Aufg. 7 Punkte: Note:

2 Übersicht Komponenten Computer-Systeme (5 Punkte) Darstellung von Zahlen und Zeichen (6 Punkte) Arithmetische Schaltungen ( Punkte) 4 4 Universalrechner (9 Punkte) 5 MMIX ( Punkte) 5. Assembler- und Loaderbefehle ( Punkte) MMIX-Befehlsformat - Übersetzungstabelle (4 Punkte) Lade- und Speicher-Befehle Alignment (9 Punkte) Arithmetische Befehle (7 Punkte) Funktionsaufrufe/Stack (4 Punkte) Pipelining (6 Punkte) 6 7 Cache-Speicher (9 Punkte)

3 Komponenten Computer-Systeme (5 Punkte) a) Skizzieren Sie das Blockschaltbild des in der Vorlesung besprochenen Schaltnetzteils (4 Punkte) V ~ Gleichrichter ~ = Schalt- Glied HF Trafo Gleichrichter ~ Tiefpass = 5 V = Galvanische Trennung Regelkreis = b) Wie groß muss bei einem optischen Datenträger der Abstand Pit Land sein, damit destruktive Interferenz auftreten kann? ( Punkt) λ/4 Darstellung von Zahlen und Zeichen (6 Punkte) a) Wie lässt sich im Falle der Addition zweier Zahlen im er-komplement ein Überlauf feststellen? ( Punkte) pos + pos = neg; neg + neg = pos b) In welcher Zahldarstellung ist der Abstand zweier aufeinander folgender Zahlen stets gleich groß: Bei Festkommazahlen oder bei Gleitkommazahlen? ( Punkt) Festkommazahlen c) Geben Sie den Wert der gegebenen Gleitkommazahl dezimal an. ( Punkte).. Exponent: e-k = - 7 = 4 ( Punkt) Mantisse:, 4 =, Wert: -7,5

4 4 Arithmetische Schaltungen Arithmetische Schaltungen ( Punkte) a) Tragen Sie in nachfolgende Abbildung die Realisierung eines Bit -auf- De- Multiplexers ein. ( Punkte) Gegeben ist die aus der Vorlesung bekannte Volladdierer-Schaltung. x i y i c i- c i s i b) Geben Sie für die gezeigte Schaltung die Signale g i (x i, y i ) (generate) und p i (x i, y i ) (propagate) in Abhängigkeit ihrer Eingangswerte an. ( Punkte) g i = x i y i p i = x i y i

5 5 Gegeben ist die aus der Vorlesung bekannte dreistufige Carry-Look-Ahead-Einheit. x y add/sub CLA-Einheit d CLA-Einheit c CLA-Einheit b CLA-Einheit a GG PP CC GG PP CC GG PP CC GG PP CC CLA-Einheit e CC 4 Überlauf- Erkennung s c) Geben Sie an, wie sich das Signal CC aus den Signalen PP i, GG i und CC zusammensetzt. Wieviele Gatterlaufzeiten τ werden im Fall Fan-In = mindestens benötigt, um CC aus PP i, GG i und CC zu bestimmen? ( Punkte) CC = GG (PP GG ) (PP PP CC ) ( Punkte) τ ( Punkt) Gegeben ist der folgende logische Ausdruck: x = (a b c d) e (f g) h. d) Zeichen Sie für Fan-In = eine Gatterschaltung zur Bestimmung von x. ( Punkte) a b c d e x f g h

6 6 Arithmetische Schaltungen Nachfolgende Schaltung zeigt einen Datenpfad, der die Anzahl der Buchstaben und Ziffern einer maximal 55 Zeichen langen ASCII-Zeichenkette bestimmt und im Speicher ablegt. Die Zeichenkette ist mit abgeschlossen. Schreiben Adresse Speicher Daten Ausgang Daten Eingang Ziffern-Adresse Add Buchstaben-Adresse Ende? Ziffer? Buchstabe? A B RA clk_ra clk_mem ende mux_bz clk_bz Zeichenketten-Adresse mux_init RB Add Steuerung clk_init RZ Add mux_adr Schaltung A prüft, ob das vom Speicher ausgegebene Byte das String-Ende markiert (Byte mit Wert Null ). Ist das Ende erreicht, gibt Schaltung A am Ausgang eine aus. Anderenfalls gibt Schaltung A eine aus. e) Tragen Sie in nachfolgende Abbildung eine Realisierung der Schaltung A ein. ( Punkte) A

7 7 Schaltung B gibt am Ausgang eine aus, wenn das vom Speicher ausgegebene Byte eine Ziffer ist (ASCII-Wert zwischen 4 und 57). Ansonsten gibt Schaltung B eine aus. f) Tragen Sie in nachfolgende Abbildung eine Realisierung der Schaltung B ein. (5 Punkte) B 47 a b a-b 7 5 a b a-b 7 Punkte Obergrenze Punkte Untergrenze Punkt Verknüpfung

8 Arithmetische Schaltungen Nachfolgende Abbildung zeigt noch einmal den Datenpfad. Schreiben Adresse Speicher Daten Ausgang Daten Eingang Ziffern-Adresse Buchstaben-Adresse Add Ende? Ziffer? Buchstabe? A B RA clk_ra clk_mem ende mux_bz clk_bz Zeichenketten-Adresse mux_init RB Add Steuerung clk_init RZ Add mux_adr Die Steuerung des Datenpfads soll wie folgt funktionieren: In den Zuständen und soll das Register RA mit der Zeichenketten-Adresse und die Register RB und RZ mit initialisiert werden (,5 Punkte). Ist in Zustand die Zeichenkette leer, soll in den Zustand 5 verzweigt werden. Anderenfalls soll in Zustand verzweigt werden (,5 Punkte). Von Zustand wird immer in Zustand 4 verzweigt. Dabei soll der in Register RB stehende Wert um erhöht werden, falls das von Register RA adressierte Zeichen ein Buchstabe ist, d.h. wenn Block Buchstabe? eine ausgibt; der in Register RZ stehende Wert um erhöht werden, falls das vom Register RA adressierte Zeichen eine Ziffer ist. (,5 Punkte) Ist die Zeichenkette nicht leer, soll nach Zustand 4 wieder in Zustand verzweigt werden. Dabei soll im Speicher das nächste Byte der Zeichenkette adressiert werden. Anderenfalls soll in Zustand 5 verzweigt werden. (,5 Punkte) Von Zustand 5 soll immer in den Zustand 6 verzweigt werden. Dabei soll der im Register RB abgelegte Wert im Speicher an die Buchstaben-Adresse geschrieben werden. Von Zustand 6 soll immer in Zustand 7 verzweigt werden. (,5 Punkte)

9 9 Von Zustand 7 soll immer in Zustand verzweigt werden. Dabei soll der im Register RZ abgelegte Wert im Speicher an der Ziffern-Adresse abgelegt werden. (,5 Punkte) g) Vervollständigen Sie nachfolgenden Moore-Automaten so, dass er die Hardware in gewünschter Weise steuert. Geben Sie für irrelevante Werte X an. (9 Punkte) immer ende == immer Initialisieren Initialisieren Zählen 4 Zählen mux_init: mux_init: mux_init: mux_init: mux_adr: X mux_adr: mux_adr: mux_adr: mux_bz: X mux_bz: X mux_bz: X mux_bz: clk_bz: clk_bz: clk_bz: clk_bz: clk_ra: clk_ra: clk_ra: clk_ra: clk_mem: clk_mem: clk_mem: clk_mem: clk_init: clk_init: clk_init: clk_init: ende == ende == ende == RZ/Ende 7 RZ 6 RB 5 RB mux_init: X mux_init: X mux_init: X mux_init: X mux_adr: mux_adr: mux_adr: mux_adr: mux_bz: mux_bz: mux_bz: mux_bz: clk_bz: clk_bz: clk_bz: clk_bz: clk_ra: clk_ra: clk_ra: clk_ra: clk_mem: clk_mem: clk_mem: clk_mem: clk_init: clk_init: clk_init: clk_init: immer immer immer immer

10 Arithmetische Schaltungen Nachfolgende Abbildung zeigt einen anderen Moore-Automaten. immer ende = ende = Initialisieren Initialisieren Addieren 4 Schieben 5 Ende clk: clk: clk: clk: clk: clk: clk: clk: clk: clk: init: init: init: init: init: reset: reset: reset: reset: reset: ende = immer ende = immer Dieser Moore-Automat soll mit folgender Schaltung implementiert werden: clk clk init reset ROM D-Register ende h) Tragen Sie in nachstehende Tabelle binär die ROM-Inhalte für die angegebenen Adressen ein. Zustand wird mit kodiert, Zustand mit,... (5 Punkte) Adresse x x4 x9 xb xc Daten 6 5 4

11 4 Universalrechner (9 Punkte) Gegeben ist der aus der Vorlesung bekannte Universalrechner. clk reset a b c M BZ R D K D4 D D D D D M4 D9 D D7 M A7 D6 D5 A D4 M D D D M D Add M M A D R7 R6 R5 R4 R R R R M M4 M4 MSB M A a SUB a-b b ADD MUL a DIV a/b b p X n- n M 4 5 M a) Tragen Sie in nachstehende Tabelle binär den Speicherinhalt zur Berechnung von b a ein. Gehen Sie entsprechend der Kommentare vor. Geben Sie für alle irrelevanten Werte X an. (9 Punkte) K D M4 M M M Kommentar XXXXXXXXXX XXX XXX XXX R = b XXX XXX R = XXXXXXXXXX R = *b XXXXXXXXXX XXX XXX XXX R = a XXXXXXXXXX XXX R = sqrt(a) XXXXXXXXXX R = b-sqrt(a) Pro Zeile,5 Punkte. Pro Zeile für jede falsche Spalte,5 Punkte Abzug. Pro Zeile mindestens Punkte.

12 5 MMIX 5 MMIX ( Punkte) Hinweis: Sie können in allen Aufgaben buf, buf,... als Pufferregister verwenden. 5. Assembler- und Loaderbefehle ( Punkte) a) Mit welcher Anweisung können Sie den Namensraum Main: eröffnen? ( Punkt) PREFIX Main: b) Wie kann innerhalb eines Namensraums auf globale Variable zugegriffen werden? ( Punkt) Doppelpunkt voranstellen. c) Geben Sie den Befehl an, mit dem Sie Register durch a ansprechbar machen. ( Punkt) a IS $ d) Geben Sie die Befehle an, mit denen Sie im Speicher an Adresse x einen vierdimensionalen Vektor anlegen, dessen Elemente Bit Gleitkommawerte sind. Der Vektor soll über die Marke V ansprechbar sein. Die Vektor-Elemente sollen jeweils mit, initialisiert werden. Stellen Sie ein geeignetes Basisregister zur Adressierung bereit. ( Punkte) LOC Data_Segment V TETRA,,, e) Geben Sie den Befehl an, mit dem Sie ein Programm aus einem Namensraum heraus beenden. ( Punkte) TRAP,:Halt,

13 5. MMIX-Befehlsformat - Übersetzungstabelle 5. MMIX-Befehlsformat - Übersetzungstabelle (4 Punkte) Beachten Sie nachfolgende Tabelle.!! x.. x.. x.. x.. x4.. x5.. x6.. x7.. x.. x9.. xa.. xb.. xc.. xd.. xe.. xf.. x.. x.. x.. x.. x..4 x..5 x..6 x..7 TRAP 5ν FCMP ν FUN ν FEQL ν FADD 4ν FIX 4ν FSUB 4ν FIXU 4ν FLOT[I] 4ν FLOTU[I] 4ν SFLOT[I] 4ν SFLOTU[I] 4ν FMUL 4ν FCMPE 4ν FUNE ν FEQLE 4ν FDIV 4ν FSQRT 4ν FREM 4ν FINT 4ν MUL[I] ν MULU[I] ν DIV[I] 6ν DIVU[I] 6ν ADD[I] ν ADDU[I] ν CMP[I] ν SL[I] ν BN[B] ν+π BNN[B] ν+π PBN[B] ν-π PBNN[B] ν-π CSN[I] ν ADDU[I] ν 4ADDU[I] ν CMPU[I] ν SLU[I] ν BZ[B] ν+π BNZ[B] ν+π PBZ[B] ν-π PBNZ[B] ν-π CSZ[I] ν SUB[I] ν ADDU[I] ν NEG[I] ν SR[I] ν BP[B] ν+π BNP[B] ν+π PBP[B] ν-π PBNP[B] ν-π CSP[I] ν SUBU[I] ν 6ADDU[I] ν NEGU[I] ν SRU[I]ν BOD[B] ν+π BEV[B] ν+π PBOD[B] ν-π PBEV[B] ν-π CSOD[I] ν CSNN[I] ν ZSN[I] ν CSNZ[I] ν ZSZ[I] ν CSNP[I] ν ZSP[I] ν CSEV[I] ν ZSOD[I] ν ZSNN[I] ν ZSNZ[I] ν ZSNP[I] ν ZSEV[I] ν LDB[I] µ+ν LDBU[I] µ+ν LDW[I] µ+ν LDWU[I] µ+ν LDT[I] µ+ν LDTU[I] µ+ν LDO[I] µ+ν LDOU[I] µ+ν LDSF[I] µ+ν LDHT[I] µ+ν CSWAP[I] µ+ν LDUNC[I] µ+ν LDVTS[I] ν PRELD[I] ν PREGO[I] ν GO[I] ν STB[I] µ+ν STBU[I] µ+ν STW[I] µ+ν STWU[I] µ+ν STT[I] µ+ν STTU[I] µ+ν STO[I] µ+ν STOU[I] µ+ν STSF[I] µ+ν STHT[I] µ+ν STCO[I] µ+ν STUNC[I] µ+ν SYNCD[I] ν PREST[I] ν SYNCID[I] ν PUSHGO[I] ν OR[I] ν ORN[I] ν NOR[I] ν XOR[I] ν AND[I] ν ANDN[I] ν NAND[I] ν NXOR[I] ν BDIF[I] ν WDIF[I] ν TDIF[I] ν ODIF[I] ν MUX[I] ν SADD[I] ν MOR[I] ν MXOR[I] ν SETH ν SETMH ν SETML ν SETL ν INCH ν INCHM ν INCML ν INCL ν ORH ν ORMH ν ORML ν ORL ν ANDNH ν ANDNMH ν ANDNML ν ANDNL ν JMP[B] ν PUSHJ[B] ν GETA[B] ν PUT[I] ν POP ν RESUME 5ν [UN]SAVE µ+ν SYNC ν SWYM ν GET ν TRIP 5ν x.. x..9 x..a x..b x..c x..d x..e x..f x.. x.. x.. x.. x4.. x5.. x6.. x7.. x.. x9.. xa.. xb.. xc.. xd.. xe.. xf..! Gegeben ist der folgende MMIX-Code: Start BZ $,Ende SRU $,$, JMP Start Ende OR $,$, a) In welches Befehlswort wird der Befehl JMP Start übersetzt? ( Punkte) xffffffe ( Pkt für Opcode; Pkt für -) b) In welches Befehlswort wird der Befehl BZ $,Ende übersetzt? ( Punkte) x4 (Ausgehend von Punkten für jedes falsche Element Opcode, X oder YZ Punkt Abzug; mindestens Punkte.)

14 4 5 MMIX 5. Lade- und Speicher-Befehle Alignment (9 Punkte) Gegeben ist die folgende Speicherbelegung: LOC Data_Segment $54 x.. X BYTE,7,9,6 Y OCTA a) Geben Sie hexadezimal alle Bit des Registers nach Ausführung der folgenden Befehle an. ( Punkte) LDB $,X: xffff FFFF FFFF FF LDB $,$54,: x 7F LDW $,$54,: xffff FFFF FFFF 7E In folgendem Programmcode wird XXX XXXXXXXXXX als Platzhalter für einen einzelnen Befehl verwendet. LOC Data_Segment $54 x.. A WYDE #,#9 B TETRA #679 Z OCTA #FFFFFFFFFFFFFFFF LOC # Main LDO $,A LDB $,B LDW $,$54,7 XXX XXXXXXXXXX TRAP,Halt, b) Geben Sie für das gezeigte Programm den Inhalt des Bit breiten Datenworts an, welches durch die Marke Z adressiert wird, wenn XXX XXXXXXXXXX jeweils durch den folgenden Befehl ersetzt wird: (6 Punkte) STT $,Z: xffff 9 FFFF FFFF STT $,Z: x FFFF FFFF STO $,Z: x

15 5.5 Funktionsaufrufe/Stack Arithmetische Befehle (7 Punkte) a) Geben Sie MMIX-Befehle an, mit denen Sie die beiden an den Speicher-Adressen X und Y befindlichen Bit breiten Gleitkommazahlen in die Register x und y einlesen,, 5 x + y berechnen und das Ergebnis als Bit breite Gleitkommazahl im Speicher an der Marke Z ablegen. (7 Punkte) Hinweis: Register x und y sowie Speicherstellen X, Y und Z sind bereits (im selben Namensraum) deklariert/definiert und können direkt verwendet werden. LDO x,x,5 Punkte LDO y,y,5 Punkte FLOT buf,7,5 Punkte FLOT buf,,5 Punkte FDIV buf,buf,buf buf =,5; Punkt FMUL buf,x,x buf = x*x; Punkt FMUL buf,buf,buf buf =,5*x*x; Punkt FADD buf,buf,y buf =,5*x*x+y Punkt STO buf,z Punkt 5.5 Funktionsaufrufe/Stack (4 Punkte) Die Funktion fkt hat bei ihrem Aufruf einen Parameter auf dem Stack übergeben bekommen und die Register und auf den Stack gesichert. Dabei wurde Register an der niederwertigeren Adresse abgelegt. Die Rücksprungadresse wurde in Register übergeben. Die Funktion hat ein Ergebnis berechnet und dieses in Register abgelegt. a) Geben Sie den MMIX-Code an, mit dem Sie das in Register gespeicherte Ergebnis zur Übergabe an den Funktions-Aufrufer auf dem Stack ablegen, die Register wiederherstellen und zum Funktions-Aufrufer zurückspringen. (4 Punkte) Hinweis: Der Stackpointer kann über SP angesprochen werden. STO $,:SP,* LDO $,:SP, LDO $,:SP,* GO $,$,

16 6 6 Pipelining 6 Pipelining (6 Punkte) Gegeben ist der bekannte Pipelining-Datenpfad. Sp.-Puls 4 BZ Add Adresse Befehls- Speicher Daten Clk Reg.-Puls 4.. X-Auswahl Reg.-Schreiben Ergebnisauswahl ES Sp.-Schreiben Zugriffs-Art SP Steuerung ALU-Funktion Direktoperand AF Registerblock Schreiben Clk Schreib- Daten $X Lese- 6.. Daten $X $X Schreiben/ Lese- BR Lesen $X Daten $Y $Y Lese- $Z..5 Daten $Z Lesen $Y..7 Dir Lesen $Z Op. Clk ALU ES SP $X Erg ALU Zugriffs- Art Schreib- Daten Adr. Clk4 Daten- Speicher Schreiben Lese- Daten ES Lese Dat. Erg ALU X X X Betrachten Sie folgenden Ausschnitt aus einem MMIX-Programm: Start SUB $,$, Zeile BZ $,Ende Zeile LDB $,$,$ Zeile STB $,$4,$ Zeile 4 JMP Start Zeile 5 a) Geben Sie alle auftretenden Datenkonflikte an. Nehmen Sie an, dass ein Datenwort, das gerade in den Registerblock hineingeschrieben wird, vom Registerblock nicht gleichzeitig am Ausgang ausgegeben werden kann. (4 Punkte) Zeile und wg. $ Zeile und wg. $ Zeile und 4 wg. $ Zeile und 4 wg. $ b) Muss zwischen Zeile und 4 ein Stall eingefügt werden, oder kann prinzipiell ein Forwarding-Pfad verwendet werden? Begründung! ( Punkte) Nein, es muss kein Stall eingefügt werden, da das aus dem Speicher ausgelesene Datum nicht von der ALU verarbeitet werden muss, sondern wieder in der SP- Phase benötigt wird.

17 7 c) Was versteht man unter einem Strukturkonflilkt? Geben Sie ein Beispiel an. ( Punkte) Gleichzeitiger Zugriff auf nur einmal verfügbare Ressource. Beispiel: STO will in BD-Phase X adressieren um $X auszulesen, während anderer Befehl in ES-Phase X adressierten will um Ergebnis zurückzuschreiben. Nehmen Sie folgende Register-Belegung an: $ = x, $ = x, $54 = x. Nehmen Sie desweiteren an, dass im Speicher an Adresse x das Bit breite Datenwort x ABC DEF abgelegt ist. Nehmen Sie folgende Forwarding-Pfade an: Vom Ausgang der ALU zu den $X, $Y und $Z-Eingängen des auf die BD-Phase folgenden Pipeline-Registers. Vom Ende der SP-Phase (Ausgang Speicher sowie Ergebnis ALU) zu den $X, $Y und $Z-Eingängen des auf die BD-Phase folgenden Pipeline-Registers. d) Tragen Sie in nachfolgende Abbildung den Inhalt der Pipeline-Register für die unter den Pipeline-Registern angegebenen Befehle ein. Nehmen Sie an, dass die benötigten Forwarding-Pfade genutzt wurden. Geben Sie für alle irrelevanten Einträge X an. ( Punkte) Reg. Schr.: Erg. Ausw.: Sp. Schr.: Reg. Schr.: Zugr.-Art: egal Erg. Ausw.: ALU: 5 Sp. Schr.: Reg. Schr.: Dir. Op.: Zugr.-Art: X Erg. Ausw.: $X: xff FDEF $X: x Lese-Daten: $Y: x44 xff FDEF STO $,$54, $Z: xff FDEF Erg. ALU: x44 Erg. ALU: Dir. Op.: x 7 X: X: X: STO $,$54, SUB $,$,$ MUL $,$, LDW $,$54,7 Pro richtigem Eintrag,5 Punkte. Egal statt X auch ok. Werte können sowohl dezimal als auch hexadezimal o.ä. angegeben werden.

18 7 Cache-Speicher 7 Cache-Speicher (9 Punkte) Ein Programm besteht aus Lade- und Speicher-Befehlen, für deren Ausführung insgesamt, µs beobachtet werden. a) Wie groß ist die Hit-Rate, wenn die Hit-Time ns und die Miss-Time ns betragen? ( Punkte) h ns + ( h) ns =, µs h ns + ns h ns = ns ns h = ns ns h = ns/ ns = / Ansatz: Punkte Ergebnis: Punkt b) Warum werden bei einem Arbeitsspeicher-/Cache-Zugriff die oberen Bits der Arbeitsspeicher-Adresse als Schlüssel im Tag-RAM abgelegt? ( Punkte) Viele Arbeitsspeicher-Rahmen werden auf einen einzelnen Cache-Rahmen abgelegt. Durch das Abspeichern des oberen Teils wird festgehalten, welche der vielen möglichen Arbeitsspeicher-Stellen im Cache abgelegt ist. c) Wie groß ist ein direkt-abgebildeter Cache, wenn bei Zugriffen 9 Schlüssel-Bits mit 9 Tag-Bits verglichen werden müssen, die Adressbreite Bit beträgt und in einem einzelnen Rahmen Byte abgespeichert werden können? ( Punkte) Bits Schlüssel: 9 Bit Bits Byteauswahl: ld() = 5 Bit Bits Rahmen: Bit = Bit Anzahl Rahmen: = 56 Größe Cachespeicher: +5 = = kb

19 9 Laden aus Speicher Schreiben in Speicher Befehl Operanden Name/Aktion Definition Befehl Operanden Name/Aktion Definition LDB LDBU LDW LDWU LDT LDTU LDO LDOU Schieben $X,$Y,$Z Load byte $X s (s(m [u($y)+u($z)])) $X,$Y,Z Load byte immediate $X s (s(m [u($y)+u(z)])) $X,$Y,$Z Load byte unsigned $X u (u(m [u($y)+u($z)])) $X,$Y,Z Load byte uns. immed. $X u (u(m [u($y)+u(z)])) $X,$Y,$Z Load wyde $X s (s(m [u($y)+u($z)])) $X,$Y,Z Load wyde immediate $X s (s(m [u($y)+u(z)])) $X,$Y,$Z Load wyde unsigned $X u (u(m [u($y)+u($z)])) $X,$Y,Z Load wyde uns. immed. $X u (u(m [u($y)+u(z)])) $X,$Y,$Z Load tetra $X s (s(m 4[u($Y)+u($Z)])) $X,$Y,Z Load tetra immediate $X s (s(m 4[u($Y)+u(Z)])) $X,$Y,$Z Load tetra unsigned $X u (u(m 4[u($Y)+u($Z)])) $X,$Y,Z Load tetra uns. immed. $X u (u(m 4[u($Y)+u(Z)])) $X,$Y,$Z Load octa $X M[u($Y)+u($Z)] $X,$Y,Z Load octa immediate $X M[u($Y)+u(Z)] $X,$Y,$Z Load octa unsigned $X M[u($Y)+u($Z)] $X,$Y,Z Load octa uns. immed. $X M[u($Y)+u(Z)] Befehl Operanden Name/Aktion Definition SL SLU SR SRU $X,$Y,$Z Shift left; with overflow $X,$Y,Z Shift left immediate; with ovf. $X,$Y,$Z Shift left uns., no overflow $X u $X,$Y,Z Shift left uns. immed.; no ovf. $X u $X u ( u($y u($z)) ) u($y) u($z) ) ra ra u (5 ) $X u ( u($y u(z)) ) u($y) u(z) ) ra ra u (5 ) ( u($y u($z)) ) ( u($y u(z)) ) $X,$Y,$Z Shift right; fill with sign $X $Y s u($z) $X,$Y,Z Shift right imm.; fill with sign $X $Y s u(z) $X,$Y,$Z Shift right unsigned; fill with $X $Y u u($z) $X,$Y,Z Shift right uns. imm.; fill w. $X $Y u u(z) STB STBU STW STWU STT STTU STO STOU Marken Befehl Operanden auflösen/adressen Name/Aktion laden Definition LDA $X,$Y,$Z Store byte; with overflow $X,$Y,Z Store byte immed.; ovf. $X,$Y,$Z Get address (absolute) $X u (u($y)+u($z)) $X,$Y,Z Get address immed. (absolute) $X u (u($y)+u(z)) GETA $X,YZ Get address (relativ) $X u M[u($Y)+u($Z)] ($X)7... s($x) 7 ) ra ra u (6 ) s($x) < 7 ) ra ra u (6 ) M[u($Y)+u(Z)] ($X)7... s($x) 7 ) ra ra u (6 ) s($x) < 7 ) ra ra u (6 ) $X,$Y,$Z Store byte unsigned M[u($Y)+u(Z)] ($X)7... $X,$Y,Z Store byte uns. imm. M[u($Y)+u(Z)] ($X)7... $X,$Y,$Z Store wyde; with overflow $X,$Y,Z Store wyde immed.; ovf. M[u($Y)+u(Z)] ($X)5... s($x) 5 ) ra ra u (6 ) s($x) < 5 ) ra ra u (6 ) M[u($Y)+u(Z)] ($X)5... s($x) 5 ) ra ra u (6 ) s($x) < 5 ) ra ra u (6 ) $X,$Y,$Z Store wyde unsigned M[u($Y)+u(Z)] ($X)5... $X,$Y,Z Store wyde uns. imm. M[u($Y)+u(Z)] ($X)5... $X,$Y,$Z Store tetra; with overflow $X,$Y,Z Store tetra immed.; ovf. M4[u($Y)+u(Z)] ($X)... s($x) ) ra ra u (6 ) s($x) < ) ra ra u (6 ) M4[u($Y)+u(Z)] ($X)... s($x) ) ra ra u (6 ) s($x) < ) ra ra u (6 ) $X,$Y,$Z Store byte unsigned M4[u($Y)+u(Z)] ($X)... $X,$Y,Z Store byte uns. imm. M4[u($Y)+u(Z)] ($X)... $X,$Y,$Z Store octa M[u($Y)+u(Z)] $X $X,$Y,Z Store octa immediate M[u($Y)+u(Z)] $X $X,$Y,$Z Store octa unsigned M[u($Y)+u(Z)] $X $X,$Y,Z Store octa uns. imm. M[u($Y)+u(Z)] $X (u(@) + 4 s(yz))

20 Arithmetische Befehle (Festkomma) BefehlOperanden Name/Aktion Definition $X,$Y,$Z Add; signed, with overflow ADD $X,$Y,Z Add immediate; signed, with overflow $X s (s($y)+s($z)) (s($y)+s($z) < 6 ) (s($y)+s($z) 6 ) ) ra ra u (5 ) $X s (s($y)+u(z)) (s($y)+s(z) < 6 ) (s($y)+s(z) 6 ) ) ra ra u (5 ) $X,$Y,$Z Add unsigned; no overflow $X u (u($y)+u($z)) ADDU $X,$Y,$Z Add unsigned; no overflow $X u $X,$Y,Z Add unsigned; no overflow $X u (u($y)+u(z)) $X,$Y,$Z Subtract; signed, with overflow SUB $X,$Y,Z Subtract immediate; signed, with overflow $X s (s($y) s($z)) (s($y) s($z) < 6 ) (s($y) s($z) 6 ) ) ra ra u (5 ) $X s (s($y) u(z)) (s($y) s(z) < 6 ) (s($y) s(z) 6 ) ) ra ra u (5 ) SUBU $X,$Y,$Z Subtract unsigned; no overflow $X u (u($y) u($z)) $X,$Y,Z Subtract unsigned immed.; no ovf. $X u (u($y) u(z)) $X,Y,$Z Negate; signed, with overflow NEG $X s (u(y) s($z)) u(y) s($z 6 ) ) ra ra u (5 ) $X,Y,Z Negate immediate; signed, with overflow $X s (u(y) s(z)) NEGU $X,Y,$Z Negate unsigned; no overflow $X s (u(y) s($z)) $X,Y,Z Negate unsigned immed.; no overflow $X s (u(y) u(z)) $X,$Y,$Z Multiply; signed, with overflow $X s (s($y) s($z)) MUL $X,$Y,Z Multiply immediate; signed, with ovf. $X s (s($y) u(z)) $X,$Y,$Z Multiply unsigned; rh ($Y $Z) 7... rh$x u (u($y) u($z)) MULU $X,$Y,$Z Multiply unsigned; rh ($Y $Z) $X,$Y,Z Multiply uns. imm.; rh ($Y Z) 7... rh$x u (u($y) u(z)) Divide; signed, with overflow $X s (bs($y)/s($z)c) $X,$Y,$Z (case $Z 6= ) rr s ( s($y)%s($z)) DIV $X,$Y,Z Divide immediate; signed, with ovf. $X u () (case $Z = ) rr $Y $X,$Y,$Z DIVU Divide unsigned; no overflow; $X u ( bu(rd$y)/u($z)c ) (case u($z) > u(rd) ) rr u ( u(rd$y)%u($z)) Divide unsigned; no overflow; $X rd no overflow (case u($z) apple u(rd) ) rr $Y Divide unsigned immediate; $X u ( bu(rd$y)/u(z)c ) no overflow; (case u(z) > u(rd) ) rr u ( u(rd$y)%u(z)) Divide; signed, with overflow $X s (bs($y)/s($z)c) $X,$Y,$Z (case $Z 6= ) rr s ( s($y)%s($z)) DIV $X,$Y,Z Divide immediate; signed, with ovf. $X u () (case $Z = ) rr $Y $X,$Y,$Z DIVU $X,$Y,Z Divide unsigned; no overflow; $X u ( bu(rd$y)/u($z)c ) (case u($z) > u(rd) ) rr u ( u(rd$y)%u($z)) Divide unsigned; no overflow; $X rd no overflow (case u($z) apple u(rd) ) rr $Y Divide unsigned immediate; $X u ( bu(rd$y)/u(z)c ) no overflow; (case u(z) > u(rd) ) rr u ( u(rd$y)%u(z)) Divide unsigned immedediate; $X rd no overflow (case u(z) apple u(rd) ) rr $Y Arithmetische Befehle (Gleitkomma) Befehl Operanden Name/Aktion Definition FADD $X,$Y,$Z Floating point add $X f ( f ($Y)+f($Z)) FSUB $X,$Y,$Z Floating point subtract $X f ( f ($Y) f($z)) FMUL $X,$Y,$Z Floating point multiplication $X f ( f ($Y) f($z)) FDIV $X,$Y,$Z Floating point divide $X f ( f ($Y)/f($Z)) p FSQRT $X,$Z Square root $ $X f f($z)) Umwandlung Befehl Operanden Festkomma Name/Aktion <-> Gleitkomma Definition FLOT $X,$Z Convert fixed to floating $X f ( s($z)) $X,Z Conv. fixed to float. imm. $X f ( u(z)) FLOTU $X,$Z Conv. uns. fixed to floating $X f ( u($z)) $X,Z Conv. uns. fixed to float. imm. $X f ( u(z)) Convert floating to fixed FIX $X,$Z with overflow $X s ( r( f ($Z))) f($z) < 6 ) ra ra u (5 ) f($z) > 6 ) ra ra u (5 ) Convert floating to fixed FIXU $X,$Z $X s without overflow ( r( f ($Z))) Spezialregister Befehl Operanden Name/Aktion Definition GET $X,Z Get value of special purpose register $X r[z] PUT X,$Z Put value to special purpose register r[x] $Z X,Z Put immed. value to spec. purp. reg. r[x] u (u(z))

21 Divide unsigned immedediate; $X rd no overflow (case u(z) apple u(rd) ) rr $Y Logische Operationen Verzweigungen Befehl Operanden Name/Aktion Definition Befehl Operanden Name/Aktion Definition AND ANDN $X,$Y,$Z Bitwise AND $X $Y & $Z $X,$Y,Z Bitwise AND $Y & u ( u(z)) immediate $X $Y & u $X,$Y,$Z Bitwise AND NOT $X $Y & $Z $X,$Y,Z Bitww AND NOT immed. $Y & u ( u(z)) $X $Y & u ANDNL $X,YZ Bitw. AND NOT low wyde $X $X & u ( u(yz)) BNZ $X,YZ Branch if nonzero s($x) 6= u ( u(@) + 4 s(yz)) ANDNML $X,YZ Bw. AND NOT med. l. wd. $X $X & ( u ( u(yz)) 6) PBNZ $X,YZ Prob. br. if nonzero s($x) 6= u ( u(@) + 4 s(yz)) ANDNMH $X,YZ Bw. AND NOT med. h. wd. $X $X & ( u ( u(yz)) ) BN $X,YZ Branch if negative s($x) < u ( u(@) + 4 s(yz)) ANDNH $X,YZ Bw. AND NOT high wyde $X $X & ( u ( u(yz)) 4) PBN $X,YZ Prob. br. if negative s($x) < u ( u(@) + 4 s(yz)) NAND OR $X,$Y,$Z Bitwise NOT AND $X ($Y & $Z) $X,$Y,Z Bitwise NOT AND ( $Y & u ( u(z))) immed. $X ( $Y & u $X,$Y,$Z Bitwise OR $X $Y $Z $X,$Y,Z Bitwise OR $Y u ( u(z)) immediate $X $Y u ORL $X,YZ Bitwise OR low wyde $X $X u ( u(yz)) ORML $X,YZ Bitw. OR med. low wyde $X $X ( u ( u(yz)) 6) ORMH $X,YZ Bitw. OR med. high wyde $X $X ( u ( u(yz)) ) ORH $X,YZ Bitwise OR high wyde $X $X ( u ( u(yz)) 4) ORN NOR XOR NXOR $X,$Y,$Z Bitwise OR NOT $X $Y $Z $X,$Y,Z Bitwise OR NOT $Y u ( u(z)) immediate $X $Y u $X,$Y,$Z Bitwise NOT OR $X ($Y $Z) $X,$Y,Z Bitwise NOT OR ($Y u ( u(z))) immediate $X ($Y u $X,$Y,$Z Bitwise XOR $X $Y $Z $X,$Y,Z Bitwise XOR $Y u ( u(z)) immediate $X $Y u $X,$Y,$Z Bitwise NOT XOR $X ($Y $Z) $X,$Y,Z Bitw. NOT XOR immediate ($Y u ( u(z))) $X ($Y u Funktionsaufruf Befehl Operanden Name/Aktion Definition $X,$Y,$Z Go to location GO $X,$Y,Z Go to location immediate JMP XYZ u ( u(@) + 4 s(xyz)) Befehl Operanden Name/Aktion Definition BZ $X,YZ Branch if zero s($x) u ( u(@) + 4 s(yz)) PBZ $X,YZ Probable br. if zero s($x) u ( u(@) + 4 s(yz)) BNN $X,YZ Branch if nonneg. s($x) u ( u(@) + 4 s(yz)) PBNN $X,YZ Prob. br. if nonneg. s($x) u ( u(@) + 4 s(yz)) BP $X,YZ Branch if positive s($x) > u ( u(@) + 4 s(yz)) PBP $X,YZ Prob. br. if positive s($x) > u ( u(@) + 4 s(yz)) BNP $X,YZ Branch if nonpositive s($x) apple u ( u(@) + 4 s(yz)) PBNP $X,YZ Prob. br. if nonpos. s($x) apple u ( u(@) + 4 s(yz)) BEV $X,YZ Branch if even u ( u(@)+4 s(yz)) PBEV $X,YZ Prob. branch if even u ( u(@)+4 s(yz)) BOD $X,YZ Branch if odd u ( u(@)+4 s(yz)) PBOD $X,YZ Prob. branch if odd u ( u(@)+4 s(yz)) Direktoperanden Befehl Operanden Name/Aktion Definition SETL $X,YZ Set to low wyde u (u(yz)) $X u SETML $X,YZ Set to med. low wyde $X u (u(yz 6)) SETMH $X,YZ Set to med. high wyde $X u (u(yz )) SETH $X,YZ Set to high wyde $X u (u((yz 4)) INCL $X,YZ Increase by low wyde $X u (u($x)+u(yz)) $X u ( u(@) + 4) ); INCML $X,YZ Inc. by med. low wyde $X u (u($x)+u(yz u ( u($y)+u($z)) $X u INCMH $X,YZ Inc. by med. high wyde $X u (u($x)+u(yz )) ( u(@) + 4) u ( u($y)+u(z)) INCH $X,YZ Increase by high wyde $X u (u($x)+u(yz 4))

22 Konzeptpapier Konzeptpapier Verwenden Sie dieses Blatt für Notizen. Falls Inhalte dieses Blatts bewertet werden sollen, müssen Sie das auf diesem Blatt und bei der jeweiligen Teilaufgabe kennzeichnen.