Effiziente Virtuelle Maschinen für funktionale Programmiersprachen Xavier Leroy, The ZINC experiment: an economical implementation of the ML language.

Präsentation zum Thema: "Effiziente Virtuelle Maschinen für funktionale Programmiersprachen Xavier Leroy, The ZINC experiment: an economical implementation of the ML language."—  Präsentation transkript:

1 Effiziente Virtuelle Maschinen für funktionale Programmiersprachen Xavier Leroy, The ZINC experiment: an economical implementation of the ML language. Technical report 117, INRIA, 1990

2 Überblick Motivation Eigenschaften funktionaler Sprahen N-ary / Unary / curried functions Die abstrakte Maschine Naive Auswertung Analyse der Auswertung Echte Mehrfachapplikation Probleme Analyse der Auswertung Darstellung von Funktionen Das Instruction Set Die Übersetzungsfunktion Operationale Semantik Unterversorgung Überversorgung Optimierungen Darstellung von Werten Das reale Instruction Set Benchmarks

3 Motivation Wie können Programme in funktionalen Sprachen effizient und plattformunabhängig ausgeführt werden ? native Code Compiler hohe Ausführungsgeschwindigkeit Programmdarstellung ist plattformabhängig Compiler müssen für jede Ziel-Plattform neu entwickelt werden Virtuelle Maschine VM selbst ist plattformabhängig, aber leicht portierbar Bytecode ist plattformunabhängig Overhead der VM kann minimiert werden

4 Eigenschaften funktionaler Sprachen Abstraktion Curried functions: val f = fn a => fn b => a+b Unary functions: val f = fn (a,b) => a+b N-ary functions ? Applikation mit Unterversorgung von Argumenten mit Überversorgung von Argumenten Schleifen werde durch rekursive Funktionen dargestellt.

5 N-ary functions n-ary functions sind Funktionen mit mehr als einem Argument. Bei der Ausführung werden diese zurückübersetzt in einfachere Funktionen. Es gibt dazu zwei Möglichkeiten fun f (a b) = a+b als unary functions mit Argumenten-Tupel fun f (a,b) = a+b oder als curried functions val f = fn a => fn b => a+b

6 Vergleich von Unary / curried functions Nachteil bei Argumenten-Tupel: Allokation des Argumenten-Tupel auf dem Heap bei jedem Aufruf Vorteil von curried functions: Curried functions sind bei partieller Anwendung verwendbar: val add = fn a => fn b => a+b map (add 5) [1,2,3] Partielle Applikation ist bei Argumenten-Tupel nicht möglich. => Curried functions sollten effizient implementiert werden! => N-ary functions als curried functions übersetzbar.

7 Überblick Motivation Eigenschaften funktionaler Sprahen N-ary / Unary / curried functions Die abstrakte Maschine Naive Auswertung Analyse der Auswertung Echte Mehrfachapplikation Probleme Analyse der Auswertung Darstellung von Funktionen Das Instruction Set Die Übersetzungsfunktion Operationale Semantik Unterversorgung Überversorgung Optimierungen Darstellung von Werten Das reale Instruction Set Benchmarks

8 Die abstrakte Maschine Die abstrakte Maschine besteht aus folgenden Komponenten: Der Akkumulator enthält Zwischenergebnisse Der Code-Zeiger zeigt auf die nächste auszuführende Instruktion. Die Umgebung verwaltet alle aktuellen Bezeichnerbindungen. Auf dem Stack werden Aufrufparameter, Ergebnis-Werte und Closures von unterbrochenen Auswertungen abgelegt. Die Semantik der Maschine wird bestimmt durch: Das Instruction Set der Maschine. Die Operationale Semantik bestimmt wie diese Instruktionen in Abhängigkeit vom aktuellen Inhalt von Umgebung und Stack ausgewertet werden.

9 Naive Auswertung Bei der naiven Auswertung wird jeweils ein Parameter angewandt. M N 1 N 2 ==> (M N 1 ) N 2 Über- und Unterversorgung betrachten wir später!

10 Auswertungsbeispiel (fn a => fn b => a + x) 3 x Um die erste Applikation auszuführen, wird der Folgeausdruck als Closure auf den Stack gelegt. Stack Umgebung x: 7 Akkumulator

