Just In Time Compiler (old version)

On May 24, 2012, Gambas got a Just In Time compiler.

The compiler was implemented by Emil Lenngren.

The compiler uses LLVM to produce machine code for x86 or x86_64.

You need LLVM version 3.1-3.5 on your computer for the Just In Time compiler to work.

Sinds 3.3

Find more instructions in the gb.jit/README file.

Syntax

To use it, place the keyword FAST at the top of a Gambas Class file, for a class that you want all functions JIT-compiled instead of interpreted, or at the beginning of a function declaration, so that only that function is JIT-compiled.

As it takes some milliseconds for LLVM to emit machine code and do optimizations, you should only use it for functions that really need optimization.

Additional Type Checking

As the JIT compiler analyses the whole function before execution starts, some extra type safety is added. In interpreter mode, you can normally do things like: 

Print "hello"
Print 1.3 \ 5

You would first see hello on the screen, and then an error message complaining you can't do integer division on floats.

If you run the same function in the JIT compiler, the error message will be thrown before execution starts. Hopefully, this will make programs less buggy.

As a consequence, you can not have code like Try Print 1.3 \ 5 either.

Performance

The biggest increases in speed will be in functions that use a lot of low-level calculations and control flows (except For Each loops), such as functions that do a lot of math. However, if the function mostly calls other libraries, you won't see any great increase in speed.

There is still the same overhead when calling functions, since the Gambas stack must be maintained as before, to make error handling work. Using Try=/=Catch is probably slightly slower too, because a real exception handler must be set up.

Something the LLVM optimizer is very good at is transforming a chain of if-else statements to a jump table, so code like: 

Select Case x
  Case 1
    ...
  Case 2
    ...
  Case 3
    ...
End Select

will be much faster than before, so you don't have to use the ON GOTO syntax and a lot of labels. This will produce identical machine code.

Some of the benchmarks from the benchmarking page:
  • Polynom: 100 seconds to 9.2 seconds.

  • Primes: 20.4 seconds to 5.95 seconds.

  • Nbody: 20.8 seconds to 3.07 seconds.

Caveats

Most things are implemented, but there are still some features and bugs to fix.

Some of the (so far) unimplemented features are:
  • Making a callback function pointer of a Gambas function in another class, for use with external libraries.

  • Using Component.Load to load functions that are executed one right after in the same function.

  • Breakpoints.

  • Automatic conversion between classes.

Debugging

If you are curious and want to see the optimized LLVM IR, just define the GB_JIT environment variable with a non-null string.