32 Bit Konstanten und Adressierung. Grundlagen der Rechnerarchitektur Assembler 78

Transkript

1 32 Bit Konstanten und Adressierung Grundlagen der Rechnerarchitektur Assembler 78

2 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

3 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

4 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

5 Lösung: Branches sind PC Relativ Betrachte folgendes Beispiel (Adressen seien Dezimal dargestellt): : bne $s0, $s1, Exit : addi $s3,$s3, : 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

6 Lösung: Branches sind PC Relativ Sei der Program Counter $pc= und $s0!=$s1 sei erfüllt: : bne $s0, $s1, : addi $s3,$s3, : 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

7 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

8 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

9 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

10 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

11 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 über Blockgrenzen springen will? Beispiel: Sprung aus beliebigem Speicherbereich nach 0x : Grundlagen der Rechnerarchitektur Assembler 88

12 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

13 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 # 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

14 Synchronisation Grundlagen der Rechnerarchitektur Assembler 91

15 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

16 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

17 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ächst ein Beispiel, wie man mittels swap synchronisieren kann. Grundlagen der Rechnerarchitektur Assembler 94

18 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

19 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

20 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 auf 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

21 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

22 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

23 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 letzten ll nicht von 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

24 Quiz für den Quizmaster Realisiere 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

25 Exceptions Grundlagen der Rechnerarchitektur Assembler 102

26 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

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

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

29 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 Typ Adresse des Exception Handlers Undefinded 0x Instruction Arithmetic 0x Overflow Interrupt Vektor Tabelle Grundlagen der Rechnerarchitektur Assembler 106

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

31 MIPS Hardware Realisierung von Exceptions? Memory CPU Registers $0... $31 Coprocessor 1 (FPU) Registers $0... $31 Arithmetic Unit PC Lo Multiply Divide 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

32 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

33 Beispiel: Handling der Exception # Es gelte $s2 = 0x7fffffff 0x : add $s1,$s2,$s2 # Overflow! 0x : # Ein fauler Exception-Handler 0x : addi $s2,$zero,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