Einführung in die Systemprogrammierung

Transkript

1 Einführung in die Systemprogrammierung Prof. Dr. Christoph Reichenbach Fachbereich 12 / Institut für Informatik 9. Juli 2015

2 Sprachen vs. Übersetzer Sprache C11 Übersetzer GNU C Compiler Intel C Compiler LLVM/Clang Sprachen können verschiedene Implementierungen haben: Übersetzer Interpreter Laufzeit-Übersetzer

3 Sprachen vs. Übersetzer Sprache C11 Übersetzer GNU C Compiler Intel C Compiler LLVM/Clang Sprachen können verschiedene Implementierungen haben: Übersetzer Interpreter Laufzeit-Übersetzer Sprachdefinition vereinigt Sprachimplementierungen

4 Die Struktur von Programmiersprachen Sprachdefinition gibt an: Lexikalische Sprachstruktur (Lexeme/Tokens) Grammatische Sprachstruktur (Syntax) Sprachsemantik: Statische Semantik Semantik der Namen: Welcher Name bindet an welche Definition? Semantik der Typen: Welche Typen können wie miteinander verknüpft werden? Dynamische Semantik Laufzeitverhalten des Programmes Beinhaltet meist: Reihenfolge und Inhalt von Ein- und Ausgaben Beinhaltet meist nicht: Ausführungsgeschwindigkeit, benötigter Speicherplatz Optimierungen müssen Sprachsemantik erhalten!

5 Der Übersetzer C-Programm Frontend Middle-End Backend Optimierung Assembler-Code

6 Der Übersetzer C-Programm Frontend Middle-End Backend Optimierung Assembler-Code

7 Der Übersetzer C-Programm Frontend Lexikalische Analyse Syntaxanalyse Namensanalyse Typüberprüfung Zwischenform Middle-End Optimierung Backend Fehlermeldungen Assembler-Code

8 Der Übersetzer C-Programm Frontend Lexikalische Analyse Syntaxanalyse Namensanalyse Typüberprüfung Zwischenform Middle-End Optimierung Backend Fehlermeldungen Assembler-Code

9 Der Übersetzer C-Programm Frontend Lexikalische Analyse Syntaxanalyse Namensanalyse Typüberprüfung Zwischenform Middle-End Optimierung Backend Registerauswahl Befehlsauswahl Codeerzeugung Fehlermeldungen Assembler-Code

