Grundlagen der Rechnerarchitektur

Transkript

1 Grundlagen der Rechnerarchitektur MIPS Assembler

2 Übersicht Arithmetik, Register und Speicherzugriff Darstellung von Instruktionen Logische Operationen Wit Weitere Arithmetik tik Branches und Jumps Prozeduren 32 Bit Konstantenund Adressierung Synchronisation Exceptions Pseudoinstruktionen, Direktiven und Makros Grundlagen der Rechnerarchitektur Assembler 2

3 Motivation Grundlagen der Rechnerarchitektur Assembler 3

4 Warum ein Assembler Kurs? Wir wollen etwas über Rechnerarchitektur lernen. Assembler ist ein Teil davon. Nach dem Erlernen von Assembler eines Systems, lernt man Assembler anderer Rechner kinderleicht i Während wir uns mit Assembler beschäftigen lernen wir auch generelle Konzepte kennen, wie die Hardware in Computern und eingebetteten Systemen organisiert ist Grundlagen der Rechnerarchitektur Assembler 4

5 Vor und Nachteile von Assembler Wann sollte man Assembler programmieren? Code Größe oder Geschwindigkeit sollen bis auf das äußerste ausgereizt werden Verwendung spezieller Maschineninstruktionen, die ein Compiler nicht nutzt (in der Regel bei CISC) Es gibt für die Computer Hardware keine höhere Sprache Meist wird ein hybrider Ansatz gewählt Man programmiert das meiste in einer High Level Sprache Nur kleine Teile des gesamten Codes werden direkt in Assembler optimiert Nachteil von Assembler Programme laufen nur für den Hardwaretyp für den diese programmiert sind Assembler Code ist im Vergleich zu High Level Sprachen deutlich länger Programmieren dauert deutlich länger Programmierenistfehleranfälliger ist (insbesonderewegen fehlenderstruktur) Grundlagen der Rechnerarchitektur Assembler 5

6 Assembler am Beispiel der MIPS Architektur Frühere Einsatzgebiete MIPS Silicon Graphics Unix Workstations (z. B. SGI Indigo2) Silicon Graphics Unix Server (z. B. SGI Origin2000) DEC Workstations (z.b. DECstation Familie und DECsystem) Siemens bzw. SNI Server der RM Serie Control Data Corporation Computer des Typs CDC 4680 Heutiger Einsatz von MIPS in eingebetteten Systemen Cobalt Server bis RaQ/Qube2 BMW Navigationssysteme die Fritz!Box Satellitenreceiver Dreambox Konica Minolta DSLRs Sony und Nintendo Spielkonsolen Quelle der Liste: de.wikipedia.org/wiki/mips Architektur Grundlagen der Rechnerarchitektur Assembler 6

