Synchronisation. Grundlagen der Rechnerarchitektur Assembler 91

Transkript

1 Synchronisation Grundlagen der Rechnerarchitektur Assembler 91

2 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

3 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

4 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

5 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

6 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

7 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

8 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

9 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

10 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

11 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

12 Exceptions Grundlagen der Rechnerarchitektur Assembler 102

13 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

14 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

15 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

16 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

17 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

18 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

19 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

20 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

21 Weitere Exceptions während des Handlings? # 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) Möglichkeiten, z.b.: Exception Handler erzeugt selber eine Exception Anfrage eines IO Gerätes Grundlagen der Rechnerarchitektur Assembler 111

22 Exceptions während des Handlings abgeschaltet # 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 Exception Level Bit: 0 = Exceptions werden berücksichtigt 1 = Exceptions werden nicht berücksichtigt Wird bei Sprung 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

23 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,$zero,0# Problem gelöst 0x : eret # Rücksprung Coprocessor 0 (Traps and Memory) Registers Interrupt Maske Jeder mögliche Interrupt ist einem Interrupt Level zugeordnet. 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

24 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öst das 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

25 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 : laden von CPU Register in FP Coprozessor Register Analoge Instruktionen für den Coprozessor 0: mfc0 : laden von Coprozessor0 Register in CPU Register mtc0 : laden von CPU Register in Coprozessor0 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

26 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 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

27 Traps Trap eine Instruktion, die eine Bedingung testet und eine Exception vom Typ 13 (Trap) auslöst, wenn die Bedingung erfüllt ist. Trap Instruktionen am Beispiel: teq $s0,$s1 # Trap Exception, wenn $s0 = $s1 teqi $s0,42 # Trap Exception, wenn $s0 = 42 tne $s0,$s1 # Trap Exception, wenn $s0!= $s1 tnei $s0,42 # Trap Exception, wenn $s0!= 42 tge $s0,$s1 # Trap Exception, wenn $s0 >= $s1 tgeu $s0,$s1 # Trap Exception, wenn $s0 >= $s1 (unsigned) tgei $s0,$42 # Trap Exception, wenn $s0 >= 42 tgeiu $s0,42 # Trap Exception, wenn $s0 >= 42 (unsigned) tlt $s0,$s1 # Trap Exception, wenn $s0 < $s1 tltu $s0,$s1 # Trap Exception, wenn $s0 < $s1 (unsigned) tlti $s0,$42 # Trap Exception, wenn $s0 < 42 tltiu $s0,42 # Trap Exception, wenn $s0 < 42 (unsigned) Grundlagen der Rechnerarchitektur Assembler 117

28 System Calls System Call Mechanismus zum Aufrufen von Betriebssystemfunktionen. Anwendung der Instruktion syscall am Beispiel: addi $v0, $zero, 1 # Lade System Call Code in $v0 # hier System Call Code 1 für den # Systemcall print_int addi $a0, $zero, 42 # Lade das Argument für den # System Call nach $a0. # Hier soll die Zahl 42 # ausgegeben werden. syscall # Rufe den System Call auf # dies führt zu einer Exception # vom Typ 8 (System Call) Grundlagen der Rechnerarchitektur Assembler 118

29 In SPIM/MARS verfügbare System Calls Bildquelle: David A. Patterson und John L. Hennessy, Computer Organization and Design, Fourth Edition, 2012 Grundlagen der Rechnerarchitektur Assembler 119

30 Zusammenfassung der neuen Befehle Instruktuion eret teq, teqi, tne, tnei, tge, tgeu, tgei, tgeiu, tlt, tltu, tlti, tltiu syscall Bedeutung Springe aus Exception Handler zurück. Setzt Exception Level Bit im Status Register wieder auf 0. Löse Trap Exception aus, wenn die Bedingung erfüllt ist. Beispiel: teq $s0, $s1 löst einen Trap aus, wenn $s0 = $s1 gilt. Rufe System Call mit der in $v0 gespeicherten Nummer auf. Parameter des System Calls werden in $a0 und $a1 übergeben. Beispiel: syscall gibt eine 42 auf dem Bildschirm aus, wenn $v0 = 1 (print_int) und $a0 = 42. Grundlagen der Rechnerarchitektur Assembler 120

