Benutzer-Werkzeuge

Webseiten-Werkzeuge


k5:k5.5:start

5.5 Just-In-Time-Compiler

Seit Mai 2012 gibt es vom Entwickler Emil Lenngren die Komponente gb.jit, die einen Just-In-Time-Compiler (JIT-Compiler) bereitstellt, der Gambas Byte-Code in die Maschinensprache des aktuell laufenden Systems übersetzt. Der Vorteil des Einsatzes des JIT-Compilers liegt darin, dass rechenintensive Programme weitaus schneller laufen. Notwendig ist der Einsatz des JIT-Compilers nicht.

  • Der JIT-Compiler verwendet die Low-Level-Virtual-Machine (LLVM), ein Toolkit (Programmbibliothek) für den Bau von hoch optimierten Compilern, Optimierern und Laufzeitumgebungen, um Maschinencode für x86_64 oder x86 produzieren.
  • Unter http://de.wikipedia.org/wiki/Low_Level_Virtual_Machine finden Sie Informationen zur LLVM.
  • Die Projekt-Seite von LLVM auf http://llvm.org/ vermittelt detaillierte Hinweise zur Installation der LLVM.

5.5.1 Installation LLVM

Sie sollten für die stabile Version von Gambas auch eine stabile Version von LLVM einsetzen. Mit diesen Befehlen können Sie eine LLVM auf Ihrem Rechner installieren:

$ svn co http://llvm.org/svn/llvm-project/llvm/tags/RELEASE_31/final/ llvm # Stabile Version
$ $ cd llvm 
$ mkdir build 
$ cd build 
$ ../configure --prefix=/usr --enable-optimized --enable-jit --enable-shared 
$ make -j4 
$ sudo make install 
$ cd

Im letzten Schritt prüfen Sie, welche Version installiert wurde:

$ llvm-config --version 
3.1 

5.5.2 Einsatz JIT-Compiler

Um den JIT-Compiler für alle Funktionen in einer Gambas-Klasse zu aktivieren, fügen Sie das Wort Fast auf einer separaten Zeile am Anfang der Klassen-Datei ein. Gambas-Funktionen werden dann mit dem JIT-Compiler in nativen Maschinen-Code kompiliert und nicht interpretiert, wenn die Komponente gb.jit verfügbar ist. Um festzustellen, ob Ihr Programm mit dem JIT-Compiler kompiliert wird, müssen Sie die Umgebungsvariable GB_JIT in Ihrem Programm setzen. Wenn diese definiert ist (existent und nicht-leer), dann schreibt gb.jit seine Debugging-Meldungen – eine Fülle an Informationen über nahezu alles, was die Komponente leistet – an die Standardfehlerausgabe des Programms. Das betrifft auch den in eine lesbare Form konvertierten Byte-Code der Instruktionen, den der JIT-Compiler generiert.

Setzen Sie in den Projekteigenschaften Ihres Projekts bei Umgebung/Umgebungsvariablen als Variable „GB_JIT“. Tragen Sie „y“ als Wert ein. Nach einem Programmstart kommt dann zum Beispiel die folgende Meldung in der Konsole, wenn LLVM nicht installiert ist:

gbx3: warning: JIT compiler not available 

oder diese Informationen, wenn der JIT-Compiler arbeitet:

gb.jit: using LLVM 3.1.
------------------------------------------------------------------------
gb.jit: beginning compiling FMain.FMain:
------------------------------------------------------------------------
...

Im Terminal setzen Sie die Umgebungsvariable GB_JIT vor dem Starten des Interpreters temporär so:

$ GB_JIT=y gbx3 2>gb.jit.log # Informationen von gb.jit werden nach "./gb.jit.log" geschrieben 

Gegenwärtig bemüht sich der Entwickler des JIT-Compilers Emil Lenngren um stabile Konfigurations-Skripte für das Zusammenspiel zwischen Gambas, seiner Komponente gb.jit und dem verwendeten Betriebssystem. Von Nachteil sind dabei Änderungen der Verzeichnis-Struktur bei der LLVM und die Tatsache, dass nahezu jede Distribution LLVM in unterschiedlichen Pfaden abspeichert.

5.5.3 Software-Test

Wenn Sie ein stabiles Gambas einsetzen, die LLVM installiert ist und Sie den JIT-Compiler in Ihren Programmen einsetzen können, dann interessiert Sie sicher, welchen Vorteil das für Ihre Programme hat. Auf http://gambasdoc.org/help/doc/benchmark finden Sie mehrere Programme und die getesteten Programm-Laufzeiten. Bei dem folgenden adaptierten Gambas-Skript aus der o.a. Quelle wurden sehr unterschiedliche Laufzeiten erzielt:

#!/usr/bin/env gbs3 
 ' Fast 
PUBLIC SUB Main() 
  DIM I As Integer 
  DIM StartTime As Float 

  StartTime = Timer 
 For I = 1 To 2 
    PRINT Test(0.2) 
  Next 
  PRINT "Programm-Laufzeit = "; GetTime(StartTime, Timer); " Sekunden" 
End 

Private Function Test(X As Float) As Float 
  DIM Mu As Float = 10.0 
  DIM Pu, Su As Float 
  DIM I, J, N As Integer 
  DIM aPoly As New Float[100] 

  N = 500000 

  For I = 0 To N - 1 
    For J = 0 To 99 
      Mu =  (Mu + 2.0) / 2.0 
      aPoly[J] = Mu 
    Next 
    Su = 0.0 
    For J = 0 To 99 
      Su = X * Su + aPoly[J] 
    Next 
    Pu += Su 
  Next 
  Return Pu 
End 

Private Function GetTime(StartTime As Float, EndTime as Float) As Float 
  Return Round(EndTime - StartTime, -3) 
End 

Der Aufruf des Gambas-Skripts – gespeichert in der Datei jit_p.gbs3 – erfolgt in der Konsole:

hans@linux:~$ gbs3 $HOME/jit_p.gbs3 # Ohne Fast
 150000 
 150000 
 Programm-Laufzeit = 24,249 Sekunden 
hans@linux:~$ 

Mit dem Schlüsselwort Fast ergaben sich beim Einsatz des JIT-Compilers nur 0,808 Sekunden, was einem Laufzeit-Verhältnis von etwa 30:1 zwischen Gambas und Gambas mit JIT-Compiler entspricht!

Download

k5/k5.5/start.txt · Zuletzt geändert: 20.06.2016 (Externe Bearbeitung)

Seiten-Werkzeuge