7 Warum gerade MIPS (und nicht Intel x86)? MIPS Instruktionssatz ki ist klar und einfach h( (RISC) Sehr gut in Lehrbüchern beschrieben Sehr ähnlich zu vielen modernen Prozessoren (z.b. ARM; schauen wir uns eventuell auch noch kurz an) MIPS ist iteine kommerziell relevante Instruktionssatzarchitektur. t (z.b wurden fast 100 Millionen MIPS Prozessoren hergestellt) 7 Grundlagen der Rechnerarchitektur Assembler

8 Begleitend: SPIM und MARS Simulator Programmieren lernt man nicht durch zuschauen! Alle Konzepte sollte man hier selber ausprobieren! Grundlagen der Rechnerarchitektur Assembler 8

9 Arithmetik, Register und Speicherzugriff Grundlagen der Rechnerarchitektur Assembler 9

10 Arithmetik und Zuweisungen Einfache Arithmetik tik mit Zuweisung C Programm: a = b + c; d = a e; MIPS Instruktionen: Komplexere Arithmetik tik mit Zuweisung C Programm: f = (g + h) (i + j); MIPS Instruktionen (verwende temporäre Variablen t0 und t1): Grundlagen der Rechnerarchitektur Assembler 10

11 Die Operanden sind Register Voriges Beispiel: i Komplexere Arithmetik tik mit Zuweisung C Programm: f = (g + h) (i + j); Sei hierbei: g in Register $s1 gespeichert h in Register $s2 gespeichert i in Register $s3 gespeichert j in Register $s4 gespeichert f in Register $s0 gespeichert MIPS Instruktionen (verwende temporäre Register $t0 und $t1): add $t0, $s1, $s2 # t0=g+h add $t1, $s3, $s4 # t1=i+j sub $s0, $t0, $t1 # f=t0-t1 MIPS Registergröße = 32 Bit Assembler Syntax: Das Zeichen # leitet für den Rest der Zeile einen Kommentar ein. Der Text wird vom Assembler einfach ignoriert. Grundlagen der Rechnerarchitektur Assembler 11

12 Speicher Operanden C Programm: g = h + A[8]; MIPS Instruktionen (verwende temporäres Register $t0): Sei hierbei: g in Register $s1 gespeichert h in Register $s2 gespeichert Basisadresse von A in Register $s3 Bildquelle: David A. Patterson und John L. Hennessy, Computer Organization and Design, Fourth Edition, 2012 Grundlagen der Rechnerarchitektur Assembler 12

13 Alignment Restriction Zugriff auf A[8], wenn Basisadresse von A in Register $s3 gespeichert? Bildquelle: David A. Patterson und John L. Hennessy, Computer Organization and Design, Fourth Edition, 2012 Grundlagen der Rechnerarchitektur Assembler 13

14 Laden und Speichern C Programm: A[12] = h + A[8]; MIPS Instruktionen (verwende temporäre Register $t0): Sei hierbei: Basisadresse von A in in Register $s3 h in Register $s2 gespeichert Grundlagen der Rechnerarchitektur Assembler 14

15 Laden und Speichern von Bytes C Programm: A[12] = h + A[8]; MIPS Instruktionen (verwende temporäre Register $t0): Sei hierbei: Basisadresse von A in in Register $s3 h in Register $s2 gespeichert Sei A[8] = Was passiert im obigen Beispiel bei lb mit $t0 genau? $t0 MSB LSB Sei A[8] = Was passiert im obigen Beispiel bei lb mit $t0 genau? $t0 MSB LSB Grundlagen der Rechnerarchitektur Assembler 15

16 Weitere Befehle zum Laden und Speichern Laden von Byte ohne Sign Extension: lbu { Beispiel: lbu $t0, 27($s3) } Was passiert im obigen Beispiel mit $t0, wenn 27($s3) = ? $t0 MSB LSB Laden von Halfword mit Sign Extension: lh { Beispiel: lh $t0, 22($s3) } Laden von Halfword ohne Sign Extension: lhu { Beispiel: lhu $t0, 22($s3) } Speichern von Halfword: sh { Beispiel: sh $t0, 22($s3) } Grundlagen der Rechnerarchitektur Assembler 16

17 Addieren und Laden von Konstanten C Programm: x = x + 4; MIPS Instruktion: Sei hierbei: x in Register $s3 gespeichert MIPS erlaubt negative Konstanten und braucht damit kein subi. MIPS hat ein spezielles Register $zero, welches 0 hart verdrahtet speichert. C Programm: x = 42; MIPS Instruktion: Sei hierbei: x in Register $s3 gespeichert Grundlagen der Rechnerarchitektur Assembler 17

18 Zwischenbilanz der MIPS Architektur Memory CPU Name Nummer Verwendung Registers $zero 0 Konstante 0 $0 $at 1.. $v0 $v $a0 $a3 4 7 $31 $t0 $t7$t Temporäre Register Arithmetic $s0 $s saved temporäre Reg. Unit $t8 $t9 $t Temporäre Register $k0 $k $gp 28 $sp 29 $fp 30 $ra 31 Grundlagen der Rechnerarchitektur Assembler 18

19 Arith hmetik Lade en Speichern Zusammenfassung der behandelten Instruktionen Instruktion add rd, rs, rt addi rt, rs, imm sub rd, rs, rt lb rt, address lbu rt, address lh rt, address lhu rt, address lw rt, address Bedeutung Register rd = Register rs + Register rt Register rt = Register rs + Konstante imm Register rd = Register rs Register rt Lade Byte an der Adresse address in Register rt. Das Byte ist sign extended. Lade Byte an der Adresse address in Register rt. Lade Half Word an der Adresse address in Register rt. Das Half Word ist sign extended. LadeHalf Word anderadresse address in Register rt. Lade Word an der Adresse address in Register rt. sb rt, address Speichere unterstes Byte des Registers rt an Adresse address sh rt, address sw rt, address Speichere unteres Half Word des Registers rt an Adresse address Speichere Inhalt des Registers rt an Adresse address. Grundlagen der Rechnerarchitektur Assembler 19

20 Quiz addi $s0, $zero, 4 # lw $s1, 0($s0) # lw $s2, 4($s0) # add $s1, $s1, $s1 # add $s1, $s1, $s2 # addi $s1, $s1, 1 # sw $s1, 0($s0) # Inhalt (Word) Inhalt (Word) A dresse Speicher zu Beginn dresse Speicher nach Instruktionsdurchlauf A Grundlagen der Rechnerarchitektur Assembler 20

21 Darstellung von Instruktionen Grundlagen der Rechnerarchitektur Assembler 21

22 Übersetzung aus Assembler in Maschinensprache Assembler Instruktion add $t0, $s1, $s Bit Opcode Maschinen Instruktion 5 Bit Source1 5 Bit Source2 5 Bit Dest 5 Bit Shamt 6 Bit Funct Name Nr $s0 16 $s1 17 $s2 18 $s3 19 $s4 20 $s5 21 $s6 22 $s7 23 Name Nr $t0 8 $t1 9 $t2 10 $t3 11 $t4 12 $t5 13 $t6 14 $t7 15 Grundlagen der Rechnerarchitektur Assembler 22

23 Notwendigkeit für andere Instruktionsformate add $t0, $s1, $s2 op rs rt rd shamt funct R Typ 6 Bit 5 Bit 5 Bit 5 Bit 5 Bit 6 Bit? lw $t0, 32($s3) I Typ Opcode 6 Bit Source 5 Bit Dest 5 Bit Konstante oder Adresse 16 Bit Grundlagen der Rechnerarchitektur Assembler 23

24 Zwischenbilanz Instruktion Format op rs rt rd shamt funct add R 0 reg reg reg 0 32 sub R 0 reg reg reg 0 34 addi (immediate) I 8 reg reg constant lw (load word) I 35 reg reg offset sw (store word) I 43 reg reg offset 6 Bit 5 Bit 5 Bit 5 Bit 5 Bit 6 Bit 16 Bit Grundlagen der Rechnerarchitektur Assembler 24

25 Beispiel: A[300] = h + A[300] $t1 sei Basisadresse von A und h in $s2 gespeichert. Assembler Code? Maschinen Code (der Einfachheit halber mit Dezimalzahlen)? op rs rt rd adr/shamt funct Instruktion Format op rs rt rd shamt funct add R 0 reg reg reg 0 32 lw (load word) I 35 reg reg offset sw (store word) I 43 reg reg offset Name Nr $s0 16 $s1 17 $s2 18 $s3 19 $s4 20 $s5 21 $s6 22 $s7 23 Name Nr $t0 8 $t1 9 $t2 10 $t3 11 $t4 12 $t5 13 $t6 14 $t7 15 Grundlagen der Rechnerarchitektur Assembler 25

26 Logische Operationen Grundlagen der Rechnerarchitektur Assembler 26

27 Logischer Links und Rechts Shift Erinnerung: Logischer Shift. Beispiel: Links Shift um 4 Stellen Rechts Shift um 4 Stellen MIPS Shift Instruktionen sll und srl, sllv, srlv: sll $t2,$s0,4 # $t2 = $s0 << 4 Bits srl $t2,$s0,7 # $t2 = $s0 >> 7 Bits sllv $t2,$s0,$s1 # $t2 = $s0 << $s1 Bits srlv $t2,$s0,$s1 # $t2 = $s0 >> $s1 Bits Beispiel: Maschineninstruktion für obige sll Assembler Instruktion: Bit 5 Bit 5 Bit 5 Bit 5 Bit 5 Bit Opcode Source1 Source2 Dest Shamt Funct R Typ Grundlagen der Rechnerarchitektur Assembler 27

28 Arithmetischer Rechts Shift Erinnerung: Arithmetischer Rechts Shift. Beispiel mit 8 Bit: Rechts Shift um 4 Stellen Rechts Shift um 3 Stellen Arithmetischer Rechts Shift in MIPS: sra $t2,$s0,4 # $t2 = $s0 arithmetisch # um 4 Bits geshiftet srav $t2,$s0,$s1 # $t2 = $s0 arithmetisch # um $s1 Bits geshiftet Grundlagen der Rechnerarchitektur Assembler 28

29 AND, OR, NOR und XOR Ei Erinnerung: AND. Ei Erinnerung: OR. Ei Erinnerung NOR. Ei Erinnerung XOR. MIPS Instruktionen (R Typ), Beispiel: and $t0,$t1,$t2 $t1 $t2 # $t0 = $t1 AND $t2 or $t0,$t1,$t2 # $t0 = $t1 OR $t2 nor $t0,$t1,$t2 # $t0 = $t1 NOR $t2 xor $t0,$t1,$t2 # $t0 = $t1 XOR $t2 MIPS Instruktionen Instruktionen (I Typ), Beispiel: andi $t0,$t1,0111 # $t0 = $t1 AND 0111 ori $t0,$t1,1100, # $t0 = $t1 OR 1100 xori $t0,$t1,1100 # $t0 = $t1 XOR 1100 Grundlagen der Rechnerarchitektur Assembler 29

30 Es gibt gar kein NOT?! Erinnerung NOT (auf Folie zu Zweierkomplement kurz eingeführt): Beobachtung: Wie kann man also NOT($t0) in MIPS realisieren? Grundlagen der Rechnerarchitektur Assembler 30

31 Zusammenfassung der behandelten Instruktionen Sh hift Logische Verknüpfun ng Instruktion sll rd, rs, shamt Bedeutung Register rd = Register rs logisch links um den Wert shamt geshiftet. sllv rd, rt, rs Register rd = Register rs logisch links um den in Register rs gespeicherten Wert geshiftet. srl rd, rs, shamt Register rd = Register rs logisch rechts um den Wert shamt geshiftet. srlv rd, rt, rs Register rd = Register rs logisch rechts um den in Register rs gespeicherten Wert geshiftet. sra rd, rs, shamt srav rd, rt, rs and rd, rs, rt or rd, rs, rt nor rd, rs, rt Register rd = Register rs arithmetisch rechts um den Wert shamt geshiftet. Register rd = Register rs arithmetisch rechts um den in Register rs gespeicherten Wert geshiftet. Register rd = Register rs AND Register rt. Register rd = Register rs AND Register rt. Register rd = Register rs AND Register rt. xor rd, rs, rt Register rd = Register rsand Register rt. andi rt, rs, imm ori rt, rs, imm xori rt, rs, imm Register rt = Register rs AND Konstante imm Register rt = Register rs AND Konstante imm Register rt = Register rs AND Konstante imm Grundlagen der Rechnerarchitektur Assembler 31

32 Schwieriges Quiz MIPS Assemblercode um folgende Funktion zu berechnen: $1 $s1 = die ersten 8 Bits von 4 * NOT($s1 AND $2) $s2) Tipp: wir brauchen and, nor und sll Grundlagen der Rechnerarchitektur Assembler 32

33 Weitere Arithmetik Grundlagen der Rechnerarchitektur Assembler 33

34 Die speziellen Register lo und hi Erinnerung: ganzzahliges Produkt von zwei n Bit Zahlen benötigt bis zu 2n Bits. Eine MIPS Instruktion zur ganzzahligen Multiplikation von zwei Registern der Länge 32 Bits benötigt damit ein Register der Länge 64 Bit, um das Ergebnis abzuspeichern. MIPS hat für die ganzzahlige Multiplikation zwei spezielle Register, lo und hi, in denen das Ergebnis abgespeichert wird: lo : Low Order Word des Produkts hi : Hi Order Word des Produkts. Zugriff auf lo und hi erfolgt mittels mflo und mfhi. Beispiel: mflo $s1 # lade Inhalt von lo nach $s1 mfhi $s2 # lade Inhalt von hi nach $s2 Grundlagen der Rechnerarchitektur Assembler 34