10 Der Übersetzer: Frontend: Lexikalische Analyse Eingabe: { int x = L; char *c = x;

11 Der Übersetzer: Frontend: Lexikalische Analyse Eingabe: { int x = L; char *c = x; Lexikalische Analyse zerlegt Eingabe in Tokens/Lexeme Erzeugt vom Lexer (Tokenizer, Scanner) Ignoriert Leerzeichen, Zeilenumbrüche etc. (in C und C-artigen Sprachen)

12 Der Übersetzer: Frontend: Lexikalische Analyse Eingabe: { int x = L; char *c = x; Lexikalische Analyse zerlegt Eingabe in Tokens/Lexeme Erzeugt vom Lexer (Tokenizer, Scanner) Ignoriert Leerzeichen, Zeilenumbrüche etc. (in C und C-artigen Sprachen) Tokens und Lexeme: punctuator { int int identifier x punctuator = constant 17 punctuator + constant 3 long-suffix L punctuator ; char char punctuator * identifier c punctuator = identifier x punctuator ; punctuator

13 Der Übersetzer: Frontend: Parser { int x = L ; { int x = L; char *c = x; char * c = x ;

14 Der Übersetzer: Frontend: Parser declaration type-specifier declarator { int x = L ; { int x = L; char *c = x; char * c = x ;

15 Der Übersetzer: Frontend: Parser declaration initializer type-specifier declarator int-constant int-constant { int x = L ; { int x = L; char *c = x; char * c = x ;

16 Der Übersetzer: Frontend: Parser declaration initializer type-specifier declarator int-constant int-constant { int x = L ; { int x = L; char *c = x; declaration type-specifier declarator initializer char * c = x ;

17 Der Übersetzer: Frontend: Parser declaration compound-statement initializer type-specifier declarator int-constant int-constant { int x = L ; { int x = L; char *c = x; declaration type-specifier declarator initializer char * c = x ;

18 Der Übersetzer: Frontend: Parser declaration compound-statement initializer type-specifier declarator int-constant int-constant { int x = L ; { int x = L; char *c = x; declaration type-specifier declarator initializer char * c = x ; Parser erzeugt AST (Abstract Syntax Tree)

19 Frontend: Namensanalyse declaration compound-statement initializer type-specifier declarator int-constant int-constant int x L declaration type-specifier char declarator * c initializer x

20 Frontend: Namensanalyse declaration compound-statement initializer type-specifier declarator int-constant int-constant int x L declaration type-specifier char declarator * c initializer x Verwendungen von Namen werden an ihre Definitionen gebunden

21 Frontend: Typanalyse (1/2) declaration compound-statement initializer type-specifier int declarator x int int-constant int 17 + int-constant long 3 L declaration type-specifier char declarator * c char* initializer x int

22 Frontend: Typanalyse (1/2) declaration compound-statement initializer type-specifier int declarator x int int-constant int 17 + int-constant long 3 L declaration type-specifier char declarator * c char* initializer x int Typen werden an Namen gebunden

23 Frontend: Typanalyse (2/2) declaration compound-statement initializer type-specifier int declarator x int int-constant int 17 + int-constant long 3 L Γ τ(declarator) declaration = τ(initializer) type-specifier char declarator * c char* initializer x int

24 Frontend: Typanalyse (2/2) declaration compound-statement initializer type-specifier int declarator x int int-constant int-constant int long L Γ τ(declarator) declaration = τ(initializer) type-specifier Typfehler: char* int declarator initializer char * c char* x int Typregeln erzwingen Typkorrektheit

25 Der Übersetzer: Middle-End Frontend erzeugt Zwischenform des Programmes

26 Der Übersetzer: Middle-End Frontend erzeugt Zwischenform des Programmes Zwischenform hilft bei Programmanalyse: Welche Programmteile hängen voneinander ab? (Kontrollfluß/Daten) Welche Programmteile benötigen welche Ressourcen?

27 Der Übersetzer: Middle-End Frontend erzeugt Zwischenform des Programmes Zwischenform hilft bei Programmanalyse: Welche Programmteile hängen voneinander ab? (Kontrollfluß/Daten) Welche Programmteile benötigen welche Ressourcen? Middle-End optimiert Programmrepräsentierung Optimierte Zwischenform geht an Backend

28 Der Übersetzer: Optimierungen Optimierung = Programmanalyse a + Transformation t Gegeben Programm p. Falls a(p): Ergebnis von p = Ergebnis von t(p)

29 Der Übersetzer: Optimierungen Optimierung = Programmanalyse a + Transformation t Gegeben Programm p. Falls a(p): Ergebnis von p = Ergebnis von t(p) Beispiel: a[0] = 0; // A0 a[1] = a[0] ; // A1 f(); a[2] = a[0] ; // A2

30 Der Übersetzer: Optimierungen Optimierung = Programmanalyse a + Transformation t Gegeben Programm p. Falls a(p): Ergebnis von p = Ergebnis von t(p) Beispiel: a[0] = 0; // A0 a[1] = a[0] ; // A1 f(); a[2] = a[0] ; // A2 A1 auf a[1] = 0 änderbar Korrekte Programmanalysen sind konservativ: Wenn ich nicht weiß, ob ich darf, darf ich nicht

31 Der Übersetzer: Optimierungen Optimierung = Programmanalyse a + Transformation t Gegeben Programm p. Falls a(p): Ergebnis von p = Ergebnis von t(p) Beispiel: a[0] = 0; // A0 a[1] = a[0] ; // A1 f(); a[2] = a[0] ; // A2 A1 auf a[1] = 0 änderbar A2 nur auf a[2] = 0 änderbar, wenn f() nicht nach a[0] schreibt Korrekte Programmanalysen sind konservativ: Wenn ich nicht weiß, ob ich darf, darf ich nicht

32 Der Übersetzer: Backend Backend erzeugt Assembler- oder Maschinencode Unterstützt oft verschiedene Prozessoren und Aufrufkonventionen Wesentliche Aufgaben:

33 Der Übersetzer: Backend Backend erzeugt Assembler- oder Maschinencode Unterstützt oft verschiedene Prozessoren und Aufrufkonventionen Wesentliche Aufgaben: Registerauswahl: Welche Variablen in welche Register? (gesichert, temporär, Spezialregister) Andere Variablen in den Stapelspeicher

34 Der Übersetzer: Backend Backend erzeugt Assembler- oder Maschinencode Unterstützt oft verschiedene Prozessoren und Aufrufkonventionen Wesentliche Aufgaben: Registerauswahl: Welche Variablen in welche Register? (gesichert, temporär, Spezialregister) Andere Variablen in den Stapelspeicher Befehlsauswahl: Effiziente Befehle suchen, um Ausdrücke abzubilden (Direkt-Operation, Register-Operation usw.)

35 Der Übersetzer: Backend Backend erzeugt Assembler- oder Maschinencode Unterstützt oft verschiedene Prozessoren und Aufrufkonventionen Wesentliche Aufgaben: Registerauswahl: Welche Variablen in welche Register? (gesichert, temporär, Spezialregister) Andere Variablen in den Stapelspeicher Befehlsauswahl: Effiziente Befehle suchen, um Ausdrücke abzubilden (Direkt-Operation, Register-Operation usw.) Architekturspezifische Optimierungen

36 Zusammenfassung: Der Übersetzer Drei Übersetzerphasen: Frontend liest Programm ein Typanalyse und Fehlersuche Erzeugt Zwischenrepräsentation Middle-End optimiert Zwischenrepräsentation Kann übersprungen werden (schnelle Übersetzung, langsamer Code) Backend bildet Zwischenrepräsentation auf Assembler/Maschinencode ab Evtl. kleinere maschinenspezifische Optimierungen

37 Qualifizierer in C extern int sprintf(char * restrict s, const char * restrict format,...);

38 Qualifizierer in C extern int sprintf(char * restrict s, const char * restrict format,...); Typen in C können qualifiziert werden Qualifizierer wie const sind Schlüsselwörter, die als Teil von Typspezifikationen angegeben werden Geben Hinweise auf geplante Verwendung von Variablen und Funktionen Wirkung: Einfluß auf Programmoptimierung: Helfen oder blockieren Programmanalysen für Optimierungen Einfluß auf Semantik: Typanalyse kann Fehler markieren, wenn Hinweise auf Verwendung der tatsächlichen Verwendung widersprechen

39 Übersicht: Qualifizierer const Stellt sicher, daß Wert nicht verändert werden kann Erlaubt zusätzliche Optimierungen inline Erbittet Einbetten ( inlining ) von Funktionskörpern in Aufrufer Kann u.u. Programm beschleunigen restrict (auf Zeiger) Verspricht, daß kein aliasing stattfinded Erleichtert Zwischenspeichern von Werten Kann u.u. Programm beschleunigen volatile Zwingt Übersetzer, Variable im Speicher zu halten Einsatzgebiete: Gerätetreiber, nicht-lokaler Kontrollfluß

40 Qualifizierer: const Variablen, die nach Initialisierung nicht beschrieben werden, sind Konstanten Qualifizierer const const int i = v + 1; Eigenschaft wird von Typüberprüfung erzwungen: Versuchte Zuweisung ist Programmfehler const int x = 5; int f(int y) { return x * y;

41 Qualifizierer: const Variablen, die nach Initialisierung nicht beschrieben werden, sind Konstanten Qualifizierer const const int i = v + 1; Eigenschaft wird von Typüberprüfung erzwungen: Versuchte Zuweisung ist Programmfehler const int x = 5; int f(int y) { return x * y; // Mit Konstante int f(int y) { return 5 * y;

42 Qualifizierer: const C-Quellcode const int x = 5; int f(int y) { return x * y; const ermöglicht Optimierungen im Übersetzer

43 Qualifizierer: const C-Quellcode const int x = 5; int f(int y) { return x * y; mit const: f:sll $v0, $a0, 2 jr $ra addu $v0, $v0, $a0 const ermöglicht Optimierungen im Übersetzer

44 Qualifizierer: const C-Quellcode const int x = 5; int f(int y) { return x * y; mit const: f:sll $v0, $a0, 2 jr $ra addu $v0, $v0, $a0 ohne const: f:lw $v0, x($gp) nop mult $a0, $v0 mflo $v0 jr $ra nop const ermöglicht Optimierungen im Übersetzer

45 Qualifizierer: const C-Quellcode const int x = 5; int f(int y) { return x * y; mit const: Mit const: effizienter Ohne const: generischer f:sll $v0, $a0, 2 jr $ra addu $v0, $v0, $a0 ohne const: f:lw $v0, x($gp) nop mult $a0, $v0 mflo $v0 jr $ra nop const ermöglicht Optimierungen im Übersetzer

46 Qualifizierer: const und Zeiger Zwei relevante Zugriffsrechte für int *p: p += 1: Zeigerarithmetik *p += 1: Inhalt der referenzierten Speicherstelle erhöhen Optionen: int *p Wir dürfen sowohl p als auch *p modifizieren

47 Qualifizierer: const und Zeiger Zwei relevante Zugriffsrechte für int *p: p += 1: Zeigerarithmetik *p += 1: Inhalt der referenzierten Speicherstelle erhöhen Optionen: int *p Wir dürfen sowohl p als auch *p modifizieren const int *p int const *p Wir dürfen *p modifizieren, aber nicht p

48 Qualifizierer: const und Zeiger Zwei relevante Zugriffsrechte für int *p: p += 1: Zeigerarithmetik *p += 1: Inhalt der referenzierten Speicherstelle erhöhen Optionen: int *p Wir dürfen sowohl p als auch *p modifizieren const int *p int const *p Wir dürfen *p modifizieren, aber nicht p int * const p Wir dürfen p modifizieren, aber nicht *p

49 Qualifizierer: const und Zeiger Zwei relevante Zugriffsrechte für int *p: p += 1: Zeigerarithmetik *p += 1: Inhalt der referenzierten Speicherstelle erhöhen Optionen: int *p Wir dürfen sowohl p als auch *p modifizieren const int *p int const *p Wir dürfen *p modifizieren, aber nicht p int * const p Wir dürfen p modifizieren, aber nicht *p const int * const p int const * const p Wir dürfen weder p noch *p modifizieren

50 Qualifizierer: inline Funktionsaufrufe können hohe Kosten haben: Stapelspeicher beschreiben Registerwahl einschränken Stapelspeicher lesen Inlining ist Optimierung, die Funktionskörper einbettet: int f(int x) { return 2 + x; void g(int argc, int *args) { for (int i = 0; i < argc; i++) args[i] = f(args[i]);

51 Qualifizierer: inline Funktionsaufrufe können hohe Kosten haben: Stapelspeicher beschreiben Registerwahl einschränken Stapelspeicher lesen Inlining ist Optimierung, die Funktionskörper einbettet: int f(int x) { return 2 + x; void g(int argc, int *args) { for (int i = 0; i < argc; i++) args[i] = f(args[i]); // Mit Inlining void g(int argc, int *args) { for (int i = 0; i < argc; i++) args[i] = 2 + (args[i]);

52 Qualifizierer: ohne inline int f(int x) { return 2 + x; void g(int argc, int *args) { for (int i = 0; i < argc; i++) { args[i] = f(args[i]);

53 Qualifizierer: ohne inline int f(int x) { return 2 + x; void g(int argc, int *args) { for (int i = 0; i < argc; i++) { args[i] = f(args[i]); g: addiu $sp, $sp, -40 sw $ra, $s0-$s3...($sp) move $s2, $a0 blez $a0, L6 move $s3, $a1 move $s1, $zero L5:sll $s0, $s1, 2 addu $s0, $s3, $s0 lw $a0, 0($s0) jal f addiu $s1, $s1, 1 slt $v1, $s1, $s2 bne $v1, $zero, L5 sw $v0, 0($s0) L6:lw $ra, $s0-$s3...($sp) jr $ra addiu $sp, $sp, 40

54 Qualifizierer: mit inline inline int f(int x) { return 2 + x; void g(int argc, int *args) { for (int i = 0; i < argc; i++) { args[i] = f(args[i]);

55 Qualifizierer: mit inline inline int f(int x) { return 2 + x; void g(int argc, int *args) { for (int i = 0; i < argc; i++) { args[i] = f(args[i]); g: blez $a0, L9 move $a3, $a0 move $a2, $zero L5:sll $v0, $a2, 2 addu $v0, $a1, $v0 lw $v1, 0($v0) addiu $a2, $a2, 1 addiu $v1, $v1, 2 slt $a0, $a2, $a3 bne $a0, $zero, L5 sw $v1, 0($v0) L9:jr $ra nop

56 Qualifizierer: mit inline inline int f(int x) { return 2 + x; void g(int argc, int *args) { for (int i = 0; i < argc; i++) { args[i] = f(args[i]); g: blez $a0, L9 move $a3, $a0 move $a2, $zero L5:sll $v0, $a2, 2 addu $v0, $a1, $v0 lw $v1, 0($v0) addiu $a2, $a2, 1 addiu $v1, $v1, 2 slt $a0, $a2, $a3 bne $a0, $zero, L5 sw $v1, 0($v0) L9:jr $ra nop Kein expliziter f-aufruf Stapelspeicherverwaltung unnötig

57 Inlining in der Praxis Inlining ist eine der wichtigsten Optimierungen Übersetzer inlininen meist heuristisch: Funktionen mit kleinem Funktionskörper (kleiner als Inlining-Schwelle) (C, C++) Funktionen, die als Funktionszeiger übergeben werden (OCaml) Funktionen, die häufig von der gleichen Stelle aufgerufen werden (Java)

58 Inlining in der Praxis Inlining ist eine der wichtigsten Optimierungen Übersetzer inlininen meist heuristisch: Funktionen mit kleinem Funktionskörper (kleiner als Inlining-Schwelle) (C, C++) Funktionen, die als Funktionszeiger übergeben werden (OCaml) Funktionen, die häufig von der gleichen Stelle aufgerufen werden (Java) C : Exakte Bedeutung von inline ist implementierungsabhängig gcc: Der inline-qualifizierer erhöht die Inlining-Schwelle für diese Funktion

59 Inlining in der Praxis Inlining ist eine der wichtigsten Optimierungen Übersetzer inlininen meist heuristisch: Funktionen mit kleinem Funktionskörper (kleiner als Inlining-Schwelle) (C, C++) Funktionen, die als Funktionszeiger übergeben werden (OCaml) Funktionen, die häufig von der gleichen Stelle aufgerufen werden (Java) C : Exakte Bedeutung von inline ist implementierungsabhängig gcc: Der inline-qualifizierer erhöht die Inlining-Schwelle für diese Funktion Meist ist explizites inline nicht nötig

60 Qualifizierer: restrict int maxsum(int *summe, int *a, int len) { *summe = 0; int max = 0; while (len--) { *summe += a[len]; if (a[len] > max) max = a[len]; return max; Eingabe: Array a mit len Elementen Berechnet: *summe = a[0] a[len-1] return max(a[0]... a[len-1])

61 Qualifizierer: ohne restrict int maxsum(int *summe, int *a, int len) { *summe = 0; int max = 0; while (len--) { *summe += a[len]; //A1 if (a[len] > max) //A2 max = a[len]; //A3 return max; sw $zero, 0($a0) beq $a2, $zero, L5 addiu $v1, $a2, -1 move $a2, $zero move $v0, $zero L4:sll $a3, $v1, 2 addu $a3, $a1, $a3 lw $t0, 0($a3) # lade a[len] nop addu $a2, $a2, $t0 sw $a2, 0($a0) # schreibe *summe lw $a3, 0($a3) # lade a[len] nop slt $t0, $v0, $a3 beq $t0, $zero, L3 addiu $t1, $v1, -1 move $v0, $a3 L3:bne $v1, $zero, L4 move $v1, $t1 jr $ra nop L5:jr $ra move $v0, $zero

62 Qualifizierer: restrict int maxsum(int *summe, int *a, int len) { *summe = 0; int max = 0; while (len--) { *summe += a[len]; //A1 if (a[len] > max) //A2 max = a[len]; //A3 return max; Was, wenn summe in *a zeigt? aliasing: Mehrere Zeiger zeigen auf gleiches Objekt int a[3]; int x = maxsum(&a[1], a, 3); a = summe summe ist Alias von (a+1) Bestimmte Optimierungen werden durch konservative Annahmen des Übersetzers verhindert

63 Qualifizierer: ohne restrict int maxsum(int *summe, int *a, int len) { *summe = 0; int max = 0; while (len--) { *summe += a[len]; //A1 if (a[len] > max) //A2 max = a[len]; //A3 return max; sw $zero, 0($a0) beq $a2, $zero, L5 addiu $v1, $a2, -1 move $a2, $zero move $v0, $zero L4:sll $a3, $v1, 2 addu $a3, $a1, $a3 lw $t0, 0($a3) # lade a[len] nop addu $a2, $a2, $t0 sw $a2, 0($a0) # schreibe *summe lw $a3, 0($a3) # lade a[len] nop slt $t0, $v0, $a3 beq $t0, $zero, L3 addiu $t1, $v1, -1 move $v0, $a3 L3:bne $v1, $zero, L4 move $v1, $t1 jr $ra nop L5:jr $ra move $v0, $zero

64 Qualifizierer: mit restrict int maxsum(int * restrict summe, int * restrict a, int len) { *summe = 0; int max = 0; while (len--) { *summe += a[len]; if (a[len] > max) max = a[len]; return max;

65 Qualifizierer: mit restrict int maxsum(int * restrict summe, int * restrict a, int len) { *summe = 0; int max = 0; while (len--) { *summe += a[len]; if (a[len] > max) max = a[len]; return max; sw $zero, 0($a0) beq $a2, $zero, L5 addiu $v1, $a2, -1 move $a3, $zero move $v0, $zero L4:sll $a2, $v1, 2 addu $a2, $a1, $a2 lw $a2, 0($a2) # lade a[len] addiu $t1, $v1, -1 addu $a3, $a3, $a2 # 1 lw, 2 nop entfernt slt $t0, $v0, $a2 beq $t0, $zero, L3 sw $a3, 0($a0) # schreibe *summe move $v0, $a2 L3:bne $v1, $zero, L4 move $v1, $t1 jr $ra nop L5:jr $ra move $v0, $zero

66 Qualifizierer: restrict restrict verspricht, daß Aliasing unmöglich ist

67 Qualifizierer: restrict restrict verspricht, daß Aliasing unmöglich ist Compilerannahme: Aliasing zwischen Zeigern τ *a und τ *b möglich: a restrict a b ja ja restrict b ja nein

68 Qualifizierer: restrict restrict verspricht, daß Aliasing unmöglich ist Compilerannahme: Aliasing zwischen Zeigern τ *a und τ *b möglich: a restrict a b ja ja restrict b ja nein Kein Aliasing: Von Zeigern geladene Werte können länger in Registern zwischengespeichert werden... = *a; // *a lesen *b = z; // *b schreiben... = *a; // *a zwischengespeichert gdw restrict a und b

69 Qualifizierer: volatile Optimierer darf normalerweise: Variablen in Register legen Speicherzugriffreihenfolge umordnen Beide Änderungen haben normalerweise keine Auswirkung auf das sichtbare Programmverhalten

70 Qualifizierer: volatile Optimierer darf normalerweise: Variablen in Register legen Speicherzugriffreihenfolge umordnen Beide Änderungen haben normalerweise keine Auswirkung auf das sichtbare Programmverhalten Problematisch für: Gerätetreiber: Speicheradressen auf Geräteregister abgebildet Zugriffreihenfolge gemäß Hardwareprotokoll Plötzliche Sprünge (Ausnahmebehandlung): Registerinhalte gehen verloren

71 Qualifizierer: volatile volatile: Variable wird nicht in Registern gesichert Reihenfolge der volatile-zugriffe wird immer beibehalten int c; volatile int va, vb; va = 0; c = 1; vb = 2; // nach va

72 Qualifizierer: volatile volatile: Variable wird nicht in Registern gesichert Reihenfolge der volatile-zugriffe wird immer beibehalten int c; volatile int va, vb; va = 0; c = 1; vb = 2; // nach va Mögliche Schreibreihenfolgen va = 0; c = 1; va = 0; c = 1; va = 0; vb = 2; vb = 2; vb = 2; c = 1;

73 Qualifizierer: volatile volatile: Variable wird nicht in Registern gesichert Reihenfolge der volatile-zugriffe wird immer beibehalten int c; volatile int va, vb; va = 0; c = 1; vb = 2; // nach va Mögliche Schreibreihenfolgen va = 0; c = 1; va = 0; c = 1; va = 0; vb = 2; vb = 2; vb = 2; c = 1; Vorsicht: volatile alleine reicht nicht, um nebenläufige Prozesse zu synchronisieren

74 Automatische Optimierungen Übersetzer können viele Arten von Optimierungen durchführen: Inlining Auswertung konstanter Ausdrücke Rückhaltung von Speicherinhalten...

75 Automatische Optimierungen Übersetzer können viele Arten von Optimierungen durchführen: Inlining Auswertung konstanter Ausdrücke Rückhaltung von Speicherinhalten... Programmierer müssen sich nicht um Optimierungen kümmern, die der Übersetzer durchführen kann

76 Grundlegende Optimierungen Konstantenfaltung (constant folding) Konstantenpropagierung (constant propagation) Eliminierung gemeinsamer Teilausdrücke (common subexpression elimination) Eliminierung von totem Code (dead code elimination) Schleifeninvariante Codeverschiebung (loop-invariant code motion)

77 Konstantenfaltung Vor Optimierung: int x = 3 + 7;

78 Konstantenfaltung Vor Optimierung: int x = 3 + 7; Nach Optimierung: int x = 10; Berechnungen über Konstanten werden ausgewertet

79 Konstantenpropagierung Vor Optimierung: int x = 7;... // x wird nicht verändert for (int i = 0; i < x; i++) {... // x wird nicht verändert

80 Konstantenpropagierung Vor Optimierung: int x = 7;... // x wird nicht verändert for (int i = 0; i < x; i++) {... // x wird nicht verändert Nach Optimierung: int x = 7;... for (int i = 0; i < 7; i++) {... Variablen mit konstantem Inhalt werden substituiert

81 Eliminierung gemeinsamer Teilausdrücke Vor Optimierung: int x = v * v + 17; int y = v * v + 23;

82 Eliminierung gemeinsamer Teilausdrücke Vor Optimierung: int x = v * v + 17; int y = v * v + 23; Nach Optimierung: const int v2 = v * v; int x = v2 + 17; int y = v2 + 23; Mehrfach hintereinander verwendete Teilausdrücke werden extrahiert und vorberechnet

83 Eliminierung von totem Code Vor Optimierung: char *s = "C99 oder neuer"; if ( STDC_VERSION < L) { s = "vor C99";

84 Eliminierung von totem Code Vor Optimierung: char *s = "C99 oder neuer"; if ( STDC_VERSION < L) { s = "vor C99"; Nach Optimierung: char *s = "C99 oder neuer"; // Eliminiert Blöcke mit nicht erfüllbaren Vorbedingungen werden entfernt

85 Abhängigkeiten zwischen Optimierungen Optimierungen beeinflussen sich gegenseitig: Eliminierung von totem Code muß Bedingungen auswerten: Abhängigkeit: Konstantenfaltung / Konstantenpropagierung Konstantenfaltung muß Konstanten sehen: Abhängigkeit: Konstantenpropagierung Konstantenpropagierung muß wissen, daß Ausdrücke konstant sind: Abhängigkeit: Eliminierung von totem Code (De)aktivierung einer Optimierung kann andere Optimierungen indirekt beeinflussen

86 Schleifeninvariante Codeverschiebung Vor Optimierung: for (int i = 0; i <= 1000; i++) { int v = p * p; a[i] += v;

87 Schleifeninvariante Codeverschiebung Vor Optimierung: for (int i = 0; i <= 1000; i++) { int v = p * p; a[i] += v; Nach Optimierung: int v = p * p; for (int i = 0; i <= 1000; i++) { a[i] += v; Berechnungen, die in jedem Schleifenschritt das gleiche Ergebnis produzieren, werden vor die Schleife geschoben

88 Komplexe Optimierungen Schleifenteilung (loop splitting) Schleifenabwicklung (loop unrolling) Schleifenfusion (loop fusion) Stärkereduktion (strength reduction) Stapel-inlining (stack inlining) Inlining

89 Schleifenteilung Vor Optimierung: int v = 1; for (int i = 0; i <= 1000; i++) { a[i] += v; v = p * p; //A v ist nicht schleifen-invariant: A kann nicht verschoben werden

90 Schleifenteilung Vor Optimierung: int v = 1; for (int i = 0; i <= 1000; i++) { a[i] += v; v = p * p; //A v ist nicht schleifen-invariant: A kann nicht verschoben werden Nach Optimierung: int v = 1; for (int i = 0; i == 0; i++) { a[i] += v; v = p * p; //A for (int i = 1; i <= 1000; i++) { a[i] += v; v = p * p; //A Schleifen werden in Teilschleifen aufgespalten, um weitere Optimierungen zu erlauben (hier: Verschieben von A)

91 Schleifenabwicklung (1/2) Vor Optimierung: for (int i = 0; i < 4; i++) { a[i] += i; Nach Optimierung:

92 Schleifenabwicklung (1/2) Vor Optimierung: for (int i = 0; i < 4; i++) { a[i] += i; Nach Optimierung: a[0] += 0; a[1] += 1; a[2] += 2; a[3] += 3; Schleifenkörper wird kopiert, um Vergleiche/Sprünge zu sparen und weitere Optimierungen zu ermöglichen

93 Schleifenabwicklung (2/2) Vor Optimierung: for (int i = 0; i < 4000; i++) { a[i] += i;

94 Schleifenabwicklung (2/2) Vor Optimierung: for (int i = 0; i < 4000; i++) { a[i] += i; Nach Optimierung: for (int i = 0; i < 4000; i+=4) { a[i] += i; a[i+1] += i+1; a[i+2] += i+2; a[i+3] += i+3; Partielle Schleifenabwicklung für lange Schleifen, insbesondere zusammen mit Schleifenteilung

95 Schleifenfusion Vor Optimierung: for (int i = 0; i < 4000; i++) { a[i] += i; for (int i = 0; i < 4000; i++) { b[i] += a[i];

96 Schleifenfusion Vor Optimierung: for (int i = 0; i < 4000; i++) { a[i] += i; for (int i = 0; i < 4000; i++) { b[i] += a[i]; Nach Optimierung: for (int i = 0; i < 4000; i++) { a[i] += i; // Zusammengefuegt b[i] += a[i]; Schleifenkörper, die über die gleichen Daten iterieren, werden zusammengefügt

97 Stärkereduktion Vor Optimierung: for (int i = 0; i < 1000; i++) { a[i * 13] = 0;

98 Stärkereduktion Vor Optimierung: for (int i = 0; i < 1000; i++) { a[i * 13] = 0; Nach Optimierung: int i13 = 0; for (int i = 0; i < 1000; i++) { a[ i13] = 0; i13 += 13; Ersetze teure Operationen in Schleife durch billigere inkrementelle Operationen

99 Stapel-Inlining Vor Optimierung: int *a = (int *) malloc(sizeof(int) * 4); lies_daten(a); int i = a[0] + a[3]; free(a);

100 Stapel-Inlining Vor Optimierung: int *a = (int *) malloc(sizeof(int) * 4); lies_daten(a); int i = a[0] + a[3]; free(a); Nach Optimierung: int a[4]; lies_daten(a); int i = a[0] + a[3];

101 Stapel-Inlining Vor Optimierung: int *a = (int *) malloc(sizeof(int) * 4); lies_daten(a); int i = a[0] + a[3]; free(a); Nach Optimierung: int a[4]; lies_daten(a); int i = a[0] + a[3]; Einschränkung: Allozierung muß klein sein, wenn Stapelspeicher beschränkt ist

102 Stapel-Inlining Vor Optimierung: int *a = (int *) malloc(sizeof(int) * 4); lies_daten(a); int i = a[0] + a[3]; free(a); Nach Optimierung: int a[4]; lies_daten(a); int i = a[0] + a[3]; Einschränkung: Allozierung muß klein sein, wenn Stapelspeicher beschränkt ist Allozierung auf Ablagespeicher wird in Allozierung auf Stapelspeicher umgewandelt

103 Zusammenfassung: Optimierungen (1/2) Konstantenfaltung: Berechnungen auf Konstanten werden fertiggerechnet Konstantenpropagierung: Konstante Variablen werden substituiert Eliminierung gemeinsamer Teilausdrücke: Mehrfach verwendete Teilausdrücke werden extrahiert, nur ein Mal berechnet Eliminierung von totem Code: Nicht ausführbare Programmteile werden gelöscht Schleifeninvariante Codeverschiebung: Unveränderliche Berechnungen in Schleifen werden aus Schleife gehoben

104 Zusammenfassung: Optimierungen (2/2) Schleifenteilung: Schleife wird in mehrere Schleifen gespalten Schleifenabwicklung: Mehrere Kopien des Schleifenkörpers werden ausgeführt Schleifenfusion: Schleifen über gleiche Daten werden zusammengeklebt Stärkereduktion: Berechnungen mit teuren Operationen in Schleifen werden mit billigeren Operationen inkrementalisiert Stapel-inlining: malloc wird auf den Stapelspeicher verlegt Inlining: Funktionskörper werden in Aufrufstelle kopiert

105 Die Grenzen von Optimierungen Einschränkungen der Implementierung Fehlende Unterstützung Berechenbarkeit Programmgleicheit ist unentscheidbar Sprachsemantik Programmverhalten muß Sprachspezifikation entsprechen Überspezifizierung Programmierer-Spezifikation schränkt Optimierer unnötig ein Beschränktes Wissen Übersetzer sieht nicht genug Informationen

106 Optimierungsgrenzen durch Berechenbarkeitsgrenzen Gegeben: zwei Sortierfunktionen quicksort bubble_sort Beide sind semantisch äquivalent: gleiche Wirkung, soweit durch Sprachsemantik definiert Kann der Übersetzer automatisch eine durch die andere Funktion ersetzen? Zur automatischen Optimierung muß Übersetzer berechnen können, daß die Funktionen äquivalent sind

107 Optimierungsgrenzen durch Berechenbarkeitsgrenzen Gegeben: zwei Sortierfunktionen quicksort bubble_sort Beide sind semantisch äquivalent: gleiche Wirkung, soweit durch Sprachsemantik definiert Kann der Übersetzer automatisch eine durch die andere Funktion ersetzen? Zur automatischen Optimierung muß Übersetzer berechnen können, daß die Funktionen äquivalent sind Programmgleichheit ist nicht berechenbar: Diese Optimierung ist i.a. nicht möglich

108 Optimierungsgrenzen durch Sprachsemantik (1/2) a struct { short a; int w1; short b; int w2; s; // 2 Bytes // 4 Bytes // 2 Bytes // 4 Bytes w1 b w2

109 Optimierungsgrenzen durch Sprachsemantik (1/2) a a b struct { short a; int w1; short b; int w2; s; // 2 Bytes // 4 Bytes // 2 Bytes // 4 Bytes w1 b w1 w2 w2? Wir könnten Speicher sparen, wenn wir die Felder umsortieren würden

110 Optimierungsgrenzen durch Sprachsemantik (2/2) Darf der Übersetzer diese Umsortierung selbst durchführen? C11 Sprachspezifikation, : Within a structure object, the [...] members [...] have addresses that increase in the order in which they are declared. [...]

111 Optimierungsgrenzen durch Sprachsemantik (2/2) Darf der Übersetzer diese Umsortierung selbst durchführen? C11 Sprachspezifikation, : Within a structure object, the [...] members [...] have addresses that increase in the order in which they are declared. [...] Sprachspezifikation verbietet Optimierung

112 Optimierungsgrenzen durch Überspezifikation Überspezifikation: Programm beinhaltet Details, die 1. Das Berechnungsergebnis nicht beeinflussen, aber 2. Zur Berechnung nicht nötig sind Überspezifikation verhindert Optimierungen for (volatile int x = 1; x < 10; x++) { a[x] += 2; // kein Grund für volatile

113 Optimierungsgrenzen durch Überspezifikation Überspezifikation kann indirekt stattfinden: int helfer(int i) { return... int f(int i) {...helfer... Inlining von helfer möglich

114 Optimierungsgrenzen durch Überspezifikation Überspezifikation kann indirekt stattfinden: int helfer(int i) { return... int f(int i) {...helfer... Inlining von helfer möglich Aber: helfer kann nach inlining nicht eliminiert werden: Ein externes Modul könnte auf helfer zugreifen helfer ist nicht static, damit global im Sinne des Binders

115 Optimierungsgrenzen durch Überspezifikation Überspezifikation kann indirekt stattfinden: int helfer(int i) { return... int f(int i) {...helfer... Inlining von helfer möglich Aber: helfer kann nach inlining nicht eliminiert werden: Ein externes Modul könnte auf helfer zugreifen helfer ist nicht static, damit global im Sinne des Binders Überspezifikation durch fehlende Angaben möglich

116 Zusammenfassung: Einschränkungen der Optimierungen Implementierungsbeschränkungen Berechenbarkeit Sprachsemantik und Überspezifizierung Beschränktes Wissen

117 Wissen des Optimierers Optimierung: Programmanalyse a + Transformation t Wissen von a: t ist korrekt Optimierung t ist inkorrekt keine Optimierung nicht genug Informationen keine Optimierung

118 Wissen des Optimierers Optimierung: Programmanalyse a + Transformation t Wissen von a: t ist korrekt Optimierung t ist inkorrekt keine Optimierung nicht genug Informationen keine Optimierung Desto mehr der Optimierer weiß, desto besser kann er optimieren

119 Modul-Optimierung Modul-Optimierung: Normalfall Jedes Modul (Programmdatei) wird einzeln optimiert Wissen des Optimierers: Inhalt eines Moduls Modul-0 Modul-1 Modul-2 Übersetzer Übersetzer Übersetzer Binder Ausführung

120 Gesamtprogrammoptimierung whole-program optimisation Alle Module werden gleichzeitig optimiert Wissen des Optimierers: Inhalt aller Module Das Programm ist vollständig Modul-0 Modul-1 Modul-2 Übersetzer Binder Ausführung Wissen, daß das Programm vollständig ist, erlaubt viele neue Optimierungen, die sonst nur mit const oder static möglich wären

121 Bindezeit-Optimierung Modul-0 Modul-1 Modul-2 link-time optimisation Binder optimiert Module mit Informationen aus anderen Modulen Wissen des Optimierers: Teile des Modulwissens Übersetzer Übersetzer Übersetzer Binder Ausführung

122 Optimierung mit Laufzeitprofil profile-directed optimisation feedback-driven optimisation Übersetzer verwenden Laufzeitmessungen, um Programme zu beschleunigen Zusätzlich zu Modul- /Ganzprogrammoptimierung Wissen des Optimierers: Schleifendurchlaufstatistiken Sprungwahrscheinlichkeiten Oft ausgeführter Code und alles, was er vorher wußte Modul-0 Modul-1 Modul-2 Übersetzer Übersetzer Übersetzer Binder Ausführung Programmprofil

123 Optimierung: Zusammenfassung Optimierungen können zu verschiedenen Zeitpunkten stattfinden: Optimierung bei Modulübersetzung: Vorteile: Relativ schnelle Übersetzung Nachteile: Nur beschränktes Wissen Ganzprogramm-Optimierung: Vorteile: Sehr effektiv Nachteile: Sehr langsam, manchmal unmöglich: Unterstützt keine dynamisch geladenen Module Optimierung braucht viel Arbeitsspeicher Bindezeit-Optimierung: Vorteile: Optimierung jenseits von Modulgrenzen Nachteile: Große Objektdateien, langsames Binden Optimierung mit Laufzeitprofil: Vorteile: Muß Programmverhalten nicht raten Nachteile: Typischer Programmlauf nötig, hoher Aufwand