11 Auswertungsbeispiel (fn a => fn b => a + x) 3 Der Parameter wird in den Akkumulator geladen. Stack Closure A Umgebung x: 7 Closure A Code X Umgebung x: 7 Akkumulator

12 Auswertungsbeispiel (fn a => fn b => a + x) … und auf den Stack gelegt. Stack Closure A Umgebung x: 7 Closure A Code X Umgebung x: 7 Akkumulator 3

13 Auswertungsbeispiel fn a => fn b => a + x Die Abstraktion wird ausgeführt, indem das Argument von Stack genommen wird und als a in die Umgebung eingefügt. Stack 3 Closure A Umgebung x: 7 Closure A Code X Umgebung x: 7 Akkumulator

14 Auswertungsbeispiel fn b => a + x Bei einer weiteren Abstraktion ist die Auswertung zunächst abgebrochen. Das Zwischenergebnis wird in einer Closure in den Akkumulator gepackt. Stack Closure A Umgebung x: 7 a: 3 Closure A Code X Umgebung x: 7 Akkumulator

15 Auswertungsbeispiel Die neue Closure ersetzt die unterbrochene Auswertung auf dem Stack. Diese wird fortgesetzt. Stack Closure A Code X Umgebung x: 7 Closure B Code fn b => a + x Umgebung x: 7 a: 3 Akkumulator Closure B

16 Auswertungsbeispiel x Das nächste Argument wird in den Akkumulator geladen. Stack Closure B Umgebung x: 7 Closure B Code fn b => a + x Umgebung x: 7 a: 3 Akkumulator

17 Auswertungsbeispiel … und auf den Stack gelegt. Die unterbrochene Auswertung wird fortgesetzt. Stack Closure B Umgebung x: 7 Closure B Code fn b => a + x Umgebung x: 7 a: 3 Akkumulator 7

18 Auswertungsbeispiel fn b => a + x Die Abstraktion wird ausgeführt, indem das Argument von Stack genommen wird und als b in die Umgebung eingefügt. Stack 7 Umgebung x: 7 a: 3 Akkumulator

19 Auswertungsbeispiel a + x a wird aus der Umgebung in den Akkumulator geladen. Stack Umgebung x: 7 a: 3 b: 7 Akkumulator

20 Auswertungsbeispiel + x … und auf den Stack gelegt. Stack Umgebung x: 7 a: 3 b: 7 Akkumulator 3

21 Auswertungsbeispiel + x x wird aus der Umgebung in den Akkumulator geladen. Stack 3 Umgebung x: 7 a: 3 b: 7 Akkumulator

22 Auswertungsbeispiel + Der oberste Wert auf dem Stack wird zum Akkumulator addiert. Stack 3 Umgebung x: 7 a: 3 b: 7 Akkumulator 7

23 Auswertungsbeispiel Der Wert im Akkumulator ist das Ergebnis. Stack Umgebung x: 7 a: 3 b: 7 Akkumulator 10

24 Analyse der Auswertung Die Auswertung von Mehrfach-Applikationen erfolgt schrittweise: Bei Left-To-Right Evaluation: ((((M) (N 1 )) (N 2 )) (N 3 )) Reihenfole: M, N 1, (M N 1 )=a, N 2, (a N 2 )=b, N 3, (b N 3 ) Bei der Auswertung jeder Applikation [außer der letzten] entsteht eine Closure für das bisher erzeugte Zwischenergebnis. n-Argumente => n-1 Closures.

25 Probleme dieser Auswertung Es werden für k Argumente mindestens k - 1 Closures verwendet. Closures werden auf dem Heap angelegt. Allokationen sind zeitintensiv Die Closures werden [teilweise] nur einmal verwendet. Der Speicherbedarf steigt. Die Garbage Collection wird häufiger verwendet. Wie kann man diese Closures meiden ?

26 Überblick Motivation Eigenschaften funktionaler Sprahen N-ary / Unary / curried functions Die abstrakte Maschine Naive Auswertung Analyse der Auswertung Echte Mehrfachapplikation Probleme Analyse der Auswertung Darstellung von Funktionen Das Instruction Set Die Übersetzungsfunktion Operationale Semantik Unterversorgung Überversorgung Optimierungen Darstellung von Werten Das reale Instruction Set Benchmarks