35 Ganzzahlige Multiplikation und Division Ganzzahlige Multiplikation. Beispiel: mult $s1, $s2 # (hi,lo) = $s1 * $s2 Ganzzahlige Division. Beispiel: div $s1, $s2 # berechnet $s2 / $s1 # lo speichert den Quotienten # hi speichert den Rest Register hi und lo können auch beschrieben werden. Beispiel: mtlo $s1 # Lade Inhalt von $s1 nach lo mthi $s2 # Lade Inhalt von $s2 nach hi Das ist sinnvoll für madd und msub. Beispiele: madd $s1,$s2 # (hi,lo)=(hi,lo)+$s1*$s2 msub $s1,$s2 # (hi,lo)=(hi,lo)-$s1*$s2 Grundlagen der Rechnerarchitektur Assembler 35

36 Ganzzahlige Multiplikation ohne hi und lo Es gibt eine weitere Instruktion, zur Multiplikaiton, die kein hi und lo verwendet: mul $s1, $s2, $s3 # $s1 = die low-order order 32 # Bits des Produkts von # $s2 und $s3. Grundlagen der Rechnerarchitektur Assembler 36

37 Zwischenbilanz der MIPS Architektur Memory CPU Registers $0... $31 Neu Arithmetic Unit Multiply Divide Lo Hi Grundlagen der Rechnerarchitektur Assembler 37

