Einführung in die Systemprogrammierung 01

Transkript

1 Einführung in die Systemprogrammierung 01 Prof. Dr. Christoph Reichenbach Fachbereich 12 / Institut für Informatik 24. April 2013

2 Administrativa Ab nächster Woche bitte Laptops in Übungen mitbringen OLAT-Paßwort ist mips Übungen werden montags morgens veröffentlicht Bearbeitungszeitlimit für Bonuspunkte: 12 Tage (Freitag Nachmittag, 17:00) Abgabe: Übungen Vorlesungen Sprechstunden Mein Fach im Direktorat, Robert-Mayer-Str

3 Daten-Repräsentation: Ganze Zahlen Wie repräsentieren wir ganze Zahlen (inklusive negativer Zahlen) im Speicher? Wie immer: Bitmuster!

4 Daten-Repräsentation: Ganze Zahlen Positive Zahlen: wie bisher Negative Zahlen: verschiedene Verfahren: Vorzeichen-Betrag Exzesscode Einerkomplement Zweierkomplement Negative Repräsentierungen verwenden logische Negation (neg bzw. ): b neg(b) Im Folgenden betrachten wir 8-Bit Zahlen. Die Konzepte funktionieren analog mit größeren n-bit Zahlen.

5 Vorzeichen-Betrag-Darstellung Beispiel Bitfolge repr( 5) = Betrag Vorzeichen Negation x: Oberstes Bit negieren Arithmetik: Benötigt Fallunterscheidung Zwei Nullen: , Zahlenraum: 2 n n 1 1 (symmetrisch)

6 Exzess-N-code-Darstellung Beispiel Bitfolge repr( 5) = = 123 = Hier: Exzess-128-Code (N = 128 = ) Negation x: 2N x Arithmetik: Benötigt Fallunterscheidung Eine Null: Zahlenraum: 2 n n 1 (asymmetrisch)

7 Einerkomplement-Darstellung Beispiel Bitfolge repr( 5) = neg(5) = neg( ) = Negation x: Alle Bits negieren Arithmetik: Ähnlich bei negativ/positiv Zwei Nullen: , Zahlenraum: 2 n n 1 (symmetrisch)

8 Zweierkomplement-Darstellung Beispiel Bitfolge repr( 5) = neg(5 1) = neg( ) = Negation x: Benötigt Fallunterscheidung Arithmetik: Positive/negative Zahlen sehr ähnlich, nur Vorzeichenerweiterung nötig Eine Null: Zahlenraum: 2 n n 1 (asymmetrisch) Einfache Arithmetik kleiner Prozessor

9 Zusammenfassung: Zahlen mit Vorzeichen Vorzeichen-Betrag: Vorzeichen-Bit repr( 1) = Exzess-N-code: +N (hier N = 128) repr( 1) = Einerkomplement: Negation repr( 1) = Zweierkomplement: Negation, +1 repr( 1) =

10 Kurze Geschichte der MIPS-Architektur 1984: MIPS Technologies gegründet 1985: MIPS R2000 (bis MHz) 1988: MIPS R3000 (bis 40 MHz), kommerziell erfolgreich 1992: Firma von SGI aufgekauft 1999: MIPS : Basis für Loongson-Prozessor 2012: Aktuellste MIPS-Prozessoren: MIPS32 microaptiv, interaptiv, proaptiv Eingebettete Systeme, Router, Android-Systeme, Allzweckrechner (Loongson)

11 Bedeutung der MIPS-Architektur RISC: Reduced Instruction Set Computing (Rechnen mit reduziertem Befehlssatz) Prozessoren vor MIPS: Komplexe Befehlssätze, oft für menschliche Programmierer gedacht Komplexer Prozessoraufbau (Mikroarchitektur) RISC ermöglicht mehrere Hardware-Optimierungen ( nächste Vorlesung) RISC verkleinerte Prozessoren Beschleunigung RISC-Idee aufgenommen von SPARC, DEC Alpha, PA-RISC, ARM, PowerPC Moderne x86-prozessoren verwenden intern RISC-Architektur