27 Echte Mehrfachapplikation - Vorteile Alle Argumente könnten vor der Applikation auf den Stack gelegt werden. Die Auswertung muss nicht nach jeder Teilapplikation unterbrochen werden. Die Reihenfolge bei 3-fach-Applikation M N 1 N 2 N 3 ist: bei Einzelapplikationen: M, N 1, (M N 1 )=a, N 2, (a N 2 )=b, N 3, (b N 3 ) bei Mehrfachapplikation: M, N 1, N 2, N 3, (M N 1 N 2 N 3 ) Die Applikation aller Argumente erzeugt keine unnötigen Closures.

28 Probleme der Mehrfachapplikation Mehrere Einzelapplikationen sollten die gleiche Auswertungsreihenfolge haben wie eine Mehrfachapplikation. [Gilt nicht für Zwischenergebnisse !] Problem: Left-To-Right Evaluation Order M N 1 N 2 => M, N 1, N 2, (M N 1 N 2 ) (M N 1 ) N 2 => [M, N 1, (M N 1 )=a], N 2, (a N 2 ) Lösung: Right-To-Left Evaluation Order M N 1 N 2 => N 2, N 1, (M N 1 N 2 ) (M N 1 ) N 2 => N 2, [N 1, (M N 1 )=a], (a N 2 )

29 Beispiel für Inkonsistenz exception Abs exception Right val f = fn x => (raise Abs; fn y => y) Problem: Left-To-Right Evaluation Order f 1 (raise Right) => raise Right ( f 1 ) (raise Right) => raise Abs Lösung: Right-To-Left Evaluation Order f 1 (raise Right) => raise Right ( f 1 ) (raise Right) => raise Right

30 Auswertungsbeispiel (fn a => fn b => a + x) 3 x Zuerst wird das rechte Argument in den Akkumulator geladen. Stack Umgebung x: 7 Akkumulator

31 Auswertungsbeispiel (fn a => fn b => a + x) 3 … und auf den Stack gelegt. Stack Umgebung x: 7 Akkumulator 7

32 Auswertungsbeispiel (fn a => fn b => a + x) 3 Dann wird das nächste Argument in den Akkumulator geladen. Stack 7 Umgebung x: 7 Akkumulator

33 Auswertungsbeispiel fn a => fn b => a + x … und auf den Stack gelegt. Stack 7 Umgebung x: 7 Akkumulator 3

34 Auswertungsbeispiel fn a => fn b => a + x Die Abstraktion wird ausgeführt, indem das Argument von Stack genommen wird und als a in die Umgebung eingefügt. Stack 3 7 Umgebung x: 7 Akkumulator

35 Auswertungsbeispiel fn b => a + x Die Abstraktion wird ausgeführt, indem das Argument von Stack genommen wird und als b in die Umgebung eingefügt. Stack 7 Umgebung x: 7 a: 3 Akkumulator

36 Auswertungsbeispiel a + x a wird aus der Umgebung in den Akkumulator geladen. Stack Umgebung x: 7 a: 3 b: 7 Akkumulator

37 Auswertungsbeispiel + x … und auf den Stack gelegt. Stack Umgebung x: 7 a: 3 b: 7 Akkumulator 3

38 Auswertungsbeispiel + x x wird aus der Umgebung in den Akkumulator geladen. Stack 3 Umgebung x: 7 a: 3 b: 7 Akkumulator

39 Auswertungsbeispiel + Der oberste Wert auf dem Stack wird zum Akkumulator addiert. Stack 3 Umgebung x: 7 a: 3 b: 7 Akkumulator 7

40 Auswertungsbeispiel Der Wert im Akkumulator ist das Ergebnis. Stack Umgebung x: 7 a: 3 b: 7 Akkumulator 10

41 Analyse der Auswertung Bei dieser Auswertung wurden KEINE Closures erzeugt.

42 Überblick Motivation Eigenschaften funktionaler Sprahen N-ary / Unary / curried functions Die abstrakte Maschine Naive Auswertung Analyse der Auswertung Echte Mehrfachapplikation Probleme Analyse der Auswertung Darstellung von Funktionen Das Instruction Set Die Übersetzungsfunktion Operationale Semantik Unterversorgung Überversorgung Optimierungen Darstellung von Werten Das reale Instruction Set Benchmarks