38 Die speziellen Register $f01 bis $f31 MIPS unterstützt mit einem separaten FPU Coprozessor Gleitkommaarithmetik auf Zahlen im IEEE 754 Single Precision (32 Bit) und Double Precision Format i (64 Bit). DieMIPS Floating Point Befehle Point nutzen die speziellen 32 Bit Floating Point Register (die Register des FPU Coprozessors): $f0, $f1, $f3,..., $f31 Single Precision Zahlen können in jedem der Register gespeichert werden (also (l $f0, $f1,..., $f31). Double Precision Zahlen können nur inpaaren von aufeinander folgenden Registern ($f0,$f1), ($f2,$3),..., ($f30,$f31) gespeichert werden. Zugriff erfolgt immer über die geradzahligen Register (also $f0, $f2,..., $f30). Grundlagen der Rechnerarchitektur Assembler 38

39 Floating Point Befehle Laden/speichern von Daten in die Register $f0,...,$f31 am Beispiel: mtc1 $s1,$f3 # $f3 = $s1 mfc1 $s1,$f3 $f3 # $s1 = $f3 lwc1 $f3,8($s1) # $f3 = Memory[8+$s1] ldc1 $f2,8($s1) # ($f2,$f3) = Memory[8+$s1] swc1 $f3,8($s1) # Memory[8+$s1] = $f3 sdc1 $f2,8($s1) # Memory[8+$s1] = ($f2,$f3) Verschieben von Registerinhalten von $f0,...,$f31 am Beispiel: mov.s $f6,$f3 $f3 # $f6 = $f3 mov.d $s4,$f6 # ($f4,$f5) = ($f6,$f7) Grundlagen der Rechnerarchitektur Assembler 39

40 Floating Point Befehle Die MIPS Single Precision Operationen am Beispiel: add.s $f1,$f2,$f3 # $f1 = $f2 + $f3 sub.s $f1,$f2,$f3 $f2 $f3 # $f1 = $f2 - $f3 mul.s $f1,$f2,$f3 # $f1 = $f2 * $f3 div.s $f1,$f2,$f3 # $f1 = $f2 / $f3 Die MIPS Double Precision Operationen am Beispiel: add.d $f2,$f4,$f6 # ($f2,$f3) = ($f4,$f5) + ($f6,$f7) sub.d $f2,$f4,$f6 $f4 $f6 # ($f2,$f3) $f3) = ($f4,$f5) $f5) - ($f6,$f7) mul.d $f2,$f4,$f6 # ($f2,$f3) = ($f4,$f5) * ($f6,$f7) div.d $f2,$f4,$f6 # ($f2,$f3) = ($f4,$f5) / ($f6,$f7) Grundlagen der Rechnerarchitektur Assembler 40

41 Zwischenbilanz der MIPS Architektur Memory CPU Registers $0... $31 Coprocessor 1 (FPU) Registers $f0... $f31 Arithmetic Unit Multiply Divide Lo Hi Arithmetic Unit Neu Grundlagen der Rechnerarchitektur Assembler 41

42 Arithmetische Operationen zusammengefasst Gan nzzahlig Gleitko omma Instruktion Beispiel Bemerkung mult, div, madd, msub mult $s1, $s2 Ergebnis wir in den speziellen Registern lo und hi abgelegt. add, sub add $s1, $s2, $s3 Operieren auf den 32 standard CPU Registern addi addi $s1,,$ $s2, 42 Ein Parameter ist eine Konstante mflo, mfhi, mtlo, mthi mflo $s1 ZumLaden und Speichern der Inhalte von lo und hi Register mul mul $1$2$3 $s1, $s2, $s3 $1 $s1 = 32 Low order Bits von $s2 $2* $3 $s3 add.s, sub.s, mul.s, div.s, add.d, sub.d, mul.d, div.d add.s $f0, $f1, $f2 add.d $f0, $f1, $f2 Instruktionen arbeiten auf den speziellen Registern $f0,...,$f31. Single Precision. Instruktionen arbeiten auf den speziellen Registern ($f0,$f1),...,($f30,$f31). Double Precision. lwc1, swc1, lwc1 $f0, 4($s1) Zum Laden und Speichern der Inhalte von ldc1, sdc1 $f0,...,$f31 über den Speicher. mfc1, mtc2 mtc1 $s1, $f0 Zum Laden und Speichern der Inhalte von $f0,...,$f31 $f31 über die standard dcpu Register. mov.s, mov.d mov.s $f1, $f2 Verschieben der Inhalte von $f0,...,$f31 Grundlagen der Rechnerarchitektur Assembler 42

43 Einfaches Quiz MIPS Assemblercode, um die Eingabe in Single Precision aus Fahrenheit in Celsius umzurechnen: $f0 = (5.0 / 9.0) * (Eingabe 32.0) Tipp: wir brauchen: lwc1 zum laden und div.s, sub.s, mul.s Inhalt (Word) Adresse Eingabe Speicher Grundlagen der Rechnerarchitektur Assembler 43

44 Branches und Jumps Grundlagen der Rechnerarchitektur Assembler 44

45 Der Program Counter Memory CPU Arithmetic Unit PC Registers $0... $31 Lo Multiply Divide Hi Der Program Counter ist ein weiteres Register, genannt $pc. Coprocessor 1 (FPU) Unsere bisherigen Assemblerprogramme waren rein sequentiell. Beispiel: 0x : addi $s0, $zero, 4 0x : lw $s1, 0($s0) 0x : lw $s2, 4($s0) 0x400000c : add $s1, $s1, $s1 0x :... Welche nächste Instruktion abgearbeitet werden soll, steht im Program Counter. Zur Abarbeitung der nächsten Instruktion wird der Program Counter von der CPU auf die nächste Instruktion gesetzt, d.h. $pc = $pc + 4. Zur Abarbeitung einer Instruktion zeigt der $pc schon auf die nachfolgende Instruktion. Grundlagen der Rechnerarchitektur Assembler 45

46 Aus der Sequentiellen Abarbeitung springen 0x : addi $s1, $s1, 42 0x : addi $s2, $s2, 24 Gilt $s1 < $s2? nein ja 0x : addi $s0, $zero, 4 0x : lw $s1, 0($s0) 0x : lw $s2, 4($s0) 0x400010c : add $s1, $s1, $s1 0x : add $s1, $s1, $s2 0x : addi $s1, $zero, 1 0x : sw $s1, 0($s0) Program Counter $pc 0x : mult $s1, $s2 $ 0x : div $s1, $s2 0x c : mtlo $s1 0x : mthi $s2 0x : madd $s1,$s2$ Grundlagen der Rechnerarchitektur Assembler 46

47 Bedingte Sprünge und unbedingte Sprünge Start:... beq register1, register2, Label3... bne register1, register2, Label1... j Label2... Ein Label (oder Sprungmarke zu deutsch) Label1:... ist eine mit einem Namen markierte... Stelle im Code, an die man per Branch Label2:... bzw. Jump hin springen möchte.... Assembler Syntax: Name des Labels Label3:... gefolgt von einem :. Grundlagen der Rechnerarchitektur Assembler 47

48 Formate für Sprungbefehle Bedingte Sprünge beq und bne haben das Format I Typ (Immediate): beq $s1, $s2, Label Label I Typ Opcode 6 Bit Source 5 Bit Dest 5 Bit Konstante oder Adresse 16 Bit Unbedingter Sprung hat das Format J Typ (Jump Format): j addr # Springe nach Adresse addr 2 addr Opcode Adresse 6 Bit 26 Bit J Typ Grundlagen der Rechnerarchitektur Assembler 48

49 Anwendungsbeispiel if then else if (i == j) then f = g + h; else f = g - h; Es sei f,,j in $s0,,$s4 gespeichert: bne $s3,$s4,else # gehe nach Else wenn i!=j add $s0,$s1,$s2 # f = g + h (bei i!=j übersprungen) j Exit # gehe nach Exit Else: sub $s0,$s1,$s2 # f = g h (bei i==j übersprungen) Exit: Bildquelle: David A. Patterson und John L. Hennessy, Computer Organization and Design, Fourth Edition, 2012 Grundlagen der Rechnerarchitektur Assembler 49

50 Anwendungsbeispiel while while (safe[i] == k) i += 1; Es sei i und k in $s3 und $s5 gespeichert und die Basis von safe sei $s6: Loop: sll $t1,$s3,2 # Temp-Reg $t1 = i * 4 add $t1,$t1,$s6 # $t1 = Adresse von safe[i] lw $t0,0($t1) # Temp-Reg $t0 = save[i] bne $t0,$s5,exit # gehe nach Exit, wenn save[i]!=k addi $s3,$s3,1 # i = i + 1 j Loop # gehe wieder nach Loop Exit: b0 b1 b2 b3 b4 b5 safe[i] Grundlagen der Rechnerarchitektur Assembler 50

51 Test auf Größer und Kleiner? slt $t0, $s3, $s4 # $t0 = 1 wenn $s3 < $s4 slti $t0, $s2, 10 # $t0 = 1 wenn $s2 < 10 Beispiel: springe nach Exit, wenn $s2 < 42 Exit:... slti $t0, $s2, 42 bne $t0, $zero, Exit... Grundlagen der Rechnerarchitektur Assembler 51

52 Signed und unsigned Vergleiche Registerinhalt von $s0 sei: Registerinhalt von $s1 sei: Was ist tder Wert von $t0 nach Ausführung der folgenden Zeile: slt $t0, $s0, $s1 # Signed-Vergleich $s0<$s1 Was ist der Wert von $t1 nach Ausführung der folgenden Zeile: sltu $t0, $s0, $s1 # Unsigned-Vergleich $s0<$s1 Grundlagen der Rechnerarchitektur Assembler 52

53 Beispiel: Test auf 0 <= $s0 < $s1 in einer Code Zeile Umständlicher Test in zwei Zeilen: slti $t0, $s0, 0 # $t0=1 wenn $s0<0 sonst $t0=0 bne $t0, $zero, OutOfBound # gehe nach OutOfBound wenn $t0!=0 slt $t0, $s0, $s1 # $t0=1 wenn $s0<$s1 sonst $t0=0 beq $t0, $zero, OutOfBound # gehe nach OutOfBound wenn $t0==0... OutOfBound: Test in einer Zeile wenn $s1 immer größer oder gleich 0 ist? Grundlagen der Rechnerarchitektur Assembler 53

54 Unterstützung von Jump Tables Assembler Code: Label_ 1: Label_2: Label_n:... Maschinen Code: 0x : x : x : Jump Table Nr Label Adresse 0 Label_1 0x Label_2 0x n 2 n 1 Label_n 0x # Gewünschter Label sei in $s0 gespeichert und # Startadresse der Jump-Table sei in $s1 # Lade Adresse für gewünschtes Label in $t0 sll $t0, $s0, 2 add $t0, $t0, $s1 lw $t0, 0($t0) # Springe an die in $t0 gespeicherte Adresse jr $t0 Grundlagen der Rechnerarchitektur Assembler 54

55 Floating Point und Branches MIPS Floating Point Instruktionen erlauben Vergleiche der Form: c.x.s $f2,$f3 # Vergleiche Single $f2 mit $f3 c.x.d $f2,$f4 $f4 # Vergleiche Double $f2 mit $f4 Hierbei kann x in c.x.s bzw. c.x.d stehen für: eq = equal lt = less than le = less or equal Beispiele: c.eq.s $f2,$f3 $f3 # $f2 = $f3? c.lt.d $f2,$f4 # ($f2,$f3) < ($f4,$f5)? c.le.s $f2,$f3 # $f2 <= $f3? Grundlagen der Rechnerarchitektur Assembler 55

56 Und dann findet der Branch wie statt? Instruktion bc1t und bc1f nach dem Floating Point Vergleich: bc1t Label # springe nach Label, wenn der # vorige Floating-Point-Vergleich i t l i # erfüllt ist bc1f Label # springe nach Label, wenn der # vorige Floating-Point-Vergleich # nicht erfüllt ist (Bemerkung c1 steht für Coprozessor 1; Erinnerung: die FPU ist dort) Bi Beispiel: il c.lt.d $f2,$f4 # ($f2,$f3) < ($f4,$f5)? bc1t Label # springe nach Label, wenn # ($f2,$f3) < ($f4,$f5) gilt.... Label:... Grundlagen der Rechnerarchitektur Assembler 56

57 Condition Flags Memory CPU Die Floating Point Vergleichsbefehle c.x.s und c.x.d setzen Default mäßig das Condition Flag 0. Die Floating Point Sprungbefehle bc1t und bc1f springen, wenn das Flag 0 gesetzt bzw. nicht gesetzt it ist. Alternativ kann man auch die anderen Flags verwenden. Dann gibt man diese mit den Instruktionen an. Beispiel: c.eq.s 2 $f2,$f3 $f3 # Setze Cond. -Flag # 2, wenn $f2=$f3. bc1t 2 Lab # springe nach Lab # wenn Cond.-Flag # 2 gesetzt ist. Coprocessor 1 (FPU) Registers $f0... $f31 Arithmetic Unit Condition Flags Grundlagen der Rechnerarchitektur Assembler 57

58 Zusammenfassung der Sprung Instruktionen hlig Ganzza bc1t, bc1f bc1t label Springe nach label wenn letzter Floating Point Vergleich true ergab c.x.s (x=eq, lt, le), c.eq.s $f1, $f2 Teste auf $f1=$f2 (single c.x.d (x=eq, lt, le) precision) Flo oating P Point Instruktion Beispiel Bedeutungdes des Beispiels beq, bne beq $s1, $s2, x Springe nach x wenn $s1 = $s2 j jlabel Springe immer nach label jr jr $s1 Springe nach in $s1 gespeicherte Adresse slt, slti, sltu, sltiu slt $s1,$s2,$s3 $s1=1 wenn $s2<$s3 (signed) Grundlagen der Rechnerarchitektur Assembler 58

59 Quiz Im folgenden Codeabschnitt soll nach continue gesprungen werden, wenn $s1 kleiner gleich $s2 ist: loop:... j loop continue:... Tipp: wir brauchen beq, sltund bne Grundlagen der Rechnerarchitektur Assembler 59

60 Annahme: $s1 = 0xFFFFFFFF $s2 = 0x Und noch ein Quiz In welchem der beiden Code Abschnitte wird gesprungen? g... slt $t0,$s1,$s2 bne $t0,$zero, lab sltu $t0,$s1,$s2 beq $t0,$zero, lab lab: lab: Sprung:... ja nein Sprung: ja nein Grundlagen der Rechnerarchitektur Assembler 60

61 Prozeduren Grundlagen der Rechnerarchitektur Assembler 61

62 Das Prinzip von Prozeduren Programmabarbeitung Hauptprogramm:... x = 2*fakultät(10) Prozeduraufruf mit Parameter n=10 Randbemerkung: was ist n!? Prozedur mit dem Namen fakultät..... Berechne n!.. Prozedurrücksprung mit Ergebnis n! Grundlagen der Rechnerarchitektur Assembler 62

63 Programmzähler und Rücksprungadresse Register $pc Register $ra Adresse Maschineninstruktion i 0x : x : x : x004000c : x : x : x : x004001c : x : x : x : x004002c : x : x : x : Startadresse des Hauptprogramms Aufruf der Prozedur Prozedur Fakultät Rücksprung aus der Prozedur Grundlagen der Rechnerarchitektur Assembler 63

64 Assembler Beispiel Hauptprogramm:... 0x004000c addi $a0,$zero,10 # setze $a0 auf 10 0x jal Fakultaet # rufe Prozedur auf 0x sll $v0,2 # Berechne Rückgabe*2... Fakultaet: # Die Prozedur Fakultaet # erwartet den Übergabeparameter in $a0 # gibt das Ergebnis in $v0 zurück 0x # Berechnung der Fakultät... # Das Ergebnis sei in $a0 0x004002c add $v0,$a0,$zero # speichere Ergebnis in $v0 0x jr $ra Register $pc Register $ra Register $a0 Register $v0 Grundlagen der Rechnerarchitektur Assembler 64

65 Problem Hauptprogramm: Programm. abarbeitung. $s0 = 42 vor Aufruf.. x = 2*fakultät(10).. Annahme immer noch $s0=42!?!.. Register $s0 Prozeduraufruf mit Parameter n=10 Prozedurrücksprung mit Ergebnis n! Prozedur mit dem Namen fakultät.. Berechne n! Überschreibe dabei $0 $s0 mit Grundlagen der Rechnerarchitektur Assembler 65

66 Lösung Hauptprogramm:.. $s0 = 42 vor Aufruf. x = 2*fakultät(10) Prozedur mit dem. Namen fakultät. Rette Inhalt von $s0 Es gilt immer auf dem Stack noch $s0=42!!!.. Berechne n!. ($s0 wird iddbi dabei überschrieben) Restauriere Inhalt von $s0 mittels Stack. Register $s0 Register. $sp Stack 0x7fffffff :... 0x7ffffffe :... 0x7ffffffd :... 0x7ffffffc :... 0x7ffffffb :... 0x7ffffffa :... 0x7ffffff9 :... 0x7ffffff8 :... 0x7ffffff7 :... 0x7ffffff6 :... 0x7ffffff5 :... 0x7ffffff4 :... 0x7ffffff3 : 0x7ffffff2 : 0x7ffffff1 : 0x7ffffff0 : 0x7fffffef : 0x7fffffee : 0x7fffffec :.. Grundlagen der Rechnerarchitektur Assembler 66

67 Assembler Beispiel Fakultaet: addi $sp, $sp, -4 # erhöhe Stack-Pointer um ein Word sw $s0, 0($sp) # rette $s0 auf Stack Register $sp # berechne Fakultät # $s0 wird dabei überschrieben lw $s0, 0($sp) # restauriere $s0 vom Stack addi $sp, $sp, 4 # dekrementiere Stack-Pointer jr $ra # Springe zurück zum Aufrufer... 0x7ffffff7 :... 0x7ffffff6 :... 0x7ffffff5 :... 0x7ffffff4 :... 0x7ffffff3 : 0x7ffffff2 : Register $s0 0x7ffffff1 : (sei $s0=0xffef2314 vor Aufruf von Fakultaet) 0x7ffffff0 : 0x7fffffef : 0x7fffffee : 0x7fffffec :... Grundlagen der Rechnerarchitektur Assembler 67

68 Registerkonvention Name Nummer Verwendung Wird über Aufrufgrenzen bewahrt? $zero 0 Konstante 0 n.a. $at 1 nein $v0 $v1 2 3 Prozedur Rückgabe nein $a0 $a3 4 7 Prozedur Parameter nein $t0 $t Temporäre nein $s0 $s Temporär gesicherte ja $t8 $t Temporäre nein $k0 $k nein $gp 28 ja $sp 29 Stack Pointer ja $fp 30 ja $ra 31 Return Adresse ja Grundlagen der Rechnerarchitektur Assembler 68

69 Rekursive Prozeduren Hauptprogramm:... Prozeduraufruf x = 2*fakultät(10) Prozedur mit dem Namen fakultät..... Letzter Rücksprung Berechne n! mit Gesamtergebnis.. Wenn Rekursionsende noch nicht erreicht, dann erneuter Prozeduraufruf ( mit kleinerem Parameter ) Alle vorigen Rücksprünge Grundlagen der Rechnerarchitektur Assembler 69

70 Verwendung des Stacks Stack Hauptprogramm $sp Fakultät Fakultät Fkltät Fakultät Fakultät Rekursionsende Grundlagen der Rechnerarchitektur Assembler 70

71 Assembler Beispiel Auf der nächste Folie wollen wir die Fakultät n! nach folgendem Algorithmus berechnen int fact (int n) { if (n < 1) { return 1; } else { return n * fact(n-1); } } Grundlagen der Rechnerarchitektur Assembler 71

72 Assembler Beispiel # Berechnung der Fakultät von n (also n!) # Eingabeparameter n ist in $a0 gespeichert # Rückgabeparameter der Berechnung ist $v0 fact: addi $sp, $sp, -8 # push Stack-Pointer te um zwei Word sw $ra, 4($sp) # rette Rücksprungadresse auf Stack sw $a0, 0($sp) # rette Eingabeparameter auf Stack slti $t0, $a0, 1 # teste n < 1 beq $t0, $zero, L1 # wenn n >= 1 dann gehe nach L1 addi $v0, $zero, 1 # es wird 1 zurückgegeben addi $sp, $sp, 8 # pop Stack-Pointer um zwei Word jr $ra # Rücksprung zum Prozedur-Aufrufer L1: addi $a0, $a0, -1 # setze Argument auf n-1 jal fact # rufe fact rekursiv mit n-1 auf lw $a0, 0($sp) # restauriere Eingabeparam vom Stack lw $ra, 4($sp) # restauriere Rücksprungadr vom Stack addi $sp, $sp, 8 # pop Stack-Pointer um zwei Word mul $v0, $a0, $v0 # es wird n * fact(n-1) zurück gegeben jr $ra Grundlagen der Rechnerarchitektur Assembler 72

73 Procedure Frame und Frame Pointer Benutzer Stack Speicher Frame Pointer $fp Stack Pointer $sp Procedure Frame Argument 6 Argument 5 Null bis vier Argument Register ($a0 $a3) $a3) Return Adresse $ra Null bis acht Saved Register ($s0 $s7) Möglicher zusätzlicher Speicher der während der Ausführung der Prozedur benötigt wird und nach Prozedurrückkehr nicht mehr Unbenutzer Stack Speicher Hohe Adresse Niedrige Adresse Grundlagen der Rechnerarchitektur Assembler 73