12 Einfacher Befehlssatz dank Übersetzern Programmrepräsentierungen und Werkzeuge Höhere Sprache Übersetzer/ Compiler Assembler Assemblersprache Maschinensprache

13 MIPS-Register Alle Register fassen 32 Bit (64 Bit bei Mips64) Registername(n) Bedeutung PC Programmzähler $0 Konstante 0 $1... $31 Allzweckregister HI, LO Divisions-/Multiplikationsergebnis Weitere Register in den Coprozessoren: Coprozessor 0: Verwaltung von Ausnahmen, Unterbrechungen, und Speicher Coprozessor 1 (optional): Fließkommaberechnung

14 MIPS-Hardware-Operationen Arithmetische und logische Operationen (add, ori,... ) Ladeoperationen Speicherzugriffsoperationen (lbu, sw,... ) Vergleichsoperationen Sprung- und Verzweigungsoperationen Systemoperationen Operationen auf Coprozessor 0 (Ausnahmen, Speicher) Operationen auf Coprozessor 1 (Fließkomma-Operationen)

15 Logische Operationen and or nor xor sll srl

16 Arithmetische Operationen Addition (add etc.) Subtraktion (sub etc.) Multiplikation (mul etc.) Division und Divisionsrest (div etc.) Verschiedene Implementierungsvarianten: Vorzeichenbehandlung Operanden Überlaufbehandlung Zielregister

17 Arithmetische Operationen: Operanden Register-Operanden add $x, $y, $z Beispiel: add $2, $2, $2 0x00 x y z 0x0 0x Maschinensprache: R-Format Für alle arithmetischen und logischen Operationen Direktoperand addi $x, $y, v Beispiel: addi $2, $3, 777 0x08 x z v Maschinensprache: I-Format Nur für addi, andi, ori, xori (und einige nicht-arithmethisch/logische Operationen)

18 Überlauf 32 Bit: Bit: A HI LO Option #1: 64 Bit-Wert aufteilen in Register HI, LO (z.b. mult, multu)

19 Überlauf A Ausgaberegister Option #2: Obere 32 Bit verwerfen (z.b. mul, addu)

20 Überlauf A Ausnahme nein = 0? ja Ausgaberegister ok Option #3: Ausnahme, falls obere 32 Bit 0 (z.b. add)

21 Arithmetische Operationen, Zusammenfassung Ganzzahl-Arithmetik: +,,, / Vorzeichen: Vorzeichenbehaftet: (div) Ohne Vorzeichen: (divu) Operanden: Registeroperanden: add $t1, $t2, $t3 Direktoperanden: addi $t1, $t2, 23 Überlaufverhalten: Ignoriert: (addu): FFFFFFFF Ausnahme: (add): FFFFFFFF + 2 Ausnahme Zielregister: Allzweckregister: mul $x, $y, $z HI und LO: 64-Bit Multiplikation/Division: mult $x, $y ; Obere 32 Bit in HI, untere in LO div $x, $y ; Rest in HI, Ergebnis in LO

22 Registerladeoperationen Obere 16 Bits direkt laden (untere 16 auf 0): lui $z, v HI- und LO-Register auslesen: mflo $z mfhi $z HI- und LO-Register beschreiben: mtlo $x mthi $x

23 Speicherzugriff [v + $x] Speicher:... E8 03 CD b C8... Mit Vorzeichen lb $z, v($x) Ohne Vorzeichen lbu $z, v($x) nein 00 < 0 FF ja $z = V V V b $z = b

24 Speicherbefehle Lesen: Befehl Name Ausr. B Vorzeichenerweiterung lb $z, v($x) load byte 8 1 ja lbu $z, v($x) load byte unsigned 8 1 nein lh $z, v($x) load halfword 16 2 ja lhu $z, v($x) load halfword unsigned 16 2 nein lw $z, v($x) load word 32 4 Schreiben: Befehl Name Ausrichtung Bytes sb $z, v($x) store byte 8 1 sh $z, v($x) store halfword 16 2 sw $z, v($x) store word 32 4

