TigerShrimp: An Understandable Tracing JIT Compiler

Abstract

Tracing Just-in-Time (JIT) compilers have been used for compiling programs that regular compilers struggle with. The difference is clearest in dynamically typed languages such as JavaScript and Python where very little is know about a program’s behavior before run-time. During run-time, tracing JIT compilers look for loops in the code and only compile the most commonly taken path through these loops. Since compilation is a time consuming process, the idea is to only compile code that is run frequently enough for it to make up the time it takes to compile it. This works on the assumption that a program spends most of its execution time inside a few loops. Commercial tracing JIT compilers are very complex systems integrating many functionalities into a highly efficient program. As such, the general ideas behind tracing JIT compilers can be quite difficult to understand from reading about these compilers. This project explores the possibility of creating a smaller scale tracing JIT compiler with the main objective of making it understandable. As far as we know, this is the first tracing JIT compiler with this stated objective. Our tracing JIT compiler is designed for understandability meaning much effort was put into separating the different parts that make up a tracing JIT compiler into distinct modules, giving a clear overview of the responsibilities of the different parts and how they interact. Another aspect of understandability is the run-time visualizing toolkit developed alongside the tracing JIT compiler, this allows for insight into otherwise unseen functionality of the compiler. Performance of the compiler is not the main objective of this project, despite this, we show results highlighting the potential of tracing JIT compilers where our compiler in some cases outperform the OpenJDK JVM.