Universität Koblenz-Landau. Montag, 20. Juni Teilklausur zur Vorlesung Grundlagen der Rechnerarchitektur. Sommersemester 2011

Transkript

1 Universität Koblenz-Landau Montag, 20. Juni Teilklausur zur Vorlesung Grundlagen der Rechnerarchitektur Sommersemester 2011 Prof. Dr. Ch. Steigner Name Vorname Mat.-Nr. Studiengang Musterlösung Punkte : Bonus (+ 6) Kontrollieren Sie bitte Ihre Klausur auf Vollständigkeit (16 Seiten). Für die Bearbeitung sind keinerlei Unterlagen sowie keinerlei elektronische Hilfsmittel (z.b. Taschenrechner) erlaubt. Verwenden Sie nur dokumentenechte Schreibmittel (kein Bleistift).

2 Grundlagen der Rechnerarchitektur Sommersemester Aufgabe 1 (6 Punkte) Mit einem Rechner mit doppelter Genauigkeit (double precision floating point) wurden die folgenden Berechnungen durchgeführt: 1) ( ) = 0 ( ) + 1 = 1 2) = ( ) = ) = ( ) = Erläutern Sie kurz diese Ergebnisse: zu 1) Anwendung des Assoziativgesetzes: kann bei Gleitkommazahlen aufgrund der Ungenauigkeit durch die beschränkte Anzahl an Stellen zu falschen Werten führen. zu 2) Awendung des istributivgesetz: Aufgrund der Ungenauigkeit bei Gleitkommazahlen durch die beschränkte Anzahl an Stellen kommt es hier zu unterschiedlichen Ergebnissen. zu 3) Anwendung des Distributivgesetz: Im Gegensatz zu (2) genügt hier die verfügbare Anzahl an Stellen ( ) der Gleitkommazahl für eine ausreichende Genauigkeit. Das Ergebnis ist jeweils korrekt. Aufgabe 2 (3 Punkte) Was wird mit dem ''Machine-Epsilon (ɛ m )'' bezeichnet (1.0 + ɛ m 1.0)? Ist ein Maß für den Rundungsfehler bei der Rechnung mit Gleitkommazahlen. Gleitkommazahlen sind nicht beliebig genau darstellbar. ɛ m wird als Maschinengenauigkeit bezeichnet. Das Maschinenepsilon gibt den maximalen, relativen Abstand zwischen 2 Gleitkommazahlen an.

3 Grundlagen der Rechnerarchitektur Sommersemester Aufgabe 3 (3 Punkte) Was wird durch die folgende XOR-Befehlsfolge erreicht? Erläutern Sie jede Zeile! xor $s0, $s0, $s1 # $s0 wird XOR mit $s1 verknüpft. In $s0 wird # das Ergebnis der Verknüpfung gespeichert. # xor $s1, $s0, $s1 # $s0 wird nun erneut mit $s1 XOR-verknüpft. In # $s1 liegt nun der Wert, der zuvor in $s0 # gespeichert war. xor $s0, $s0, $s1 # $s0 wird mit $s1 XOR-verknüpft. In $s0 liegt nun # der Wert, der zuvor in $s1 gespeichert war. # Die Befehlsfolge tauscht den Inhalt der Register $s0 und $s1 auf Bit-ebene aus (SWAP $s0 $s1). Aufgabe 4 (8 Punkte) a) Welcher Wert wird durch die folgende IEEE 754 Floating-Point Zahl angegeben? S ign Exponent Mantissa-Fraction x x b) Welcher Wert wird durch die folgende IEEE 754 Floating-Point Zahl angegeben? S ign Exponent Mantissa-Fraction x x

4 Grundlagen der Rechnerarchitektur Sommersemester c) Addieren Sie die Werte aus a) und b) und geben Sie das Ergebnis in der Konvention für IEEE 754 Floating-Point Zahlen an. Gehen Sie schrittweise vor (Angleichen der Exponenten, Addieren der Mantissen, Normalisieren?, Ergebnis) 1) Umwandeln der Zahlen nach IEEE 754: s.o ) Angleichen der Exponenten: x x x x 2 2 3) Addition = ,25 : x = ,6875 : x 2 2 4) Hier muss nichts isiert werden Mantisse x 2 2 Mantisse ,9375 : x 2 2 5) Ergebnis: x 2 2 = x , S ign Exponent Mantissa-Fraction Aufgabe 5 (6 Punkte) a) Konvertieren sie den Dezimalwert in die Binary-Fraction Darstellung indem Sie das Schema aus der Vorlesung nutzen. Start x x x