31 Unsigned Arithmetik Instruktionen Zu den bisher behandelten Arithmetik Instruktionen gibt es auch noch unsigned Varianten, die keine Overflow Exception erzeugen. Beispiel: # Es gelte $s2 = 0x7fffffff addu $s1,$s2,$s2 # erzeugt *keine* # Overflow-Exception! Grundlagen der Rechnerarchitektur Assembler 121

32 Signed und ihre Unsigend Varianten Signed Instruktion kann Overflow erzeugen Unsigned Vertreter kann Overflow erzeugen add ja addu nein addi ja addiu nein div nein divu nein mult nein multu nein mul nein madd nein maddu nein msub nein msubu nein sub ja subu nein Grundlagen der Rechnerarchitektur Assembler 122

33 Pseudoinstruktionen, Direktiven und Makros Grundlagen der Rechnerarchitektur Assembler 123

34 Motivation für Pseudoinstruktionen Wir hatten häufiger schon addi $s1,$zero,wert # $s1=wert Eine Instruktion li (Load Immediate) wäre doch nachvollziebarer li $s1,wert # $s1=wert MIPS als ISA aus dem RISC Lager versucht aber den Instruktion Set möglichst klein zu halten. Damit ist so was wie ein li in der ISA nicht eingebaut. Kann man ja mit einem addi und dem $zero Register ausdrücken. Dennoch gibt es in MIPS oben genannte Instruktion. Wo kommt die her? Das ist eine sogenannte Pseudoinstruktion,die der Assembler in Instruktionen der MIPS ISA übersetzt. Grundlagen der Rechnerarchitektur Assembler 124

35 Umsetzung von Pseudoinstruktionen Wie würde folgende move Instruktion vom Assembler umgesetzt? move $s1,$s2 # Pseudoinstruktion $s1=$s2 Wie würde folgende blt Instruktion vom Assembler umgesetzt? blt $s1,$s2, Label # Springe nach Label, # wenn $s1<$s2 gilt Beachte: Registerkonvention. Pseudoinstruktionen die ein Register zum Zwischenspeichern von Ergebnissen brauchen, benutzen dazu das Register $at (Assembler Temporary) Grundlagen der Rechnerarchitektur Assembler 125

36 Einige MIPS Assembler Pseudoinstruktioen Instruktion Beispiel Erklärung des Beispiel blt, bltu blt $s1, $s2, Label Springe nach Label, wenn $s1 < $s2 (signed) bgt, bgtu bgt $s1, $s2, Label Springe nach Label, wenn $s1 > $s2 (signed) ble, bleu ble $s1, $s2, Label Springe nach Label, wenn $s1 <= $s2 (signed) bge, bgeu bge $s1, $s2, Label Springe nach Label, wenn $s1 >= $s2 (signed) li li $s1, 42 Lade Immediate 42 in $s1 move move $s1, $s2 $s1 = $s2 MARS unterstützt beispielsweise neben den 155 Basisinstruktionen weitere 388 zusätzliche Pseudoinstruktionen. Grundlagen der Rechnerarchitektur Assembler 126

37 Direktiven Direktiven vereinfachen das Datenlayout eines Programms im Speicher. Damit der Assembler ein Programm, wie auf der rechten Seite gezeigt, erzeugt, schreiben wir:.text 0x li $v0, 1 li $a0, 5 syscall.data 0x str:.asciiz "Hallo Welt! 0x : li $v0, 1 0x : li $a0, 5 0x : syscall... 0x : H 0x : a 0x : l 0x : l 0x : o... Grundlagen der Rechnerarchitektur Assembler 127