43 Darstellung von Funktionen Funktionen werden durch λ-Abstraktionen mit de-Bruijn-Darstellung ersetzt: val f = fn a => fn b => a + b val f = λ. λ. + val f = fn a => fn b => fn x => a + b val f = λ. λ. λ. + Die Bezeichner von neu gebundenen Abstraktionen entfallen. Außerdem reduzieren sich Umgebungen von Funktionen Bezeichner -> Wert auf einfachere Werte-Listen.

44 Darstellung von Funktionen Funktionen werden als Werte in Form von Closures dargestellt. Eine Closure besteht aus einer Umgebung und einer Code-Pointer. Beispiel (ML-Notation): val f = fn a => fn b => fn c => a + b f : {}, o val g = f 5 3 g : {a:5, b:3}, o

45 Darstellung von Funktionen Funktionen werden als Werte in Form von Closures dargestellt. Eine Closure besteht aus einer Umgebung und einer Code-Pointer. Beispiel (de-Bruijn-Notation): val f = λ. λ. λ. + f : [], o val g = f 5 3 g : [3, 5], o

46 Das Instruction Set Access(n) - liest das n. Element aus der Umgebung in den Akkumulator. Reduce(c) - führt c aus und legt den Wert des Akkumulators auf den Stack. Return - Beendet ein Auswertung eines Ausdrucks Grab - nimmt das oberste Element [das nächste Argument] vom Stack und fügt sie als neues erstes Element in die Umgebung ein. ConstInt(i) - legt die Integer-Konstante i in den Akkumulator. AddInt - Addiert das oberste Element des Stacks zum Akkumulator.

47 Die Übersetzungsfunktion [ ] [ M N ]--> Reduce( [ N ]; Return ); [ M ] [ ]--> Access(n) [ λ. N ]--> Grab; [ N ] [ i ]--> ConstInt(i) [ N 1 + N 2 ]--> Reduce( [ N 2 ]; Return ); [ N 1 ]; AddInt Jedes Programm endet mit Return.

48 Übersetzungsbeispiel ( fn a => fn b => a + b ) ( ( fn x => x ) 1 ) 2 ( λ. λ. + ) ( ( λ. ) 1 ) 2 [ ( λ. λ. + ) ( ( λ. ) 1 ) 2 ]; Return

49 Übersetzungsbeispiel ( fn a => fn b => a + b ) ( ( fn x => x ) 1 ) 2 ( λ. λ. + ) ( ( λ. ) 1 ) 2 Reduce( [ 2 ]; Return ); [ ( λ. λ. + ) ( ( λ. ) 1 ) ]; Return

50 Übersetzungsbeispiel ( fn a => fn b => a + b ) ( ( fn x => x ) 1 ) 2 ( λ. λ. + ) ( ( λ. ) 1 ) 2 Reduce( ConstInt(2); Return ); [ ( λ. λ. + ) ( ( λ. ) 1 ) ]; Return

51 Übersetzungsbeispiel ( fn a => fn b => a + b ) ( ( fn x => x ) 1 ) 2 ( λ. λ. + ) ( ( λ. ) 1 ) 2 Reduce( ConstInt(2); Return ); Reduce( [ ( λ. ) 1 ]; Return ); [ λ. λ. + ]; Return

52 Übersetzungsbeispiel ( fn a => fn b => a + b ) ( ( fn x => x ) 1 ) 2 ( λ. λ. + ) ( ( λ. ) 1 ) 2 Reduce( ConstInt(2); Return ); Reduce( Reduce( [ 1 ]; Return ); [ λ. ]; Return ); [ λ. λ. + ]; Return

53 Übersetzungsbeispiel ( fn a => fn b => a + b ) ( ( fn x => x ) 1 ) 2 ( λ. λ. + ) ( ( λ. ) 1 ) 2 Reduce( ConstInt(2); Return ); Reduce( Reduce( ConstInt(1); Return ); [ λ. ]; Return ); [ λ. λ. + ]; Return

54 Übersetzungsbeispiel ( fn a => fn b => a + b ) ( ( fn x => x ) 1 ) 2 ( λ. λ. + ) ( ( λ. ) 1 ) 2 Reduce( ConstInt(2); Return ); Reduce( Reduce( ConstInt(1); Return ); Grab; [ ]; Return ); [ λ. λ. + ]; Return