74 Speicherbelegungskonvention $sp 0x7ffffffc Stack $gp $pc 0x x x Heap Statische Daten (z.b. Konstanten oder statische Variablen) Text (d.h. das Programm in Form von Maschinen instruktionen) Der Heap speichert alle dynamischen (d.h. während der Laufzeit angelegten) Daten. 0x Reserviert Grundlagen der Rechnerarchitektur Assembler 74

75 Die Sprunginstruktionen zusammengefasst Instruktion Beispiel Beduetung j j Label $pc = Sprungadresse jal jal Label $ra = $pc+4, $pc= Sprungadresse jr jr $s1 $pc = Registerinhalt $pc ist der Program Counter $ra ist das 32teCPU Register Grundlagen der Rechnerarchitektur Assembler 75

76 Schwieriges Quiz Rekursive Berechnung von n*m in der Form Rmul(n,m) m) = n+rmul(n,m 1) Eingabeparameter: $a0 für n und $a1 für m>0 $a0, $a1, $v0, $t0 brauchen Rückgabeparameter: $v0 nach Registerkonvention alle nichtüber Aufrufgrenzen Temporäre Berechnung: $t0 bewahrt zu werden. Rmul: addi $sp, $sp, -4 # rette Rücksprungadresse sw $ra, 0($sp) # add $t0, $a0, $zero # $t0 = n addi $a1, $a1, -1 # m = m - 1 beq $a1, $zero, End # wenn m=0, dann Ende jal Rmul # $v0 = Rmul(n,m-1) add $t0, $t0, $v0 # $t0 = $t0 + $v0 End: add $v0, $t0, $zero # $v0 = $t0 lw $ra, 0($sp) # springe zurück addi $sp, $sp, 4 # jr $ra # Grundlagen der Rechnerarchitektur Assembler 76