5 Grundlagen der Rechnerarchitektur Sommersemester b) Konvertieren Sie die ermittelte Binary-Fraction Darstellung in eine IEEE 754 Floating-Point Zahl mit einfacher Genauigkeit (Single Precision). Geben Sie das Vorzeichen (S), den Exponenten (E) und die Mantisse (M) an x2 0 = x 2-2 = x S ign Exponent Mantissa-Fraction Aufgabe 6 (7 Punkte) Konvertieren Sie die Werte der Multiplikation 2.25 x 10 in eine IEEE 754 Floating-Point Zahl, bestehend aus 3-bit Exponent und 3-bit Mantisse. Für den Fall, dass die Genauigkeit auf Grund der 3-Bit Mantisse für das Ergebnis nicht erhalten werden kann, geben Sie bitte den Betrag der Abweichung an. Gehen Sie schrittweise vor und benennen Sie jeden Schritt. (Hinweis: Das Adjustment für den 3-bit Exponenten beträgt: = 3 10 ) 1) Umwandeln der Werte in 3-bit IEEE = x x x = x x x S ign 2) Addieren der Exponenten: Exponent Mantisse =

6 Grundlagen der Rechnerarchitektur Sommersemester Fortsetzung Aufgabe 6 3) Multiplikation der Mantissen ) Normalisieren hier muss nichts isiert werden: x 2 4 Exponent: = x2 7-3 = x2 4 5) Runden: bit Mantisse / 2 5 1/32 fällt weg 6) Vorzeichen: 0 da beide Operanden 0 7) Ergebnis: 3-bit Mantisse + 3-bit Exponent S ign Exponent Mantisse x2 7-3 = x2 4 = x Das Ergebnis weicht aufgrund der Rundung auf 3 Bit um den Wert 1/ ( x2 4 = 0, x x2 0 ) = 0,5 (x2 0 ) vom richtigen Wert ab. Der Korrekte Wert ohne Rundung wäre

7 Grundlagen der Rechnerarchitektur Sommersemester Aufgabe 7 (4 Punkte) Gegeben ist das folgende MIPS-Programm zum Schreiben in einen Ringpuffer. Vervollständigen Sie das MIPS-Programm an den leer belassenen Programm-Zeilen, indem Sie die Operationen im gegebenen Flowchart zur Grundlage nehmen. Line: 1:.text 2:.globl main 3: main: li $t0, 0 # elements 4: li $t1, 0 # start 5: li $t2, 0 # end 6: li $t3, 1 # one 7: li $t4, 8 # maxb elements 8: request: jal pread # read first integer 9: move $s0, $v0 # save it in $s0 10: beq $s0, $0, dec1 # create the queue v0=0? 1: beq $s0, $t3, dec2 # dequeue? 12: jal wronginput # check for wrong input value 13: j request # 14: dec2: jal dequeue # dequeue 15: j request 16: dec1: jal init # create the queue 17: j request 18: jal main 19: li $v0, 10 # exit program 20: syscall 21: init: slt $s1, $t0, $t4 # is the queue full? 22: beq $s1, $0, full # $t4 = maxqueue (elem<maxb) 23: addi $sp, $sp,-4 # save the return address 24: sw $ra, 4($sp) # 25: jal input # enter value in a subroutine 26: lw $ra, 4($sp) # restore the return address 27: addi $sp, $sp, 4 # 28: move $s0, $v0 # input value in $s0 29: addi $t0, $t0, 1 # element = element : add $t6, $t2, $t2 # convert the end pointer 31: add $t6, $t6, $t6 # into word format