55 Übersetzungsbeispiel ( fn a => fn b => a + b ) ( ( fn x => x ) 1 ) 2 ( λ. λ. + ) ( ( λ. ) 1 ) 2 Reduce( ConstInt(2); Return ); Reduce( Reduce( ConstInt(1); Return ); Grab; Access(0); Return ); [ λ. λ. + ]; Return

56 Übersetzungsbeispiel ( fn a => fn b => a + b ) ( ( fn x => x ) 1 ) 2 ( λ. λ. + ) ( ( λ. ) 1 ) 2 Reduce( ConstInt(2); Return ); Reduce( Reduce( ConstInt(1); Return ); Grab; Access(0); Return ); Grab; [ λ. + ]; Return

57 Übersetzungsbeispiel ( fn a => fn b => a + b ) ( ( fn x => x ) 1 ) 2 ( λ. λ. + ) ( ( λ. ) 1 ) 2 Reduce( ConstInt(2); Return ); Reduce( Reduce( ConstInt(1); Return ); Grab; Access(0); Return ); Grab; Grab; [ + ]; Return

58 Übersetzungsbeispiel ( fn a => fn b => a + b ) ( ( fn x => x ) 1 ) 2 ( λ. λ. + ) ( ( λ. ) 1 ) 2 Reduce( ConstInt(2); Return ); Reduce( Reduce( ConstInt(1); Return ); Grab; Access(0); Return ); Grab; Grab; Reduce( [ ]; Return ); [ ]; AddInt; Return

59 Übersetzungsbeispiel ( fn a => fn b => a + b ) ( ( fn x => x ) 1 ) 2 ( λ. λ. + ) ( ( λ. ) 1 ) 2 Reduce( ConstInt(2); Return ); Reduce( Reduce( ConstInt(1); Return ); Grab; Access(0); Return ); Grab; Grab; Reduce( Access(0); Return ); [ ]; AddInt; Return

60 Übersetzungsbeispiel ( fn a => fn b => a + b ) ( ( fn x => x ) 1 ) 2 ( λ. λ. + ) ( ( λ. ) 1 ) 2 Reduce( ConstInt(2); Return ); Reduce( Reduce( ConstInt(1); Return ); Grab; Access(0); Return ); Grab; Grab; Reduce( Access(0); Return ); Access(1); AddInt; Return

61 Das Instruction Set Access(n) - liest das n. Element aus der Umgebung in den Akkumulator. Reduce(c) - führt c aus und legt den Wert des Akkumulators auf den Stack. Return - Beendet ein Auswertung eines Ausdrucks Grab - nimmt das oberste Element [das nächste Argument] vom Stack und fügt sie als neues erstes Element in die Umgebung ein. ConstInt(i) - legt die Integer-Konstante i in den Akkumulator. AddInt - Addiert das oberste Element des Stacks zum Akkumulator.

62 Operationale Semantik CodeAkkuEnv.StackCodeAkkuEnvStack Access(k); ca[v 0..v n ]scvkvk s Reduce(c); caescae :: s Returnae :: sc0c0 ae0e0 a :: s Return(c 0, e 0 )ev :: sc0c0 (c 0, e 0 )e0e0 v :: s Grab; caev :: scav :: es Grab; cae :: sc0c0 ae0e0 (Grab; c, e) :: s ConstInt(i); caescies AddInt; caev :: sca + ves SubInt; caev :: sca – ves

63 Verbleibende Closures Closures können nur von Grab und Reduce erzeugt werden. Grab erzeugt eine Closure genau dann, wenn keine weiteren Argumente vorhanden sind. (Normale Closure) => Das Ergebnis ist eine Abstraktion, die Closure ist notwendig. Reduce erzeugt Closures, um die Auswertung zu unterbrechen, bis ein Argument reduziert ist. (Markierte Closure) Diese Closures können nicht in die Umgebung eingefügt werden. => Sie können auf dem Stack alloziiert werden. => Sie belasten den Heap / die Garbage Collection nicht. Wie funktioniert Unter- / Überversorgung ?

64 Überblick Motivation Eigenschaften funktionaler Sprahen N-ary / Unary / curried functions Die abstrakte Maschine Naive Auswertung Analyse der Auswertung Echte Mehrfachapplikation Probleme Analyse der Auswertung Darstellung von Funktionen Das Instruction Set Die Übersetzungsfunktion Operationale Semantik Unterversorgung Überversorgung Optimierungen Darstellung von Werten Das reale Instruction Set Benchmarks