77 Bemerkung zu vorigem Quiz Registerkonvention, ti dass ein Register über Aufrufgrenzen f nicht iht bewahrt wird bedeutet: Register darf nach blib belieben überschreiben werden. Register muss vor dem Rücksprung nicht restauriert werden. Prozedur muss aber das Register für sich selbst sichern! Beispiel: Verwendung von $t0 Sichern von $t0 Aufruf einer anderen Prozedur Restaurieren von $t0 Ausnahme: wir wissen genau, dass das Register in keiner der aufgerufenen Prozeduren verwendet wird. Prozeduren, die keine anderen aufruft muss natürlich temporäre Register nie sichern. Prozedur, die keine andere aufruft nennt man auch Leaf Procedure Grundlagen der Rechnerarchitektur Assembler 77

78 32 Bit Konstanten und Adressierung Grundlagen der Rechnerarchitektur Assembler 78

79 Immediate kann nur 16 Bit lang sein Erinnerung: Laden einer Konstante in ein Register addi $t0, $zero, 200 Als Maschinen Instruktion: addi $zero $t0 200 Inhalt von $t0 nach Instruktionsausführung: Byte 3 Byte 2 Byte 1 Byte 0 Also, Byte 0 und Byte 1 von $t0 kann man so mit einem Wert initialisieren. Was ist mit Byte 2 und 3? Grundlagen der Rechnerarchitektur Assembler 79

80 Lösung: Load Upper Immediate Aufgabe: Lade folgende 32 Bit Konstante in Register $s Neuer Befehl: Lade 16 Bit Wert in obere 16 Bits von Register $s0 lui $s0, 61 # 61 dezimal = binär Registerinhalt von $s0 ist danach: Füge anschließend die unteren 16 Bits ein: ori $s0, $s0, 2304 # 2304 dez = bin Registerinhalt von $s0 ist danach: Grundlagen der Rechnerarchitektur Assembler 80

81 Immediate in Branches sind nur 16 Bit lang Erinnerung: Bedingter Sprung bne $s0, $s1, Exit # gehe nach Exit, wenn $s0!=$s1 Als Maschinen Instruktion (I Typ): bne $s1 $s0 Exit (immediate) Also, nur 16 Bit für die Branch Adresse verfügbar! Konsequenz, wenn Exit eine absolute Adresse wäre: 0x : x0000EFF0 : bne $s0, $s1, 0x #?!?... 0x0000FFFF :... 0x :... Grundlagen der Rechnerarchitektur Assembler 81

82 Lösung: Branches sind PC Relativ Betrachte folgendes Beispiel (Adressen seien Dezimal dargestellt): : bne $s0, $s1, Exit : addi $s3,$s3,1, : j Loop : Exit: Label Exit könnte doch nur die Sprungdifferenz = 12 codieren, d.h : bne $s0, $s1, : addi $s3,$s3, : j Loop : Exit: Noch besser, codiere nur die Anzahl zu überspringender Befehle (also 3 = 12/4): : bne $s0, $s1, : addi $s3,$s3, : j Loop : Exit: (Erinnerung: Instruktionen haben immer Word Länge, also 32 Bit) Grundlagen der Rechnerarchitektur Assembler 82

83 Lösung: Branches sind PC Relativ Sei der Program Counter $pc= und $s0!=$s1 sei erfüllt: : bne $s0, $s1, : addi $s3,$s3,1, : j Loop : Exit: Auf welchen Wert muss der Program Counter als nächstes gesetzt werden? Achtung: obiges Beispiel ist nicht korrekt. MIPS setzt $pc=$pc+4 schon vor Abarbeitung des Befehls. Wie muss damit Zeile korrekt lauten? Grundlagen der Rechnerarchitektur Assembler 83

84 Immediate in Jumps sind nur 26 Bit lang Erinnerung: Unbedingter Sprung j Exit # spinge immer nach Exit Als Maschinen Instruktion (J Typ): j Exit (address) Also, nur 26 Bit für die Adresse verfügbar! Also folgender Adressbereich: von 0x bis 0x03FFFFFF Konsequenz, wenn Exit eine absolute Adresse wäre: 0x : j 0x #?!?... 0x :... Grundlagen der Rechnerarchitektur Assembler 84

85 Lösung: Jumps sind Pseudo Direkt Betrachte voriges Beispiel aber mit korrektem 26 Bit Adressfeld: 0x : j 0x10 # x : x :... Der Program Counter sei $pc=0x Wie kommt man nach 0x ? (0x = xFC = x = x = ) Grundlagen der Rechnerarchitektur Assembler 85

86 Lösung: Jumps sind Pseudo Direkt Auch hier wieder, nutze die Tatsache, dass Befehle immer 4 Bytes lang sind: 0x : j 0x4 # x : x :... Der Program Counter sei $pc=0x Wie kommt man nach 0x ? (0x = xF = x = x = x = ) Grundlagen der Rechnerarchitektur Assembler 86

87 Achtung: Programm Address Boundary Berachte folgendes Beispiel: 0x10EFFF10 : j Label... 0x : Label:... Wie vorher hergeleitet muss das Label folgendes erfüllen: $pc = ($pc AND 0xF ) OR (Label LSHIFT 2) Wie muss das Label übersetzt werden? (0x10EFFF14 = xF = x = ) Also, Sprung von 0x1??????? Nach 0x2??????? So nicht möglich. Grundlagen der Rechnerarchitektur Assembler 87

88 Achtung: Programm Address Boundary Allgemein: Sprünge in der Form beschränkt auf die 256MB Speicherblöcke 0x bis 0x0FFFFFFF 0x bis 0x1FFFFFFF... 0xF bis 0xFFFFFFFF Und wenn man doch hüber Blockgrenzen springen will? Beispiel: Sprung ausbeliebigem Speicherbereich nach0x : Grundlagen der Rechnerarchitektur Assembler 88

89 Zusammenfassung der neuen Befehle Instruktion Beispiel Beduetung lui lui $s1, 61 Lade 16 Bit Wert in obere 16 Bits von Register $s1 Grundlagen der Rechnerarchitektur Assembler 89

90 Quiz : Loop: sll $t1,$s3,2 $ # Temp-Reg $t1 = i * : add $t1,$t1,$s6 # $t1 = Adresse von safe[i] : lw $t0,0($t1) # Temp-Reg $t0 = save[i] : bne $t0,$s5,exit $s5 # gehe nach Exit, wenn save[i]!=k : addi $s3,$s3,1 # i = i : j Loop # gehe wieder nach Loop : Exit: Adresse Opcode rs rt rd shamt Funct Was steht hier? Grundlagen der Rechnerarchitektur Assembler 90

91 Synchronisation Grundlagen der Rechnerarchitektur Assembler 91