8 Grundlagen der Rechnerarchitektur Sommersemester : sw $s0, base($t6) # Queue(base+end)=s0 33: addi $t2, $t2, 1 # end = end + 1 div $v0, $t2, $t4 # $v0 $a0 : $a1 mfhi $t2 # $t1 $hi xx: j $ra # return to caller Aufgabe 8 (5 Punkte) Markieren Sie die richtigen Aussagen zu Aufrufkonventionen für Callee-/Caller-Saved Register durch entsprechendes ankreuzen! Sind alle Register callee-save, dann sichert das aufgerufene Unterprogramm den Inhalt aller Register bevor es diese überschreibt. Sind alle Register caller-save, dann sichert das aufgerufene Unterprogramm den Inhalt aller Register bevor es diese überschreibt. Alle Register werden automatisch vom Coprozessor gesichert, bevor ein Unterprogramm aufgerufen wird. Es treten immer Seiteneffekte (Side-effects) auf, wenn die Aufrufkonventionen für Caller-/Callee-Saved Register nicht eingehalten werden. Bei den Aufrufkonventionen für Callee-/Caller-Saved Register wird eine typische Eigenschaft des von-neumann Rechners behandelt. Die Aufrufkonventionen für Caller-/Callee-Saved Register legen fest: wie Parameter an ein Unterprogramm übergeben werden. wie Rückgabewerte des Unterprogramms behandelt werden. wie Adressen des Stack-Speichers nach Aufruf eines Unterprogramm behandelt werden. welche Register nach Aufruf eines Unterprogramms ihren Wert behalten. welche Register nach Aufruf eines Unterprogramms für die Sicherung der Daten aus dem Datensegment (.data) verwendet werden. welche Register nach Aufruf eines Unterprogramms für die Sicherung der Daten aus dem Stack-Speicher verwendet werden. nach wie vielen Durchläufen ein Unterprogramm den spezielleren Aufrufkonventionen der rekursiven Unterprogramme unterliegt.

9 Grundlagen der Rechnerarchitektur Sommersemester Aufgabe 9 (6 Punkte) Ergänzen Sie die unten angegebene Interrupt-Routine um einige Befehle zur Ausgabe des Exception Codes der Teil des Cause Registers ist. Da der Exception Code nur 5 bit umfasst, soll in der Ausgabe nur ein Wert innerhalb des Bereichs von 0 bis 31 auftreten. 3 1 $ 13 Cause Register Exception Typ and pending interrupts Branch belay Pengdin interrupt Exception code 1: interrupt: 2: li $v0 4 # print message 1 3: la $a0 mes1 4: syscall 5: li $v0 1 # print EPC register of the 6: mfc0 $a0 $14 # instruction that was executing 7: syscall # when the exception occurred 8: li $v0 4 9: la $a0 mes2 # print linefeed 10: syscall 11: li $v0 4 # print message 4 12: la $a0 mes4 13: syscall # print 14: li $v0 1 # print Exception Code zu ergänzen mfc0 $a0, $13 # Get the Cause Register andi $a0, $a0, 0x7c # Mask out the ExcCode-bits srl $a0, $a0, 2 syscall xx: li $v0 4 xx: la $a0 mes2 xx: syscall xx: addi $t4 $t4 1 xx: la $a0 mes3 xx: syscall xx: li $v0 1 xx: move $a0 $t4 # shift right zu ergänzen # print linefeed # increase interrupt c # print t4 register

10 Grundlagen der Rechnerarchitektur Sommersemester xx: syscall xx: li $v0 4 xx: la $a0 mes2 xx: syscall xx: li $v0 4 xx: la $a0 INTR xx: syscall # print linefeed # exception occurred # syscall 4 (print_str) # print INTR message on console xx: j restore # finished interrupt-code xx: xx:.kdata xx: mes1:.asciiz " The program was interrupted at address:\n" xx: mes2:.asciiz " \n" xx: mes3:.asciiz " The interrupt number is:" xx: mes4:.asciiz " The Exception Code is:" Aufgabe 10 (10 Punkte) Die Eulersche Zahl e ( e= 2, ) kann als Reihe der Form 1 e = k =0 k! = 1 0! 1 1! 1 2! 1 3! 1 4!... e = = dargestellt werden, wobei gilt 0! = 1. Das folgende MIPS-Programm soll die Eulersche Zahl über die obige Reihe bis zur angegebenen Iteration berechnen. Die Eingabe der maximalen Iteration und die Ausgabe der Zahl e sind bereits implementiert. Vervollständigen Sie das MIPS-Programm mit Floating-Point Zahlen der einfachen Genauigkeit (Single Precision). 1:.text 2:.globl main # Calculation of Euler e 3: main: 4: la $a0,prompt3 # print string 5: li $v0,4 # service 4 6: syscall 7: li.s $f0, 1.0 # $f0 = constant 1.0 8: li.s $f2, 1.0 # $f2 = constant 1.0 9: li.s $f4, 1.0 # $f4 = constant : li.s $f10,2.0 # $f10 = constant : li.s $f6, 0.0 # $f6 = constant : li $t1, 0 13: li $t2, 1