65 Unterversorgung Unterversorgung bedeutet, dass eine Curried-Function weniger Argumente bekommt, als sie bekommen könnte. ( fn a => fn b => 1 ) 2 ( λ. λ. 1 ) 2 Reduce( ConstInt(2); Return ); Grab; Grab; Access(1); Return

66 Unterversorgung Reduce( ConstInt(2); Return ); Grab; Grab; Access(1); Return Stack Umgebung Akkumulator

67 Unterversorgung ConstInt(2); Return Stack Umgebung Akkumulator Closure A Code Grab;... Return Umgebung

68 Unterversorgung Return Stack Umgebung Akkumulator 2 Closure A Code Grab;... Return Umgebung

69 Unterversorgung Grab; Grab; Access(1); Return Stack 2 Umgebung Akkumulator

70 Unterversorgung Grab; Access(1); Return Stack Umgebung 2 Akkumulator

71 Operationale Semantik CodeAkkuEnv.StackCodeAkkuEnvStack Access(k); ca[v 0..v n ]scvkvk s Reduce(c); caescae :: s Returnae :: sc0c0 ae0e0 a :: s Return(c 0, e 0 )ev :: sc0c0 (c 0, e 0 )e0e0 v :: s Grab; caev :: scav :: es Grab; cae :: sc0c0 ae0e0 (Grab; c, e) :: s ConstInt(i); caescies AddInt; caev :: sca + ves SubInt; caev :: sca – ves

72 Unterversorgung Stack (Closure B) Umgebung Akkumulator Closure B Code Grab; Access(1); Return Umgebung 2

73 Überblick Motivation Eigenschaften funktionaler Sprahen N-ary / Unary / curried functions Die abstrakte Maschine Naive Auswertung Analyse der Auswertung Echte Mehrfachapplikation Probleme Analyse der Auswertung Darstellung von Funktionen Das Instruction Set Die Übersetzungsfunktion Operationale Semantik Unterversorgung Überversorgung Optimierungen Darstellung von Werten Das reale Instruction Set Benchmarks

74 Überversorgung Überversorgung bedeutet, dass eine Curried-Function mehr Argumente bekommt, als zu erwarten wäre. Daher muss das Ergebnis der Anwendung der erwarteten Argumente eine Abstraktion sein. (Typ-Korrektheit) ( fn a => a ) ( fn b => 1 ) 2 ( λ. ) ( λ. 1 ) 2 Reduce( ConstInt(2); Return ); Reduce( Grab; ConstInt(1); Return ); Grab; Access(0); Return

75 Überversorgung Reduce( ConstInt(2); Return ); Reduce( Grab; ConstInt(1); Return ); Grab; Access(0); Return Stack Umgebung Akkumulator

76 Überversorgung ConstInt(2); Return Stack Umgebung Akkumulator Closure A Code Reduce...; Return Umgebung

77 Überversorgung Return Stack Umgebung Akkumulator 2 Closure A Code Reduce... Return Umgebung

78 Überversorgung Reduce( Grab; ConstInt(1); Return ); Grab; Access(0); Return Stack 2 Umgebung Akkumulator

79 Überversorgung Grab; ConstInt(1); Return Stack 2 Umgebung Akkumulator Closure B Code Grab;...; Return Umgebung

80 Operationale Semantik CodeAkkuEnv.StackCodeAkkuEnvStack Access(k); ca[v 0..v n ]scvkvk s Reduce(c); caescae :: s Returnae :: sc0c0 ae0e0 a :: s Return(c 0, e 0 )ev :: sc0c0 (c 0, e 0 )e0e0 v :: s Grab; caev :: scav :: es Grab; cae :: sc0c0 ae0e0 (Grab; c, e) :: s ConstInt(i); caescies AddInt; caev :: sca + ves SubInt; caev :: sca – ves

81 Überversorgung Grab; Access(0); Return Stack (Closure C) 2 Umgebung Akkumulator Closure C Code Grab;...; Return Umgebung

82 Überversorgung Access(0); Return Stack 2 Umgebung (Closure C) Akkumulator Closure C Code Grab;...; Return Umgebung

