Synchronisation - Uni Koblenz-Landauunikorn/lehre/gdra/ss14...Exception‐Code Registers Pending...

Synchronisation

Grundlagen der Rechnerarchitektur ‐ Assembler 91

Data‐Race


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



lw $t0, 0($s0) # lade x nach $t0addi $t0, $t0, 2 # $t0 = $t0 + 2sw $t0, 0($s0) # speichere $t0 nach x


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


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!




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


Variable x

Variable lock (initial=0)Prozessor 2: berechne x = x – 1


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





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



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


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.




loop: ll $t0, 0($s0) # $t0 = xaddi $t0, $t0, 2 # $t0 = $t0 + 2sc $t0, 0($s0) # x = $t0beq $t0, $zero, loop # nochmal bei failure


Variable x


loop: ll $t0, 0($s0) # $t0 = xaddi $t0, $t0, -1 # $t0 = $t0 – 1sc $t0, 0($s0) # x = $t0beq $t0, $zero, loop # nochmal bei failure




loop: ll $t0, 0($s0) # $t0 = xaddi $t0, $t0, 2 # $t0 = $t0 + 2sc $t0, 0($s0) # x = $t0beq $t0, $zero, loop # nochmal bei failure


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


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


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


Motivation: Behandlung von Overflows


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


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


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?



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



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?


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


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



40000014

Registers


...

# Ein fauler Exception-Handler0x80000180 : addi $s2,$zero,0# Problem gelöst0x80000184 : eret # Rücksprung


$pc zur Behandlung:

$pc nach Behandlung:

Weitere Exceptions während des Handlings?



40000014

Registers


...



$pc zur Behandlung:


Möglichkeiten, z.B.:• Exception‐Handler erzeugtselber eine Exception

• Anfrage eines IO‐Gerätes

Exceptions während des Handlings abgeschaltet




...



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




...



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




...

# Exception-Handler beginnt immer hier0x80000180 : ...0x80000184 : ...


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




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




...

# 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


$pc zur Behandlung:


Beachte: Register‐Satz‐Konvention: $k0 und $k1 sind für OS‐Funktionenreserviert. Behandeln vonExceptions ist eine OS‐Funktion.

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 = $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


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


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


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


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


Motivation für Pseudoinstruktionen


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


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


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


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)


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


MIPS R2000 CPU und Coprocessoren


CPU Coprocessor 1 (FPU)


$0...

$31

ArithmeticUnit

MultiplyDivide

$0...

$31

ArithmeticUnit

RegistersRegisters

Lo Hi


Memory

PCCondition‐

Flags

Alle Instruktionsformate


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


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


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


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


Kategorie MnemonicBranches blt, bltu

bgt, bgtuble, bleubge, bgeu

32‐Bit Immediate laden liRegister kopieren move

Speicherbelegungskonvention


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


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


Beispiel:

add $s0, $s2, $s4 # $s0 = $s2 + $s

(Instruktionstyp: R‐Typ)


Basis‐Adressierung


Beispiel:

lw $t0, 12($s0) # $t0 = Inhalt der Speicherstelle $s2+12

(Instruktionstyp: I‐Typ)


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)


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)


Eine Instruktion haben wir noch vergessen


nop # tue nichts

So das war‘s:li $v0,10syscall

Zusammenfassung und Literatur


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!


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


Synchronisation - Uni Koblenz-Landauunikorn/lehre/gdra/ss14...Exception‐Code Registers Pending...

Documents

Transcript of Synchronisation - Uni Koblenz-Landauunikorn/lehre/gdra/ss14...Exception‐Code Registers Pending...