11 Grundlagen der Rechnerarchitektur Sommersemester : jal preada # read iteration maximum 15: add $t1,$t1,$v0 # save iteration max in $t1 zu ergänzen ret: add.s $f2, $f2, $f4 # f2 = f2 + 1 mul.s $f0, $f0, $f2 div.s $f6, $f4, $f0 add.s $f10, $f10, $f6 # f0 = f0 * f2 # f6 = 1 : f0 # f10= f10 + f6 addi $t2, $t2, 1 bne $t2, $t1 ret mov.s $f12, $f10 # check against iteration max # print zu ergänzen xx: jal pwrite # print xx: jal main xx: preada: xx: la $a0,prompta # print string xx: li $v0,4 # service 4 xx: syscall xx: li $v0,5 # read int into $v0 xx: syscall # service 5 xx: jr $ra # return xx: pwrite: li $v0,4 #print string service xx: la $a0,prompt2 #address of prompt xx: syscall xx: li $v0,3 # print double service xx: syscall xx: la $a0,prompt3 # print string xx: li $v0,4 # service 4 xx: syscall xx: jr $ra # return xx:.data xx: prompta:.asciiz " Enter Number of Iterations: " xx: prompt3:.asciiz "\n" xx: prompt2:.asciiz " The Euler-Approximation is: "

12 Grundlagen der Rechnerarchitektur Sommersemester Aufgabe 11 (8 Punkte) Das Produkt zweier natürlicher Zahlen a 1 a 2 lässt sich rekursiv wie folgt berechnen: a 1 0 = 0 a 1 a 2 = a 1 (a 2 1) + a 1 Programmieren Sie ein MIPS-Unterprogramm, dass die Multiplikation a 1 a 2 auf diese Weise rekursiv berechnet. Die Parameter a 1 und a 2 sind in den Registern $a1 und $a2 abgelegt und das Ergebnis wird im Register $v0 geliefert. Einige Programmzeilen und Marken sind bereits vorgegeben. Ergänzen Sie die weiteren Befehle. # # calculate: rekmul(a 1,0)=0; rekmul(a 1,a 2 ) = rekmul(a 1,a 2-1) + a 1 # : rekmul: : addi $sp, -4 : sw $ra, 4($sp) : beq $a1, $0, null # if a 1 =0 then goto null addi $a1, $a1, -1 # calculate a 1-1 jal rekmul # v0=rekmul(a 2,a 1-1) : add $v0, $v0, $a2 # v0=rekmul(a 2,a 1-1) + a 2 j return # jump to return mark null: move $v0, $0 # rekmul(a 2,0)=0 return: lw $ra, 4($sp) addi $sp, 4 # load $ra-address from stack # $sp top of stack : jr $ra # return

13 Grundlagen der Rechnerarchitektur Sommersemester Aufgabe 12 (BONUS) (6 Punkte) Wandeln Sie die Werte der Addition (- 5) in IEEE-754 Floating-Point Zahlen um und berechnen Sie das Ergebnis. Gehen Sie dabei schrittweise vor und benennen Sie jeden Schritt. 1) Umwandeln der Zahlen nach IEEE 754: s.o S ign Exponent Mantisse 2) Angleichen der Exponenten: x x x x x x 2 2 3) Umwandeln in 2er Komplement (-) 5.0: (1) x2 2 (0 ) (0) ) Addition (-) x2 2 (-) 1,25 : x2 2 0,6875 : (-) 0,5625 : er Komplement umwandeln: = ) Normalisieren x x 2 1 Mantisse Mantisse x x ) Ergebnis: S ign Exponent Mantissa-Fraction