83 Überversorgung Return Stack 2 Umgebung (Closure C) Akkumulator (Closure C) Closure C Code Grab;...; Return Umgebung

84 Operationale Semantik CodeAkkuEnv.StackCodeAkkuEnvStack Access(k); ca[v 0..v n ]scvkvk s Reduce(c); caescae :: s Returnae :: sc0c0 ae0e0 a :: s Return(c 0, e 0 )ev :: sc0c0 (c 0, e 0 )e0e0 v :: s Grab; caev :: scav :: es Grab; cae :: sc0c0 ae0e0 (Grab; c, e) :: s ConstInt(i); caescies AddInt; caev :: sca + ves SubInt; caev :: sca – ves

85 Überversorgung Grab; ConstInt(1); Return Stack 2 Umgebung Akkumulator

86 Überversorgung ConstInt(1); Return Stack Umgebung 2 Akkumulator

87 Überversorgung Return Stack Umgebung 2 Akkumulator 1

88 Überversorgung Stack 1 Umgebung Akkumulator

89 Weitere Optimierungen Durch einen Cache (in Registern der Virtuellen Maschine) wird der Zugriff auf die aktuellsten Elemente der Umgebung beschleunigt. Es gibt spezialisierte Instruktionen für häufige Operationen. (z.B.: Let, Konstante Konstruktoren, Endrekursion …) Durch eine globale Variablenliste wird die Umgebung stark verkleinert. Trennung von Argumenten-Stack und Return-Stack

90 Überblick Motivation Eigenschaften funktionaler Sprahen N-ary / Unary / curried functions Die abstrakte Maschine Naive Auswertung Analyse der Auswertung Echte Mehrfachapplikation Probleme Analyse der Auswertung Darstellung von Funktionen Das Instruction Set Die Übersetzungsfunktion Operationale Semantik Unterversorgung Überversorgung Optimierungen Darstellung von Werten Das reale Instruction Set Benchmarks

91 Darstellung von Werten Alle Werte sind 32-bit Worte. unboxed, also direkt, werden folgende Typen abgelegt: 31-bit vorzeichenbehaftete Integer werden als 32-bit Integer mit gesetztem Bit 0 dargestellt. Zeiger in den Heap (oder in den Code auf Konstanten) werden direkt abgelegt. (Ihre Binärdarstellung endet auf 00.) Alle anderen Datentypen werden im Heap angelegt und es wird nur der Zeiger auf diesen Speicherblock abgelegt. boxed 31-bit Integer..........1 32-bit Pointer.........00 ? Real.........10

92 Heap-Aufbau Der Speicher besteht aus 32-bit Worten, die in Blöcke aufgeteilt werden. Jeder Block hat einen Header, mit einer Beschreibung seines Inhalts, seiner Größe und 2 Bits für die Garbage Collection. Die Garbage Collection kann selbständig zwischen unstrukturierten Daten und Listen von Werten unterscheiden. Es gibt im Code keine Zeiger in den Heap. Es gibt in der globalen Variablenliste Zeiger in den Heap.

93 Speicherblöcke im Heap Im ersten Word eines Blocks steht: n – die Größe des Blocks (22 bit) GC – Daten für den Garbage Collector (2 bit) tag – Typinformation (8 bit) Das Tag-Feld bestimmt die Interpretation des Inhalts tag=255: Unstrukturierte Blöcke tag=254: Closure tag<254: Konkreter Datentyp nGCtag field 1...... field n

94 Unstrukturierte Blöcke Unstrukturierte Blöcke enthalten keine Werte. tag = 255 Beispiel: Strings Strings werden nullterminiert abgelegt Sie werden aufgefüllt, so dass Länge = 4 * Block-Größe – letztes Byte. Beispiel: var x = Abstract_Maschine 5GC255 Abst ract _Mas chin e\0\0\3

95 Closure Closures sind stukturierte Blöcke, d.h. sie enthalten Werte. tag = 254 Der Datenblock besteht aus dem Codezeiger und der zugehörigen Umgebung Im Beispiel: k Elemente in der Umgebung k+1GC254 value 1 value 2 … value k

96 Konkrete Datentypen Instanzen sind strukturierte Blöcke, d.h. sie enthalten Werte. tag < 254 Beispiel: datatype t = I of int * int | S of string Varianten werden beginnend mit 0 durchnummeriert. Die Variantennummer wird als tag verwendet. 2GC0 value 1 value 2 1GC1 pointer 1

