Synchronisation
Grundlagen der Rechnerarchitektur ‐ Assembler 91
Data‐Race
Grundlagen der Rechnerarchitektur ‐ Assembler 92
Prozessor 1: berechne x = x + 2
lw $t0, 0($s0) # lade x nach $t0addi $t0, $t0, 2 # $t0 = $t0 + 2sw $t0, 0($s0) # speichere $t0 nach x
Gemeinsamer Speicher
Variable x
Prozessor 2: berechne x = x – 1
lw $t0, 0($s0) # lade x nach $t0addi $t0, $t0, -1 # $t0 = $t0 – 1sw $t0, 0($s0) # speichere $t0 nach x Es gelte zu Beginn: x=10
Gilt nach Durchlauf beider Code‐Abschnitte immer x=11?
Problem: Zugriff auf x ist nicht atomar
Grundlagen der Rechnerarchitektur ‐ Assembler 93
Prozessor 1: berechne x = x + 2
lw $t0, 0($s0) # lade x nach $t0addi $t0, $t0, 2 # $t0 = $t0 + 2sw $t0, 0($s0) # speichere $t0 nach x
Prozessor 2: berechne x = x – 1
lw $t0, 0($s0) # lade x nach $t0addi $t0, $t0, -1 # $t0 = $t0 – 1sw $t0, 0($s0) # speichere $t0 nach x
Zeit
Inhalt von x10
Mögliche Lösung: Atomic‐Swap
Grundlagen der Rechnerarchitektur ‐ Assembler 94
Speicher
Variable lock
1.) Speicherinhalt lock in Register $t1 kopieren2.) Alten Wert von $t1 nach lock kopieren
swap $t1, lock
Beispiel
$t1 lock
Vor Ausführung von swap 1 0
Nach Ausführung von swap 0 1
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.
swap ist hierbei atomar, d.h. während des swap wird jeglicher Speicherzugriff anderer Prozesse verzögert bis swap vollständig ausgeführt wurde!
Mögliche Lösung: Atomic‐Swap
Grundlagen der Rechnerarchitektur ‐ Assembler 95
Prozessor 1: berechne x = x + 2
addi $t1, $zero, 1 # setze $t1 auf 1loop: swap $t1, lock # tausche $t1 und lock
bne $t1, $zero, loop # nochmal wenn $t1!=0lw $t0, 0($s0) # lade x nach $t0addi $t0, $t0, 2 # $t0 = $t0 + 2sw $t0, 0($s0) # speichere $t0 nach xswap $t1, lock # gib lock wieder frei
Gemeinsamer Speicher
Variable x
Variable lock (initial=0)Prozessor 2: berechne x = x – 1
addi $t1, $zero, 1 # setze $t1 auf 1loop: swap $t1, lock # tausche $t1 und lock
bne $t1, $zero, loop # nochmal wenn $t1!=0lw $t0, 0($s0) # lade x nach $t0addi $t0, $t0, -1 # $t0 = $t0 – 1sw $t0, 0($s0) # speichere $t0 nach xswap $t1, lock # gib lock wieder frei
Mögliche Lösung: Atomic‐Swap
Grundlagen der Rechnerarchitektur ‐ Assembler 96
Prozessor 1: berechne x = x + 2
addi $t1, $zero, 1 # setze $t1 auf 1loop: swap $t1, lock # tausche $t1 und lock
bne $t1, $zero, loop # nochmal wenn $t1!=0lw $t0, 0($s0) # lade x nach $t0addi $t0, $t0, 2 # $t0 = $t0 + 2sw $t0, 0($s0) # speichere $t0 nach xswap $t1, lock # gib lock wieder frei
Prozessor 2: berechne x = x – 1
addi $t1, $zero, 1 # setze $t1 auf 1loop: swap $t1, lock # tausche $t1 und lock
bne $t1, $zero, loop # nochmal wenn $t1!=0lw $t0, 0($s0) # lade x nach $t0addi $t0, $t0, -1 # $t0 = $t0 – 1sw $t0, 0($s0) # speichere $t0 nach xswap $t1, lock # gib lock wieder frei Zeit
x
10
lock
0
Weitere Lösung: Load Linked und Store Conditional
Grundlagen der Rechnerarchitektur ‐ Assembler 97
MIPS‐ISA hat ein Load‐Linked (ll) und Store‐Conditional (sc).Also, wie kann man mit ll und sc synchronisieren?
Speicher
Variable lock
Lade den Inhalt der Speicherstelle 0($s1) in das Register $t1
ll $t1, 0($s1) # load linked
sc $t0, 0($s1) # store conditional1. 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 1.
2. Sonst lasse den Speicherblock unberührt und setze $t0 auf 0.
Weitere Lösung: Load Linked und Store Conditional
Grundlagen der Rechnerarchitektur ‐ Assembler 98
Prozessor 1: berechne x = x + 2
loop: ll $t0, 0($s0) # $t0 = xaddi $t0, $t0, 2 # $t0 = $t0 + 2sc $t0, 0($s0) # x = $t0beq $t0, $zero, loop # nochmal bei failure
Gemeinsamer Speicher
Variable x
Prozessor 2: berechne x = x – 1
loop: ll $t0, 0($s0) # $t0 = xaddi $t0, $t0, -1 # $t0 = $t0 – 1sc $t0, 0($s0) # x = $t0beq $t0, $zero, loop # nochmal bei failure
Weitere Lösung: Load Linked und Store Conditional
Grundlagen der Rechnerarchitektur ‐ Assembler 99
Prozessor 1: berechne x = x + 2
loop: ll $t0, 0($s0) # $t0 = xaddi $t0, $t0, 2 # $t0 = $t0 + 2sc $t0, 0($s0) # x = $t0beq $t0, $zero, loop # nochmal bei failure
Prozessor 2: berechne x = x – 1
loop: ll $t0, 0($s0) # $t0 = xaddi $t0, $t0, -1 # $t0 = $t0 – 1sc $t0, 0($s0) # x = $t0beq $t0, $zero, loop # nochmal bei failure
Zeit
x
10
Zusammenfassung der neuen Befehle
Grundlagen der Rechnerarchitektur ‐ Assembler 100
Instruktuion Beispiel Bedeutungll 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.
Quiz für den Quizmaster
Grundlagen der Rechnerarchitektur ‐ Assembler 101
Realisiere swap Register, Adresse mit ll und sc.
Erinnerung:swap tauscht Speicher‐inhalt und Registerinhalt atomar aus.
Das Register sei $s0Die Adresse sei 0($s1)Das temporäreRegister sei $t0
Exceptions
Grundlagen der Rechnerarchitektur ‐ Assembler 102
Motivation: Behandlung von Overflows
Grundlagen der Rechnerarchitektur ‐ Assembler 103
Was war nochmal ein Overflow? Beispiel mit 8‐Bit‐Zahlen:01011010 (= 90)
+ 01100111 (=103)-----------------11000001 (=-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.
Beispiele für Exceptions
Grundlagen der Rechnerarchitektur ‐ Assembler 104
Von außen ausgelöste Exceptions nennt man auch Interrupts
Ereignistyp Ausgelöst durchden Prozessor?
Interrupt
Anfrage eines I/O Gerätes nein XSystem‐Call jaArithmetischer Overflow jaVerwendung einer undefiniertenInstruktion
ja
Hardwarefehler ja/nein (X)... ...
Behandlung von Exceptions
Grundlagen der Rechnerarchitektur ‐ Assembler 105
Genereller Ablauf:
Exception‐Handler
Aktuell laufendes Programm
Speicher
(1) Exception
(2) Sichere $pc
(3) Springe zumException‐Handler(4) Behandle die
Exception
(5) springe ggf.wieder zurück.Rücksprung mitgesichertem $pcmöglich.
Woher weis die CPU wo der Exception‐Handler liegt?
Behandlung von Exceptions
Grundlagen der Rechnerarchitektur ‐ Assembler 106
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.
Exception‐Typ
Adresse des Exception‐Handlers
UndefindedInstruction
0x8000 0000
ArithmeticOverflow
0x8000 0180
... ...Handler‐Routine springt nach Exception‐Behandlung ggf. zurück in den normalen Code, d.h. an die Programminstruktion auf die EPC
zeigt.
Interrupt‐Vektor‐Tabelle
Behandlung von Exceptions
Grundlagen der Rechnerarchitektur ‐ Assembler 107
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‐ExceptionMIPS Exception‐Codes
PC
MIPS Hardware‐Realisierung von Exceptions?
Grundlagen der Rechnerarchitektur ‐ Assembler 108
CPU Coprocessor 1 (FPU)
Coprocessor 0 (Traps and Memory)
$0...
$31
ArithmeticUnit
MultiplyDivide
$0...
$31
ArithmeticUnit
RegistersRegisters
Lo Hi
BadVadr ($8) Status ($12) Cause ($13) EPC ($14)Registers
Memory
Es gibt einen weiteren Coprozessor
Beispiel: Aufruf des Exception‐Handlers
Grundlagen der Rechnerarchitektur ‐ Assembler 109
Coprocessor 0 (Traps and Memory)Registers
# Es gelte $s2 = 0x7fffffff0x40000014 : add $s1,$s2,$s2 # Overflow!0x40000018 : ...
...
# Exception-Handler beginnt immer hier0x80000180 : ...0x80000184 : ...
BadVadr ($8) Status ($12) Cause ($13) EPC ($14)
$pc vor Exception:
6 2 Exception‐Code für Arithmetic Overflow ist 12.
$pc nach Exception:
Beispiel: Handling der Exception
Grundlagen der Rechnerarchitektur ‐ Assembler 110
Coprocessor 0 (Traps and Memory)
40000014
Registers
# Es gelte $s2 = 0x7fffffff0x40000014 : add $s1,$s2,$s2 # Overflow!0x40000018 : ...
...
# Ein fauler Exception-Handler0x80000180 : addi $s2,$zero,0# Problem gelöst0x80000184 : eret # Rücksprung
BadVadr ($8) Status ($12) Cause ($13) EPC ($14)
$pc zur Behandlung:
$pc nach Behandlung:
Weitere Exceptions während des Handlings?
Grundlagen der Rechnerarchitektur ‐ Assembler 111
Coprocessor 0 (Traps and Memory)
40000014
Registers
# Es gelte $s2 = 0x7fffffff0x40000014 : add $s1,$s2,$s2 # Overflow!0x40000018 : ...
...
# Ein fauler Exception-Handler0x80000180 : addi $s2,$zero,0# Problem gelöst0x80000184 : eret # Rücksprung
BadVadr ($8) Status ($12) Cause ($13) EPC ($14)
$pc zur Behandlung:
$pc nach Behandlung:
Möglichkeiten, z.B.:• Exception‐Handler erzeugtselber eine Exception
• Anfrage eines IO‐Gerätes
Exceptions während des Handlings abgeschaltet
Grundlagen der Rechnerarchitektur ‐ Assembler 112
Coprocessor 0 (Traps and Memory)Registers
# Es gelte $s2 = 0x7fffffff0x40000014 : add $s1,$s2,$s2 # Overflow!0x40000018 : ...
...
# Ein fauler Exception-Handler0x80000180 : addi $s2,$zero,0# Problem gelöst0x80000184 : eret # Rücksprung
BadVadr ($8) Status ($12) Cause ($13) EPC ($14)
15 8 1 0
Exception‐Level‐Bit:0 = Exceptions werden
berücksichtigt1 = Exceptions werden
nicht berücksichtigt
Wird bei Sprung in denException‐Handler immergesetzt.Bei Aufruf von eret wirddas Bit wieder gelöscht
Status erlaubt auch das Maskieren von Interrupts
Grundlagen der Rechnerarchitektur ‐ Assembler 113
Coprocessor 0 (Traps and Memory)Registers
# Es gelte $s2 = 0x7fffffff0x40000014 : add $s1,$s2,$s2 # Overflow!0x40000018 : ...
...
# Ein fauler Exception-Handler0x80000180 : addi $s2,$zero,0# Problem gelöst0x80000184 : eret # Rücksprung
BadVadr ($8) Status ($12) Cause ($13) EPC ($14)
15 8 1 0
Interrupt‐Maske
Die Bits einer Interrupt‐Maskebestimmen welche Interrupt‐Level Exceptions erzeugen dür‐fen und welche ignoriert wer‐den.
Jeder mögliche Interrupt isteinem Interrupt‐Level zugeord‐net.
Mit Bit 0 des Status‐Registers können Interrupts generell ein‐ und ausgeschaltet werden.
Pending‐Interrupts
Grundlagen der Rechnerarchitektur ‐ Assembler 114
Coprocessor 0 (Traps and Memory)
# Es gelte $s2 = 0x7fffffff0x40000014 : add $s1,$s2,$s2 # Overflow!0x40000018 : ...
...
# Exception-Handler beginnt immer hier0x80000180 : ...0x80000184 : ...
BadVadr ($8) Status ($12) Cause ($13) EPC ($14)
15 8 6 2
Exception‐Code
Registers
PendingInterrupts
Alle ankommenden Interrupts(auch ausmaskierte) setzenim Cause‐Register dasPending‐Flag ihres Interrupt‐Levels.
Wird das Masken‐Bit (oder dasgenerelle Interrupt‐Bit) späterwieder aktiviert, löst dasPending‐Bit dann den Interruptauf der CPU aus.
Zugriff auf die Coprocesor‐0‐Register
Grundlagen der Rechnerarchitektur ‐ Assembler 115
Coprocessor 0 (Traps and Memory)
BadVadr ($8) Status ($12) Cause ($13) EPC ($14)Registers
Erinnerung: Für den FPU‐Coprozessor (Coprozessor 1) hatten wir:mfc1 : laden von FP‐Coprozessor‐Register in CPU‐Registermtc1 : laden von CPU‐Register in FP‐Coprozessor‐Register
Analoge Instruktionen für den Coprozessor 0:mfc0 : laden von Coprozessor0‐Register in CPU‐Registermtc0 : laden von CPU‐Register in Coprozessor0‐Register
Beispiele:mfc0 $s0, $13 # $s0=Coprozessor-Register 13mtc0 $13, $s0 # Coprozessor-Register 13=$s0
Beispiel für Coprocessor 0 Register‐Zugriff
Grundlagen der Rechnerarchitektur ‐ Assembler 116
Coprocessor 0 (Traps and Memory)Registers
# Es gelte $s2 = 0x7fffffff0x40000014 : add $s1,$s2,$s2 # Overflow!0x40000018 : ...
...
# Ein etwas besserer Exception-Handler# Exception auslösende Instruktion einfach überspringen0x80000180 : mfc0 $k0,$14 # $k0 = EPC0x80000184 : addi $k0,$k0,4 # $k0 = EPC+40x80000188 : mtc0 $14,$k0 # EPC=EPC+40x8000018c : eret # Rücksprung
BadVadr ($8) Status ($12) Cause ($13) EPC ($14)
$pc zur Behandlung:
$pc nach Behandlung:
Beachte: Register‐Satz‐Konvention: $k0 und $k1 sind für OS‐Funktionenreserviert. Behandeln vonExceptions ist eine OS‐Funktion.
Traps
Grundlagen der Rechnerarchitektur ‐ Assembler 117
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 = $s1teqi $s0,42 # Trap‐Exception, wenn $s0 = 42tne $s0,$s1 # Trap‐Exception, wenn $s0 != $s1tnei $s0,42 # Trap‐Exception, wenn $s0 != 42tge $s0,$s1 # Trap‐Exception, wenn $s0 >= $s1tgeu $s0,$s1 # Trap‐Exception, wenn $s0 >= $s1 (unsigned)tgei $s0,$42 # Trap‐Exception, wenn $s0 >= 42tgeiu $s0,42 # Trap‐Exception, wenn $s0 >= 42 (unsigned)tlt $s0,$s1 # Trap‐Exception, wenn $s0 < $s1tltu $s0,$s1 # Trap‐Exception, wenn $s0 < $s1 (unsigned)tlti $s0,$42 # Trap‐Exception, wenn $s0 < 42tltiu $s0,42 # Trap‐Exception, wenn $s0 < 42 (unsigned)
System‐Call – Mechanismus zum Aufrufen von Betriebssystem‐funktionen.
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)
System‐Calls
Grundlagen der Rechnerarchitektur ‐ Assembler 118
In SPIM/MARS verfügbare System‐Calls
Grundlagen der Rechnerarchitektur ‐ Assembler 119Bildquelle: David A. Patterson und John L. Hennessy, „Computer Organization and Design“, Fourth Edition, 2012
Zusammenfassung der neuen Befehle
Grundlagen der Rechnerarchitektur ‐ Assembler 120
Instruktuion Bedeutungeret Springe aus Exception‐Handler zurück. Setzt
Exception‐Level‐Bit im Status‐Register wieder auf 0.
teq, teqi, tne, tnei,tge, tgeu, tgei, tgeiu,tlt, tltu, tlti, tltiu
Löse Trap‐Exception aus, wenn die Bedingung erfüllt ist.Beispiel: teq $s0, $s1 löst einen Trap aus, wenn $s0 = $s1 gilt.
syscall Rufe System‐Call mit der in $v0 gespeicherten Nummer auf. Parameter des System‐Callswerden in $a0 und $a1 übergeben.Beispiel: syscall gibt eine 42 auf dem Bildschirm aus, wenn $v0 = 1 (print_int) und $a0 = 42.
Unsigned Arithmetik‐Instruktionen
Grundlagen der Rechnerarchitektur ‐ Assembler 121
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!
Signed und ihre Unsigend‐Varianten
Grundlagen der Rechnerarchitektur ‐ Assembler 122
SignedInstruktion
kann Overflow erzeugen
UnsignedVertreter
kann Overflow erzeugen
add ja addu neinaddi ja addiu neindiv nein divu neinmult nein multu neinmul neinmadd nein maddu neinmsub nein msubu neinsub ja subu nein
Pseudoinstruktionen, Direktiven und Makros
Grundlagen der Rechnerarchitektur ‐ Assembler 123
Motivation für Pseudoinstruktionen
Grundlagen der Rechnerarchitektur ‐ Assembler 124
Wir hatten häufiger schonaddi $s1,$zero,wert # $s1=wert
Eine Instruktion li (Load‐Immediate) wäre doch nachvollziebarerli $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 $zeroRegister 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.
Umsetzung von Pseudoinstruktionen
Grundlagen der Rechnerarchitektur ‐ Assembler 125
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)
Einige MIPS‐Assembler Pseudoinstruktioen
Grundlagen der Rechnerarchitektur ‐ Assembler 126
Instruktion Beispiel Erklärung des Beispielblt, 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 $s1move move $s1, $s2 $s1 = $s2
MARS unterstützt beispielsweise neben den 155 Basisinstruktionen weitere 388 zusätzliche Pseudoinstruktionen.
Direktiven
Grundlagen der Rechnerarchitektur ‐ Assembler 127
Direktiven vereinfachen das Datenlayout eines Programms im Speicher.
Damit der Assembler ein Programm, wie auf der rechten Seite gezeigt, erzeugt, schreiben wir:.text 0x00400010li $v0, 1li $a0, 5syscall
.data 0x10001000str:.asciiz "Hallo Welt!“
0x00400010 : li $v0, 10x00400014 : li $a0, 50x00400014 : syscall
...
0x10001000 : ‘H’0x10001001 : ‘a’0x10001002 : ‘l’0x10001003 : ‘l’0x10001004 : ‘o’
...
Makros (nicht Besandteil von SPIM/MARS)
Grundlagen der Rechnerarchitektur ‐ Assembler 128
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_strmov $a1, $argjal printf.end_macro
...
.dataint_str: .asciiz „%d“
Code:...print_int($t0)...
wird expandiert zu:...la $a0, int_strmov $a1, $t0jal printf...
Nochmal alles im Überblick
Grundlagen der Rechnerarchitektur ‐ Assembler 129
MIPS R2000 CPU und Coprocessoren
Grundlagen der Rechnerarchitektur ‐ Assembler 130
CPU Coprocessor 1 (FPU)
Coprocessor 0 (Traps and Memory)
$0...
$31
ArithmeticUnit
MultiplyDivide
$0...
$31
ArithmeticUnit
RegistersRegisters
Lo Hi
BadVadr ($8) Status ($12) Cause ($13) EPC ($14)Registers
Memory
PCCondition‐
Flags
Alle Instruktionsformate
Grundlagen der Rechnerarchitektur ‐ Assembler 131
opcode reg1 reg2 Sprungoffset/Wert6 Bit 5 Bit 5 Bit 16 Bit
I‐Typ(Immediate‐Typ)
opcode Adresse6 Bit 26 Bit
J‐Typ(Jump‐Typ)
opcode src1 src2 dest shamt funct6 Bit 5 Bit 5 Bit 5 Bit 5 Bit 6 Bit
R‐Typ(Register‐Typ)
32 Bit
Kompletter CPU‐Registersatz
Grundlagen der Rechnerarchitektur ‐ Assembler 132
Name Nummer Verwendung Wird über Aufrufgrenzenbewahrt?
$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‐$t7 8‐15 Temporäre nein
$s0‐$s7 16‐23 Temporär gesicherte ja
$t8‐$t9 24‐25 Temporäre nein
$k0‐$k1 26‐27 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 133
Kategorie Unterkategorie Assembler‐Befehlsname (Mnemonic) Typ
Einfache ArithmetikRegister add, addu, sub, subu
mult, multu, div, divu, mfhi, mfloR
Immediate addi, addiu I
Logische OperationenRegister and, or, nor, xor R
Immediate andi, ori, xori I
Bedingte Sprünge beq, bne I
Unbedingte Sprüngej, jal Jjr R
Speicherzugriff
Word lw, sw, ll, sc I
Halfword lh, lhu, sh I
Byte lb, lbu, sb I
Laden von Konstanten lui I
VergleicheRegister slt, sltu R
Immediate slti, sltiu I
Shifts sll, sllv, slr, slrv, sra, srav R
Einige CPU‐Instruktionen
Einige FPU‐Instruktionen
Grundlagen der Rechnerarchitektur ‐ Assembler 134
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
Einige Pseudoinstruktionen
Grundlagen der Rechnerarchitektur ‐ Assembler 135
Kategorie MnemonicBranches blt, bltu
bgt, bgtuble, bleubge, bgeu
32‐Bit Immediate laden liRegister kopieren move
Speicherbelegungskonvention
Grundlagen der Rechnerarchitektur ‐ Assembler 136
Reserviert
Text
Statische Daten
Heap
0x00400000
0x10000000
0x10008000
0x7ffffffc
0x00000000
$pc
$sp
$gp
Stack
Hohe
Adresse
Niedrige Ad
resse
$sp
$fp
Procedure‐Frame
SavedRegister
Lokale Variablen
UnbenutzerSpeicher
BenutzerSpeicher
Argument 5
Argument 6
Immediate‐Adressierung
Grundlagen der Rechnerarchitektur ‐ Assembler 137
Beispiel:
addi $s0, $s2, 42 # $s0 = $s2 + 42
(Instruktionstyp: I‐Typ)
Bildquelle: David A. Patterson und John L. Hennessy, „Computer Organization and Design“, Fourth Edition, 2012
Register‐Adressierung
Grundlagen der Rechnerarchitektur ‐ Assembler 138
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
Basis‐Adressierung
Grundlagen der Rechnerarchitektur ‐ Assembler 139
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
PC‐Relative‐Adressierung
Grundlagen der Rechnerarchitektur ‐ Assembler 140
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
Pseudodirekte Adressierung
Grundlagen der Rechnerarchitektur ‐ Assembler 141
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 John L. Hennessy, „Computer Organization and Design“, Fourth Edition, 2012
Eine Instruktion haben wir noch vergessen
Grundlagen der Rechnerarchitektur ‐ Assembler 142
nop # tue nichts
So das war‘s:li $v0,10syscall
Zusammenfassung und Literatur
Grundlagen der Rechnerarchitektur ‐ Assembler 143
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
Literatur[PattersonHennessy2012] David A. Patterson und John L. Hennessy, „Computer
Organization and Design“, Fourth Edition, 20122.1 Introduction2.2 Operations of the Computer Hardware2.3 Operands of the Computer Hardware2.5 Representing Instructions in the Computer2.7 Instructions for Making Decisions2.8 Supporting Procedures in Computer Hardware2.9 Communicating with People2.10 MIPS Addressing for 32‐Bit Immediates and Adresses2.11 Parallelism and Instructions: Synchronization4.9 ExceptionsB.1 IntroductionB.2 AssemblersB.5 Memory UsageB.6 Procedure Call ConventionB.7 Exceptions and InterruptsB.9 SPIMB.10 MIPS R2000 Assembly Language
Grundlagen der Rechnerarchitektur ‐ Assembler 145