14 Grundlagen der Rechnerarchitektur Sommersemester Instruction Operands Type Description add d,s,t d <-- s+t ; with overflow trap addu d,s,t d <-- s+t ; without overflow trap MIPS Instruction Set addi addiu d,s,const d,s,const d <-- s+const ; with overflow trap const is 16-bit two's comp d <-- s+const ; without overflow trap const is 16-bit two's comp and d,s,t d <-- bitwise AND of s with t andi d,s,const d <-- bitwise AND of s with const b beq beqz bge bgez bgt ble blez blt bltz bne bnez div div divu divu j target s,t,addr s,addr s,t,addr s,addr s,t,addr s,t,addr s,addr s,t,addr s,addr s,t,addr s,addr s,t d,s,t s,t d,s,t target pseudo after a delay of one machine cycle, PC <-- address of target branch if s == t pseudo branch if the two's comp. integer in register s is == 0 pseudo branch if s >= t branch if the two's comp. integer in register s is >= 0 pseudo pseudo branch if s > t branch if s <= t branch if the two's comp. integer in register s is <= 0 pseudo branch if s < t Branch if the two's comp. integer in register s is < 0 branch if s!= t pseudo branch if s!= 0 pseudo pseudo lo <-- s div t ; hi <-- s mod t - two's comp. Operands, lo stores the result of the integer division (i.e., the quotient), while hi stores the remainder. The operation is undefined if the divisor is 0 d <-- s div t two's comp. operands lo <-- s div t ; hi <-- s mod t unsigned operands d <-- s div t unsigned operands after a delay of one machine cycle, PC <-- address of target jal a $ra <-- IP+4, IP <-- a jr d Jump to instruction whose address is in register (d). la d,addr pseudo d <-- addr Load address into destination register (d). lb lbu lh lhu li lui lw d,off(b) d,off(b) d,off(b) d,off(b) d, imm d,const d,off(b) d, b(s) pseudo d <-- Sign-extended byte from memory address b+off off is 16-bit two's complement d <-- Zero-extended byte from memory address b+off off is 16-bit two's complement t <-- Sign-extended halfword from memory address b+off off is 16-bit two's complement t <-- Zero-extended halfword from memory address b+off off is 16-bit two's complement d <-- imm Load immediate value into register (d). upper two bytes of $t <-- two byte const lower two bytes of $t <-- 0x0000 d <-- Word from memory address b+off d <-- Word from merory address b+s

15 Grundlagen der Rechnerarchitektur Sommersemester mfc0 $ri, $X Spezialfall # Get coprocessor0's register $X and store it into $ri mfhi d d <-- hi ; Move From Hi mflo d d <-- lo ; Move From Lo move d,s pseudo d <-- s mtc0 $ri, $X # Store $ri to coprocessor0's register $X mul d,s,t pseudo d <-- s*t (without overflow) mulo d,s,t pseudo d <-- s*t (with overflow) mult s,t hi / lo < -- s * t ; two's comp operands multu s,t hi / lo < -- s * t ; unsigned operands MIPS Instruction Set nop no operation nor d,s,t d <-- bitwise NOR of s with t nor d,s,$0 Spezialfall d <-- bitwise NOT of s or d,s,t d <-- bitwise OR of s with t or d,s,$0 Spezialfall d <-- s ori d,s,const d <-- s OR zero-extended const ori d,$0,const Spezialfall d <-- zero-extended const sb sh d,off(b) d,off(b) byte at off+b <-- low-order byte from register $d. off is 16-bit two's complement two bytes at off+b <-- two low-order bytes from register $d. off is 16-bit two's complement sll d,s,shft d <-- logical left shift of s by shft positions where 0 <= shft < 32 slt slti sltiu sltu d,s,t d,s,imm d,s,imm d,s,t if s < t d <-- 1 else d <-- 0 two's comp. operands if s < imm d <-- 1 else d <-- 0 two's comp. operands if s < imm d <-- 1 else d <-- 0 unsigned operands if s < t d <-- 1 else d <-- 0 unsigned operands sra d,s,shft d <-- arithmetic right shift of s by shft positions where 0 <= shft < 32 srl d,s,shft d <-- logical right shift of s by shft positions where 0 <= shft < 32 sub d,s,t d <-- s - t; with overflow trap subu d,s,t d <-- s - t; no overflow trap sw syscall t,off(b) Word at memory address (b+off) <-- t b is a register. off is 16-bit twos complement. Call Operating System Functions with Parameters: Service Call Code Arguments Result print integer $v0: 1 $a0:integer print float $v0: 2 $f12:float print double $v0: 3 $f12:double print string $v0: 4 $a0:string addr read integer $v0: 5 $v0:integer read float $v0: 6 $f0:float read double $v0: 7 $f0:double read string $v0: 8 $a0:buffer addr, $a1:length sbrk (mem alloc) $v0: 9 $a0:n Bytes $v0:addr exit $v0:10 xor d,s,t d <-- bitwise exclusive or of s with t xori d,s,const d <-- bitwise exclusive or of s with const