25 Sprung- und Verzweigungsbefehle Sprungbefehle ändern den Programmzähler steuern den Programmfluß Bezug zur theoretischen Informatik: Um Turing-vollständig zu sein ( Allzweckrechner ) benötigt ein Rechner: Sprungbefehle Bedingte Ausführung Indirekten Speicherzugriff (oder unendlich große Register)

26 Sprungbefehle Jeder dieser Befehle setzt den Programmzähler auf a, wenn die Bedingung wahr ist. Befehl Name Bedingung j a jump (keine) beq $x, $y, a branch if equal $x = $y bne $x, $y, a branch if not equal $x $y bltz $x, a branch if less than zero $x < 0 blez $x, a branch if less or equal to zero $x 0 bgtz $x, a branch if greater than zero $x > 0 bgez $x, a branch if greater or equal to zero $x 0

27 Sprungbefehle in Maschinensprache j ziel: 2 ziel 6 26 ziel: Absolute Adresse im Speicher Um zwei 0-Bits erweitert (Befehle 32-Bit ausgerichtet): PC := ziel 4 Kann noch nicht alle Adressen im Adreßraum anspringen (stattdessen ist u.u. der jr-befehl nötig) beq $x, $y, rziel: 4 $x $y rziel rziel: Relative Adresse im Speicher (Zweierkomplement) Um zwei 0-Bits erweitert: PC := PC + rziel 4

28 Sprungbefehle: Beispiel 0000: li $1, : li $2, Sprungmarken : eingabe $3 FC C: schleife: addi $1, $1, : beq $1, $3, fertig : mul $2, $2, $ : j schleife C: fertig: ausgabe $2 FC Relative Sprungmarke = 001C Absolute Sprungmarke = 000C Verweise auf Sprungmarken werden vom Assembler in relative oder absolute Adressen übersetzt.

29 Sprungbefehle: Beispiel li $1, 1 li $2, 1 eingabe $3 schleife: addi $1, $1, 1 beq $1, $3, fertig mul $2, $2, $1 j schleife fertig: ausgabe $2 Prozessor $0 = 0 $1 = 0 $2 = 0 $3 = 0

32 Sprungbefehle: Beispiel li $1, 1 li $2, 1 eingabe $3 schleife: addi $1, $1, 1 beq $1, $3, fertig mul $2, $2, $1 j schleife fertig: ausgabe $2 Eingabe: 4 Prozessor $0 = 0 $1 = 1 $2 = 1 $3 = 4

43 Sprungbefehle: Beispiel li $1, 1 li $2, 1 eingabe $3 schleife: addi $1, $1, 1 beq $1, $3, fertig mul $2, $2, $1 j schleife fertig: ausgabe $2 Prozessor $0 = 0 $1 = 4 $2 = 6 $3 = 4 Ausgabe: 6

44 Sprünge mit Registern Befehl Name Effekt jr $x jump to register PC := $x jal ziel jump and link $31 := PC + 4; PC := ziel jal springt und merkt sich Rücksprungadresse jr springt zu berechneter (z.b. von jal gespeicherter) Adresse $31 heißt auch $ra ( Rücksprungadresse bzw. return address)

45 Subroutinen mit jr und jal Hauptprogramm: jal eingabe... jal eingabe ausgabe $2 eingabe: lw $2, 1000($0) addi $2, 1 sw $2, 1000($0) eingabe $3 jr $ra eingabe markiert eine Subroutine jal eingabe ruft die Subroutine auf Die Subroutine hat folgende Auswirkungen: $3 wird eingelesen Das 32-Bit-Wort auf Adresse 1000 wird um 1 erhöht $2 wird auf den aktuellen Stand dieses Zählers gesetzt

46 Schwer zu merken: Welche Routinen verändert welche Registerinhalte wie? Aufrufkonventionen fakultaet: li $1, 1 li $2, 1 addi $3, $3, 1 schleife: addi $1, $1, 1 beq $1, $3, fertig mul $2, $2, $1 j schleife fertig: jr $ra Subroutine berechnet Fakultät von Wert in $3 Ergebnis in $2 Seiteneffekte: Inhalte von Registern $3 und $1 werden verändert