38 Makros (nicht Besandteil von SPIM/MARS) Makros definieren in einem Wort eine Folge von Instruktionen. Beim assemblieren wird jedes Auftreten des Makronamens im Code mit den Instruktionen ausgetauscht. Beispiel:.macro print_int($arg) la $a0, int_str mov $a1, $arg jal printf.end_macro....data int_str:.asciiz %d Code:... print_int($t0)... wird expandiert zu:... la $a0, int_str mov $a1, $t0 jal printf... Grundlagen der Rechnerarchitektur Assembler 128

39 Nochmal alles im Überblick Grundlagen der Rechnerarchitektur Assembler 129

40 MIPS R2000 CPU und Coprocessoren Memory CPU Registers $0... $31 Coprocessor 1 (FPU) Registers $0... $31 Arithmetic Unit PC Lo Multiply Divide Hi Condition Flags Arithmetic Unit Coprocessor 0 (Traps and Memory) Registers BadVadr ($8) Status ($12) Cause ($13) EPC ($14) Grundlagen der Rechnerarchitektur Assembler 130

41 Alle Instruktionsformate opcode src1 src2 dest shamt funct 6 Bit 5 Bit 5 Bit 5 Bit 5 Bit 6 Bit R Typ (Register Typ) opcode reg1 reg2 Sprungoffset/Wert 6 Bit 5 Bit 5 Bit 16 Bit I Typ (Immediate Typ) opcode Adresse 6 Bit 26 Bit J Typ (Jump Typ) 32 Bit Grundlagen der Rechnerarchitektur Assembler 131

42 Kompletter CPU Registersatz Name Nummer Verwendung Wird über Aufrufgrenzen bewahrt? $zero 0 Konstante 0 n.a. $at 1 Assembler Temporary 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 Reserviert für das OS nein $gp 28 Global Pointer ja $sp 29 Stack Pointer ja $fp 30 Frame Pointer ja $ra 31 Return Adresse ja Grundlagen der Rechnerarchitektur Assembler 132

43 Kategorie Unterkategorie Assembler Befehlsname (Mnemonic) Typ Einfache Arithmetik Register add, addu, sub, subu mult, multu, div, divu, mfhi, mflo Immediate addi, addiu I Register and, or, nor, xor R Logische Operationen Immediate andi, ori, xori I Bedingte Sprünge beq, bne I Unbedingte Sprünge Einige CPU Instruktionen j, jal J jr Word lw, sw, ll, sc I Speicherzugriff Halfword lh, lhu, sh I Byte lb, lbu, sb I Laden von Konstanten lui I Register slt, sltu R Vergleiche Immediate slti, sltiu I Shifts sll, sllv, slr, slrv, sra, srav R Grundlagen der Rechnerarchitektur Assembler 133 R R

44 Einige FPU Instruktionen Kategorie Assembler Befehlsname (Mnemonic) Typ Branch bc1f, bc1t I FPU Registerzugriff mtc1, mfc1 R FPU Speicherzugriff lwc1, swc1, ldc1, sdc1 I Single Precision Arithmetik add.s, sub.s, mul.s, div.s R Double Precision Arithmetik add.d, sub.d, mul.d, div.d R Verschieben von Registerinhalten der FPU mov.s, mov.d R Single Precision Vergleiche c.x.s (x=eq, lt, le) R Double Precision Vergleiche c.x.d (x=eq, lt, le) R Grundlagen der Rechnerarchitektur Assembler 134

45 Einige Pseudoinstruktionen Kategorie Branches 32 Bit Immediate laden Register kopieren Mnemonic blt, bltu bgt, bgtu ble, bleu bge, bgeu li move Grundlagen der Rechnerarchitektur Assembler 135

46 Speicherbelegungskonvention $sp $gp 0x7ffffffc 0x Stack Heap Hohe Adresse Benutzer Speicher Argument 6 Argument 5 Saved Register $fp $pc 0x x x Statische Daten Text Reserviert Niedrige Adresse Lokale Variablen Unbenutzer Speicher Procedure Frame $sp Grundlagen der Rechnerarchitektur Assembler 136