16 MIPS Floating Point Instructions Grundlagen der Rechnerarchitektur Sommersemester Instruction Operands Type Precision Description abs.d fd, fs Normal double fd <-- absolute value of fs abs.s fd, fs Normal single fd <-- absolute value of fs add.d fd, fs, ft Normal double fd <-- fs + ft add.s fd, fs, ft Normal single fd <-- fs + ft bc1t target Normal IF (fp-condition-flag == TRUE) THEN GOTO target bc1f target Normal IF (fp-condition-flag == FALSE) THEN GOTO target c.eq.d fs, ft Normal double IF (fs == ft) THEN fp-condition-flag = true ELSE fp-condition-flag = false (use bc1t or bc1f to read the fp-condition-flag) c.eq.s fs, ft Normal single IF (fs == ft) THEN fp-condition-flag = true ELSE fp-condition-flag = false (use bc1t or bc1f to read the fp-condition-flag) c.le.d fs, ft Normal double IF (fs <= ft) THEN fp-condition-flag = true ELSE fp-condition-flag = false c.le.s fs, ft Normal single IF (fs <= ft) THEN fp-condition-flag = true ELSE fp-condition-flag = false c.lt.d fs, ft Normal double IF (fs < ft) THEN fp-condition-flag = true ELSE fp-condition-flag = false c.lt.s fs, ft Normal single IF (fs < ft) THEN fp-condition-flag = true ELSE fp-condition-flag = false cvt.d.s fd, fs Normal double fd <-- Convert single in fs to double cvt.d.w fd, fs Normal double fd <-- Convert integer in fs to double cvt.s.d fd, fs Normal single fd <-- Convert double in fs to single cvt.s.w fd, fs Normal single fd <-- Convert integer in fs to single cvt.w.d fd, fs Normal integer fd <-- Convert double in fs to integer cvt.w.s fd, fs Normal integer fd <-- Convert single in fs to integer div.d fd, fs, ft Normal double fd <-- fs / ft div.s fd, fs, ft Normal single fd <-- fs / ft l.d fd, addr pseudo double load double at addr into register fd l.s fd, addr pseudo single load single at addr into register fd li.d fd, float pseudo double load immediate double value into register fd li.s fd, float pseudo single load immediate single value into register fd mov.d fd, fs Normal double fd <-- fs mov.s fd, fs Normal single fd <-- fs mul.d fd, fs, ft Normal double fd <-- fs * ft mul.s fd, fs, ft Normal single fd <-- fs * ft mfc1 d, fs Normal Move coprocessor1 register fs to CPU register d mtc1 s, fd Normal Move CPU register s to coprocessor1 register fd neg.d fd, fs Normal double fd <-- fs * -1 neg.s fd, fs Normal single fd <-- fs * -1 s.d fd, addr pseudo double store double in register fd at addr s.s fd, addr pseudo single store single in register fd at addr sub.d fd, fs, ft Normal double fd <-- fs - ft sub.s fd, fs, ft Normal single fd <-- fs - ft Floating Point System Calls Service Call Code Arguments Results print float $v0 = 2 $f12 = float (single) print double $v0 = 3 $f12 = double read float $v0 = 6 $f0: float (single) read double $v0 = 7 $f0: double Exception Handling Das Status-Register : Das Cause-Register :