47 Subroutinen auf MIPS Größere Programme werden von mehreren Entwicklern gebaut, u.u. auch in verschiedenen Programmiersprachen Konventionen nötig, um Kommunikation zu erlauben Diese Konventionen geben an: Wo wird welcher Aufrufparameter abgelegt? In welche Register dürfen Subroutinen schreiben? Wo wird welcher Rückgabewert abgelegt? Auswirkungen: Registerkonventionen Speicherkonventionen Wer die Konventionen verletzt, riskiert schwer zu findende Programmfehler

48 Registerkonventionen Register Name Bedeutung Erhalten? $0 $zero Konstante 0 $1 $at Assembler-Hilfsregister nein $2 $3 $v0 $v1 Rückgabewerte nein $4 $7 $a0 $a3 Argumente (Parameter) nein $8 $15 $t0 $t7 Temporäre Register nein $16 $23 $s0 $s7 Gesicherte Register ja $24 $25 $t8 $t9 Temporäre Register nein $26 $27 $k0 $k1 Kernelregister nein $28 $gp Globaler Zeiger ja $29 $sp Stapelzeiger ja $30 $fp Rahmenzeiger ja $31 $ra Rücksprungadresse Erhaltene Register müssen beim Rücksprung von einer Subroutine den gleichen Zustand wie beim Einsprung haben.

49 Speicherkonventionen auf 32-Bit MIPS Betriebssystem verwendet Speicher von 0x xFFFFFFFF. Stapelspeicher (stack) per Konvention durch $sp begrenzt Ablagespeicher, von Systembibliotheken verwaltet (dynamische Allozierung) Statischer Speicher: Programmvariablen, mit gleicher Lebenszeit wie Gesamtprogramm Programmcode (text) ab 0x $fp $sp $gp Betriebssystem- Kern (Kernel), Gerätespeicher Stapelspeicher Ablagespeicher Statische Daten Programmcode

50 Der Stapelspeicher Per Konvention: Stapelspeicher speichert: Variablen von Subroutinen Parameter an Subroutinen $sp zeigt auf nach unten wachsenden Speicher $sp ist 64-Bit-ausgerichtet

51 Der Stapelspeicher: Beispiel Lokale Variablen: sub: addi $sp, $sp, -8 sw $s0, $sp(0) li $s0, lw $s0, $sp(0) addi $sp, 8 jr $ra $sp $sp Stapelspeicher Prozessor...? ? $s0 = CB33F5 $sp = 7FFF0A00 7FFF09F8

52 Der Stapelspeicher: Parameterübergabe Konvention: Für alle Parameter wird Platz auf dem Stapelspeicher alloziert Parameter 0 3 werden in Registern $a0-$a3 gespeichert Parameter ab 4 werden im Stapelspeicher gespeichert $sp Stapelspeicher... Param. 7 Param. 6 Param. 5 Param. 4 (Param. 3) (Param. 2) (Param. 1) (Param. 0)

53 MIPS-Speicher, Zusammenfassung Bereich unterhalb 0x für Anwendungen Speicheraufbau von oben nach unten: Stapelspeicher (wächst nach unten) ungenutzter Speicher Ablagespeicher (wächst nach oben) Statische Daten (konstante Größe) Programmcode (konstante Größe) Stapelspeicher nimmt lokale Variablen und Parameter auf $sp ist unteres Ende des Stapelspeichers $fp zeigt auf Aktivierungseintrag (Beginn der lokalen Variablen)

54 Subroutinen, Zusammenfassung Subroutinen werden mit jal (oder ähnlichen bedingten Sprüngen) aufgerufen Rücksprungadresse wird dabei in $ra abgelegt Parameter in $a0 $a3 und Stapelspeicher Rückgabewerte in $v0, $v1 Subroutinen müssen $s0 $s7, $fp, $sp, $gp erhalten Ablage von Variablen und Parametern im Stapelspeicher

55 Weitere MIPS-Operationen Pseudo-Operationen Coprozessor 0 Coprozessor 1 (Wir überspringen einige weniger wichtige Operationen.)