47 Immediate Adressierung Beispiel: addi $s0, $s2, 42 # $s0 = $s (Instruktionstyp: I Typ) Bildquelle: David A. Patterson und John L. Hennessy, Computer Organization and Design, Fourth Edition, 2012 Grundlagen der Rechnerarchitektur Assembler 137

48 Register Adressierung Beispiel: add $s0, $s2, $s4 # $s0 = $s2 + $s (Instruktionstyp: R Typ) Bildquelle: David A. Patterson und John L. Hennessy, Computer Organization and Design, Fourth Edition, 2012 Grundlagen der Rechnerarchitektur Assembler 138

49 Basis Adressierung Beispiel: lw $t0, 12($s0) # $t0 = Inhalt der Speicherstelle $s2+12 (Instruktionstyp: I Typ) Bildquelle: David A. Patterson und John L. Hennessy, Computer Organization and Design, Fourth Edition, 2012 Grundlagen der Rechnerarchitektur Assembler 139

50 PC Relative Adressierung Beispiel: beq $s0, $s2, Label # wenn $s0 = $s2 dann springe nach # Label. (Instruktionstyp: I Typ) (Beachte: Address speichert die Anzahl zu überspringender Words und nicht die Bytes) Bildquelle: David A. Patterson und John L. Hennessy, Computer Organization and Design, Fourth Edition, 2012 Grundlagen der Rechnerarchitektur Assembler 140

51 Pseudodirekte Adressierung Beispiel: j Label # Springe nach Label (Instruktionstyp: J Typ) (Beachte: Address speichert die untere Basis des PC in Words und nicht in Bytes) Bildquelle: David A. Patterson und Grundlagen John L. Hennessy, der Rechnerarchitektur Computer Organization Assembler and Design, Fourth Edition,

52 Eine Instruktion haben wir noch vergessen nop # tue nichts So das war s: li $v0,10 syscall Grundlagen der Rechnerarchitektur Assembler 142

53 Zusammenfassung und Literatur Grundlagen der Rechnerarchitektur Assembler 143

54 Zusammenfassung Assembler als Schnittstelle zwischen höheren Sprachen und den Maschinen Instruktionen Assembler übersetzt menschenlesbare Assembler Instruktionen in maschinenlesbare Maschineninstruktionen (Zahlen) Assembler kann die ISA mit sinnvollen Pseudoinstruktionen erweitern Wir haben nochmals deutlich das Prinzip des Stored Program gesehen Instruktionen sind ununterscheidbar von Zahlen Instruktionen liegen im gewöhnlichen Datenspeicher Programmieren in Assemblersprache macht alles schneller? Wenn dann nur kritischste Teile Compiler kennt die Intention des Programmes nicht Compiler optimieren heutzutage aber sehr gut; meist besser als der gewöhnliche Assemblerprogrammierer Höhere Sprache bedeutet weniger Codezeilen und damit auch schnellere Programmierzeit Höhere Sprache bedeutet auch, dass Code schneller auf neue Architektur portierbar ist Der Speicher speichert lediglich Bits. Interpretation des Inhalts hängt von der Instruktion ab die darauf zu greift Programmieren lernt man nicht durch zuhören. Übung mach den Meister! Grundlagen der Rechnerarchitektur Assembler 144

55 Literatur [PattersonHennessy2012] David A. Patterson und John L. Hennessy, Computer Organization and Design, Fourth Edition, Introduction 2.2 Operations of the Computer Hardware 2.3 Operands of the Computer Hardware 2.5 Representing Instructions in the Computer 2.7 Instructions for Making Decisions 2.8 Supporting Procedures in Computer Hardware 2.9 Communicating with People 2.10 MIPS Addressing for 32 Bit Immediates and Adresses 2.11 Parallelism and Instructions: Synchronization 4.9 Exceptions B.1 Introduction B.2 Assemblers B.5 Memory Usage B.6 Procedure Call Convention B.7 Exceptions and Interrupts B.9 SPIM B.10 MIPS R2000 Assembly Language Grundlagen der Rechnerarchitektur Assembler 145