92 Data Race Prozessor 1: berechne x = x + 2 lw $t0, 0($s0) # lade x nach $t0 addi $t0, $t0, 2 # $t0 = $t0 + 2 sw $t0, 0($s0) # speichere $t0 nach x Gemeinsamer Speicher Variable x Prozessor 2: berechne x = x 1 lw $t0, 0($s0) # lade x nach $t0 addi $t0, $t0, -1 # $t0 = $t0 1 sw $t0, 0($s0) # speichere $t0 nach x Es gelte zu Beginn: x=10 Gilt nach Durchlauf beider Code Abschnitte immer x=11? Grundlagen der Rechnerarchitektur Assembler 92

93 Problem: Zugriff auf x ist nicht atomar Prozessor 1: berechne x = x + 2 lw $t0, 0($s0) # lade x nach $t0 addi $t0, $t0, 2 # $t0 = $t0 + 2 sw $t0, 0($s0) # speichere $t0 nach x Inhalt von x 10 Prozessor 2: berechne x = x 1 lw $t0, 0($s0) # lade x nach $t0 addi $t0, $t0, -1 # $t0 = $t0 1 sw $t0, 0($s0) # speichere $t0 nach x Zeit Grundlagen der Rechnerarchitektur Assembler 93

94 Mögliche Lösung: Atomic Swap swap $t1, lock 1.) Speicherinhalt lock in Register $t1 kopieren 2.) Alten Wert von $t1 nach lock kopieren Beispiel $t1 lock Vor Ausführung von swap 1 0 Nach Ausführung von swap 0 1 Speicher Variable lock swap ist hierbei atomar, d.h. während des swap wird jeglicher Speicherzugriff anderer Prozesse verzögert bis swap vollständig ausgeführt wurde! MIPS ISA hat kein swap, dennoch gibt es andere ISAs die so einen Befehl haben. Also, zunächstein Beispiel, wie manmittelsswapmittels swap synchronisierenkann kann. Grundlagen der Rechnerarchitektur Assembler 94

95 Mögliche Lösung: Atomic Swap Prozessor 1: berechne x = x + 2 addi $t1, $zero, 1 # setze $t1 auf 1 loop: swap $t1, lock # tausche $t1 und lock bne $t1, $zero, loop # nochmal wenn $t1!=0 lw $t0, 0($s0) # lade x nach $t0 addi $t0, $t0, 2 # $t0 = $t0 + 2 sw $t0, 0($s0) # speichere $t0 nach x swap $t1, lock # gib lock wieder frei Prozessor 2: berechne x = x 1 addi $t1, $zero, 1 # setze $t1 auf 1 loop: swap $t1, lock # tausche $t1 und lock bne $t1, $zero, loop # nochmal wenn $t1!=0 lw $t0, 0($s0) # lade x nach $t0 addi $t0, $t0, -1 # $t0 = $t0 1 sw $t0, 0($s0) # speichere $t0 nach x swap $t1, lock # gib lock wieder frei Gemeinsamer Speicher Variable x Variable lock (initial=0) Grundlagen der Rechnerarchitektur Assembler 95

96 Mögliche Lösung: Atomic Swap Prozessor 1: berechne x = x + 2 addi $t1, $zero, 1 # setze $t1 auf 1 loop: swap $t1, lock # tausche $t1 und lock bne $t1, $zero, loop # nochmal wenn $t1!=0 lw $t0, 0($s0) # lade x nach $t0 addi $t0, $t0, 2 # $t0 = $t0 + 2 sw $t0, 0($s0) # speichere $t0 nach x swap $t1, lock # gib lock wieder frei lock 0 x 10 Prozessor 2: berechne x = x 1 addi $t1, $zero, 1 # setze $t1 auf 1 loop: swap $t1, lock # tausche $t1 und lock bne $t1, $zero, loop # nochmal wenn $t1!=0 lw $t0, 0($s0) # lade x nach $t0 addi $t0, $t0, -1 # $t0 = $t0 1 sw $t0, 0($s0) # speichere $t0 nach x swap $t1, lock # gib lock wieder frei Zeit Grundlagen der Rechnerarchitektur Assembler 96

97 Weitere Lösung: Load Linked und Store Conditional ll $t1, 0($s1) # load linked Lade den Inhalt der Speicherstelle 0($s1) in das Register $t1 sc $t0, 0($s1) # store conditional 1. Wenn seit dem letztem load linked keiner auf den Speicherblock zugegriffen hat, dann Speichere den Inhalt von Register $t0 auf die Speicherstelle 0($s1) und setze $t0 auf1. 2. Sonst lasse den Speicherblock unberührt und setze $t0 auf 0. Speicher Variable lock MIPS ISA hat ein Load Linked (ll) und Store Conditional (sc). Also, wie kann man mit ll und sc synchronisieren? Grundlagen der Rechnerarchitektur Assembler 97

98 Weitere Lösung: Load Linked und Store Conditional Prozessor 1: berechne x = x + 2 loop: ll $t0, 0($s0) # $t0 = x addi $t0, $t0, 2 # $t0 = $t0 + 2 sc $t0, 0($s0) # x = $t0 beq $t0, $zero, loop # nochmal bei failure Gemeinsamer Speicher Variable x Prozessor 2: berechne x = x 1 loop: ll $t0, 0($s0) # $t0 = x addi $t0, $t0, -1 # $t0 = $t0 1 sc $t0, 0($s0) # x = $t0 beq $t0, $zero, loop # nochmal bei failure Grundlagen der Rechnerarchitektur Assembler 98

99 Weitere Lösung: Load Linked und Store Conditional Prozessor 1: berechne x = x + 2 loop: ll $t0, 0($s0) # $t0 = x addi $t0, $t0, 2 # $t0 = $t0 + 2 sc $t0, 0($s0) # x = $t0 beq $t0, $zero, loop # nochmal bei failure x 10 Prozessor 2: berechne x = x 1 loop: ll $t0, 0($s0) # $t0 = x addi $t0, $t0, -1 # $t0 = $t0 1 sc $t0, 0($s0) # x = $t0 beq $t0, $zero, loop # nochmal bei failure Zeit Grundlagen der Rechnerarchitektur Assembler 99

100 Zusammenfassung der neuen Befehle Instruktuion Beispiel Bedeutung ll ll $s1, 0($s0) Lade den Inhalt von Adresse 0($s0) in $s1 und starte eine atomare Read Modify Write Operation. sc sc $t0, 0($s0) Speichere den Inhalt von $t0 auf Adresse 0($s0), wenn seit dem ltt letzten ll nicht ihtvon einem anderen Prozess auf den Speicherblock zugegriffen wurde, der das adressierte Word enthält. Setze $t0 auf 1 in diesem Fall. Ansonsten überschreibe den Speicherbereich nicht und setze $t0 auf 0. Grundlagen der Rechnerarchitektur Assembler 100

101 Quiz für den Quizmaster Realisiere i swap Register, Adresse mit ll und sc. Das Register sei $s0 Die Adresse sei 0($s1) Das temporäre Register sei $t0 Erinnerung: swap tauscht Speicherinhalt und Registerinhalt atomar aus. Grundlagen der Rechnerarchitektur Assembler 101

102 Exceptions Grundlagen der Rechnerarchitektur Assembler 102

103 Motivation: Behandlung von Overflows Was war nochmal ein Overflow? Beispiel mit 8 Bit Zahlen: (= 90) (=103) (=-63) Die bisher behandelten ganzzahligen Arithmetik Instruktionen (z.b. add, addi und sub ) können Overflow erzeugen. Was wenn so ein Overflow auftritt? Einfach ignorieren? Für jeden Overflow sollte eine Ausnahmebehandlungsroutine aufgerufen werden, die dann entscheidet was zu tun ist. Anschließend kann der normale Code wieder ausgeführt werden. Eine solche Ausnahmebehandlung wird über Exceptions realisiert. Grundlagen der Rechnerarchitektur Assembler 103

104 Beispiele für Exceptions Ereignistyp Ausgelöst durch Interrupt den Prozessor? Anfrage eines I/O Gerätes nein X System Call Arithmetischer Overflow Verwendung einer undefinierten Instruktion Hardwarefehler ja/nein (X) ja ja ja Von außen ausgelöste Exceptions nennt man auch Interrupts Grundlagen der Rechnerarchitektur Assembler 104