97 Konkrete Datentypen (2) Sind mehr als 254 Varianten vorhanden, so muss eine alternative Darstellung verwendet werden. Die Variantennummer wird als Integer im ersten Daten-Feld abgelegt. Beispiel: datatype t = C0 of int |... | C254 of int * int 2GC0 0 value 1 3GC0 254 value 1 value 2

98 Beispiel datatype t = A of int | B of int * t * string * (int->int) val x = B(3, A 2, test, (fn a => fn b => a+b) 3) 4GC1 3 o o o 2 255 test \0\0\0\4 1GC0 2 2 254 o 3

99 Vorteile der Blockdarstellung Der Garbage Collector kann erkennen, ob es sich um reine Daten oder eine Liste von Werten handelt, die Zeiger enthalten können. Zur Erinnerung: Zeiger können von Integern an den beiden abschließenden 00 unterschieden werden.

100 Überblick Motivation Eigenschaften funktionaler Sprahen N-ary / Unary / curried functions Die abstrakte Maschine Naive Auswertung Analyse der Auswertung Echte Mehrfachapplikation Probleme Analyse der Auswertung Darstellung von Funktionen Das Instruction Set Die Übersetzungsfunktion Operationale Semantik Unterversorgung Überversorgung Optimierungen Darstellung von Werten Das reale Instruction Set Benchmarks

101 Das reale Instruction Set Constants and literals Function handling Environment handling Building and destructing blocks Integers Floating-point numbers Strings Predicates Branches and conditional branches Miscellaneous

102 Constants and literals Constbyte(int 8 ), Constshort(int 16 ), Constlog(int 32 ) Lädt eine Konstante. Atom(tag), Atom0, …, Atom9 Lädt einen Pointer auf einen konstanten Block mit Tag tag. GetGlobal(int 16 ), SetGlobal(int 16 ) Lädt eine globale Variable oder speichert diese.

103 Function handling Push, Pushmark Legt den Akkumulator bzw. eine Markierung auf den Stack Apply, AppTerm Führt die Closure im Akkumulator aus. (Normal / endrekursiv) Return Beendet die Auswertung eines Ausdrucks Grab Fügt ein Argument vom Stack in die Umgebung ein. Cur(ofs) Erstellt eine Closure für Codepointer ofs im Akkumulator

104 Integers and floating-point numbers SuccInt, PredInt, NegInt, AddInt, SubInt, MulInt, DivInt, ModInt, AndInt, OrInt, XorInt, ShiftLeftInt, ShiftRightInt Berechnet die jeweilige Operation mit dem Akkumulator und ggf. dem obersten Element des Stacks. FloatOfInt, IntOfFloat Konvertiert Integer in Fließkommazahlen oder umgekehrt. Floatop(AddFloat), Floatop(SubFloat), Floatop(MulFloat), Floatop(DivFloat) Berechnet die jeweiligen Operationen

105 Branches and conditional branches Branchifeqtag(tag, ofs), Branchifneqtag(tag, ofs) Springt relativ um ofs, falls der Akkumulator auf Tag tag zeigt. Switch(ofs 0,..., ofs k ) Springt relativ um ofs tag falls der Akkumulator auf Tag tag zeigt. BranchifEq(ofs) Springt relativ um ofs, falls der Akkumulator und der oberste Element des Stacks pointer-gleich sind. BranchifEqual(ofs) Springt relativ um ofs, falls der Akkumulator und der oberste Element des Stacks struktuell gleich sind. … viele weitere

106 Benchmarks fun fib n = if n<2 then 1 else fib(n-1) + fib(n-2) fun tak x y z = if x>y then tak (tak (x-1) y z) (tak (y-1) z x) (tak (z-1) x y) else z fun sum [] = 0 | sum (a::ar) = a + sum ar fun interval n = if n = 0 then nil else n :: interval(n-1) fun double f x = f (f x) val quad = double double val oct = quad quad fun succ n = n+1 fib 26 tak 18 12 6 sum (interval 10000) double oct (fn x => x+1) 1 map (quad quad succ) (intervall 1000)

107 Benchmarks (2)

108 Quellen Xavier Leroy, The ZINC experiment: an economical implementation of the ML language. Technical report 117, INRIA, 1990