56 Pseudo-Operationen li $2, 0xABCD0123 ; Pseudoinstruktion wird vom Assembler überzetzt zu: lui $2, 0xABCD ori $2, $2, 0x0123 ; load upper immediate: Obere 16 Bits laden ; Bitweise-Oder fügt untere 16 Bits hinzu Einige Pseudo-Operationen benötigen Zwischenablagen, z.b.: blt $t0, $t1, ziel (springt gdw $t0 < $t1) muß erst Differenz zwischen $t0 und $t1 berechnen Register $at ist daher als Zwischenablage reserviert

57 Coprozessor 0 Speicherverwaltung Behandlung von Unterbrechungen und Ausnahmen: Unterbrechung (interrupt): Ein Eingabe- oder Ausgabegerät fordert Aufmerksamkeit Ausnahme (exception): Der Prozessor ist bei der Befehlsausführung auf eine ungewöhnliche Situation gestoßen: Unbekannter Befehl Arithmetischer Überlauf... Anfrage auf Systemdienst (syscall) 32 Spezialregister (nicht alle verwendet) Zugriff (nur durch Betriebssystemkern!) per: mtc0 $x, CP0Reg ; Lesen mfc0 $x, CP0Reg ; Schreiben

58 Systemdienste Betriebssystem hat Monopol auf Ein- und Ausgabegeräte Betriebssystemcode kann nur in privilegiertem Modus ( Kernel-Modus ) ausgeführt werden Privilegierter Modus (steuerbar durch Statusregister in CP0) erlaubt: Zugriff auf Register in Coprozessor 0 Zugriff auf Betriebssystemkernspeicher Zugriff auf Gerätespeicher Anwendungsprogramme können Betriebssystemkern um Dienstleistungen bitten: li $v0, Dienstleistungsnummer syscall

59 Systemdienste: Beispiele Diese Systemdienste werden von dem in den Übungen verwendeten SPIM-Simulator angeboten: $v0 Systemdienst 1 Zahl ausgeben: $a0 4 ASCII-Zeichenkette ausgeben: $a0 zeigt auf 0- terminierte Zeichenkette 5 Zahl einlesen: wird in $v0 gespeichert 8 ASCII-Zeichenkette einlesen: auf Adresse $a0, maximal $a1 Zeichen 10 SPIM-Simulator beenden

60 Behandlung von Unterbrechungen und Ausnahmen Bei einer Unterbrechung/Ausnahme reagiert der Prozessor wie folgt (in einem Schritt): Programmzähler wird in CP0-Register abgelegt (CP0 14) Prozessor sichert Statusregister und deaktiviert Hardwareunterbrechungen Grund für die Unterbrechung/Ausnahme wird in Register CP0 13 geschrieben Bei Speicherzugriffsfehlern: Fehleradresse wird gesichert System geht in Kernelmodus über System springt nach 0x Das Betriebssystem schreitet ein: Betriebssystemkern analysiert, behandelt Unterbrechung Betriebssystem führt eret-befehl aus: Programmzähler wird aus CP0 14 geladen Alter Status (Unterbrechungen, priv. Modus) wiederhergestellt

61 Coprozessor 1 Optionaler Zusatzprozessor (bei R2000, R3000) Hardware-Unterstützung für Fließkommazahlen: Basis-Arithmetik Quadratwurzel Zahlenkonvertierung / Rundung Bedingte Sprünge auf dem Zentralprozessor

62 MIPS-Hardware-Instruktionen, Zusammenfassung Alle Befehle als 32 Bit kodiert Befehle manipulieren die Register: 31 Allzweckregister, PC, HI, LO 32 CP0-Register für Systemverwaltung (nicht alle verwendbar!) CP1-Register für Fließkommazahlen Manche Befehle und Operationen nur in privilegiertem Modus ( Kernel-Modus ) erlaubt Drei Kodierungen für Befehle: R-Instruktionsformat: I-Instruktionsformat: J-Instruktionsformat: op $x $y $z fc op $x $y v op

63 Nächste Woche: Grundlagen der Performanz