105 Genereller Ablauf: Behandlung von Exceptions (4) Handle Exception Exception Handler (3) Springe zum Exception Handler (5) springe ggf. wieder zurück. Rücksprung mit gesichertem $pc möglich. Aktuell laufendes Programm Speicher (2) Sichere $pc (1) Exception Woher weis die CPU wo der Exception Handler liegt? Grundlagen der Rechnerarchitektur Assembler 105

106 Behandlung von Exceptions Möglichkeit 1: Interrupt Vektor Tabelle Speichere Adresse der aktuellen Programmausführung in einem speziellen Register EPC. Wähle aus der Interrupt Vektor Tabelle die Adresse des Handlers für diesen Exception Typ und springe dort hin. Handler Routine springt nach Exception Behandlung ggf. zurück in den normalen Code, d.h. an die Programminstruktion auf die EPC zeigt. Exception Adresse des Typ Exception Handlers Undefinded 0x Instruction Arithmetic 0x Overflow Interrupt Vektor Tabelle Grundlagen der Rechnerarchitektur Assembler 106

107 Behandlung von Exceptions Möglichkeit 2: Cause Register (das ist die MIPS Variante) Speichere Adresse der aktuellen Nummer Exception Typ (Grund) Programmausführung in einem 0 Interrupt (Hardware) speziellen Register EPC. 4 Address Error (load or fetch) Speichere den Exception Typ in einem speziellen Cause Register. 5 Address Error (store) 6 Bus Error (fetch) Springe an die Adresse des einen 7 Bus Error (store) Exception Handlers. 8 System Call Der Exception Handler behandelt den im Cause Register beschriebenen Exception Typ. Routine springt nachexception Behandlung ggf. zurück in den normalen Code, d.h. an die Programminstruktion auf die EPC zeigt. 9 Break Point 10 Reserved Instruction 11 Coprocessor Unimplemented 12 ArithmeticOverflow ih i 13 Trap 15 Floating Point Exception MIPS Exception Codes Grundlagen der Rechnerarchitektur Assembler 107

108 MIPS Hardware Realisierung von Exceptions? Memory CPU Registers $0... $31 Coprocessor 1 (FPU) Registers $0... $31 Arithmetic Unit PC Multiply Divide Lo Hi Arithmetic Unit Coprocessor 0 (Traps and Memory) Registers BadVadr ($8) Status ($12) Cause ($13) EPC ($14) Es gibt einen weiteren Coprozessor Grundlagen der Rechnerarchitektur Assembler 108

109 Beispiel: Aufruf des Exception Handlers # Es gelte $s2 = 0x7fffffff 0x : add $s1,$s2,$s2 # Overflow! 0x : # Exception-Handler beginnt immer hier 0x :... 0x : $pc vor Exception: $pc nach Exception: Exception Code für Arithmetic Overflow ist 12. Coprocessor 0 (Traps and Memory) Registers BadVadr ($8) Status ($12) Cause ($13) EPC ($14) Grundlagen der Rechnerarchitektur Assembler 109

110 Beispiel: Handling der Exception # Es gelte $s2 = 0x7fffffff 0x : add $s1,$s2,$s2 # Overflow! 0x : # Ein fauler Exception-Handler 0x : addi $s2,$s2,0 # Problem gelöst 0x : eret # Rücksprung $pc zur Behandlung: $pc nach Behandlung: Coprocessor 0 (Traps and Memory) Registers BadVadr ($8) Status ($12) Cause ($13) EPC ($14) Grundlagen der Rechnerarchitektur Assembler 110

111 Weitere Exceptions während des Handlings? # Es gelte $s2 = 0x7fffffff 0x : add $s1,$s2,$s2 # Overflow! 0x : # Ein fauler Exception-Handler 0x : addi $s2,$s2,0 # Problem gelöst 0x : eret # Rücksprung $pc zur Behandlung: $pc nach Behandlung: Coprocessor 0 (Traps and Memory) Registers Möglichkeiten, z.b.: Exception Handler erzeugt selber eine Exception Anfrage eines IO Gerätes BadVadr ($8) Status ($12) Cause ($13) EPC ($14) Grundlagen der Rechnerarchitektur Assembler 111

112 Exceptions während des Handlings abgeschaltet # Es gelte $s2 = 0x7fffffff 0x : add $s1,$s2,$s2 # Overflow! 0x : # Ein fauler Exception-Handler 0x : addi $s2,$s2,0 # Problem gelöst 0x : eret # Rücksprung Exception Level Bit: 0 = Exceptions werden berücksichtigt 1 = Exceptions werden nicht berücksichtigt Wird bei bisprung in den Exception Handler immer gesetzt. Bei Aufruf von eret wird das Bit wieder gelöscht Coprocessor 0 (Traps and Memory) Registers BadVadr ($8) Status ($12) Cause ($13) EPC ($14) Grundlagen der Rechnerarchitektur Assembler 112

113 Status erlaubt auch das Maskieren von Interrupts # Es gelte $s2 = 0x7fffffff 0x : add $s1,$s2,$s2 # Overflow! 0x : Die Bits einer Interrupt Maske bestimmen welche Interrupt Level Exceptions erzeugen dürfen und welche ignoriert werden. # Ein fauler Exception-Handler 0x : addi $s2,$s2,0 # Problem gelöst 0x : eret # Rücksprung Coprocessor 0 (Traps and Memory) Registers Interrupt Maske Jeder mögliche Interrupt ist einem Interrupt Level zugeord net. Mit Bit 0 des Status Registers können Interrupts generell ein und ausgeschaltet werden. BadVadr ($8) Status ($12) Cause ($13) EPC ($14) Grundlagen der Rechnerarchitektur Assembler 113

114 Pending Interrupts # Es gelte $s2 = 0x7fffffff 0x : add $s1,$s2,$s2 # Overflow! 0x : # Exception-Handler beginnt immer hier 0x :... 0x : Alle ankommenden Interrupts (auch ausmaskierte) setzen im Cause Register das Pending Flag ihres Interrupt Levels. Wird das Masken Bit (oder das generelle Interrupt Bit) später wieder aktiviert, löstdas Pending Bit dann den Interrupt auf der CPU aus. Pending Interrupts Exception Code Coprocessor 0 (Traps and Memory) Registers BadVadr ($8) Status ($12) Cause ($13) EPC ($14) Grundlagen der Rechnerarchitektur Assembler 114

115 Zugriff auf die Coprocesor 0 Register Erinnerung: Für den FPU Coprozessor (Coprozessor 1) hatten wir: mfc1 : laden von FP Coprozessor Register in CPU Register mtc1 : ld laden von CPU Register in FP Coprozessor Register AnalogeInstruktionen für den Coprozessor 0: mfc0 : laden von Coprozessor1 Register in CPU Register mtc0 : laden von CPU Register in Coprozessor1 Register Beispiele: mfc0 $s0, $13 # $s0=coprozessor-register 13 mtc0 $13, $s0 # Coprozessor-Register 13=$s0 Coprocessor 0 (Traps and Memory) Registers BadVadr ($8) Status ($12) Cause ($13) EPC ($14) Grundlagen der Rechnerarchitektur Assembler 115

116 Beispiel für Coprocessor 0 Register Zugriff # Es gelte $s2 = 0x7fffffff 0x : add $s1,$s2,$s2 # Overflow! 0x : # Ein etwas besserer Exception-Handler # Exception auslösende Instruktion einfach überspringen 0x : mfc0 $k0,$14 # $k0 = EPC 0x : addi $k0,$k0,4 # $k0 = EPC+4 0x : mtc0 $14,$k0 # EPC=EPC+4 0x c : eret # Rücksprung Coprocessor 0 (Traps and Memory) Registers $pc zur Behandlung: $pc nach Behandlung: Beachte: Register Satz t Konvention: $k0 und $k1 sind für OS Funktionen reserviert. Behandeln von Exceptions ist eine OS Funktion. BadVadr ($8) Status ($12) Cause ($13) EPC ($14) Grundlagen der Rechnerarchitektur Assembler 116