Archive of posts with the tag just-in-time compilation

• Jul 5, 2017 A 10 Year Journey, Stop 5: Growing the SOM Family

  

• Jan 12, 2016 Type Hierarchies and Guards in Truffle Languages

  Continuing a little bit with writing notes on Truffle and Graal, this one is based on my observations in SOMns and changes to its message dispatch mechanism. Specifically, I refactored the main message dispatch chain in SOMns. As in Self and Newspeak, all interactions with objects are message sends. Thus, field access and method invocation is essentially the same. This means that message sending is a key to good performance.

• Dec 8, 2015 Add Graal JIT Compilation to Your JVM Language in 5 Easy Steps, Step 5

  Step 5: Optimizing the Interpreter for Compilation

• Dec 1, 2015 Add Graal JIT Compilation to Your JVM Language in 5 Easy Steps, Step 4

  Step 4: Complete Support for Mandelbrot

• Nov 24, 2015 Add Graal JIT Compilation to Your JVM Language in 5 Easy Steps, Step 3

  Step 3: Interpreting a Simple Fibonacci Function with Golo+Truffle

• Nov 17, 2015 Add Graal JIT Compilation to Your JVM Language in 5 Easy Steps, Step 2

  Step 2: Adding Bit Operations To Golo

• Nov 10, 2015 Add Graal JIT Compilation to Your JVM Language in 5 Easy Steps, Step 1

  Over the course of the next four weeks, I plan to publish a new post every Tuesday to give a detailed introduction on how to use the Graal compiler and the Truffle framework to build fast languages. And this is the very first post to setup this series. The next posts are going to provide a bit of background on Golo, the language we are experimenting with, then build up the basic interpreter for executing a simple Fibonacci and later a Mandelbrot computation. To round off the series, we will also discuss how to use one of the tools that come with Graal to optimize the performance of an interpreter. But for today, let’s start with the basics.

• Oct 19, 2015 Tracing vs. Partial Evaluation: Comparing Meta-Compilation Approaches for Self-Optimizing Interpreters

  Back in 2013 when looking for a way to show that my ideas on how to support concurrency in VMs are practical, I started to look into meta-compilation techniques. Truffle and RPython are the two most promising systems to build fast language implementations without having to implement a compiler on my own. While these two approaches have many similarities, from a conceptual perspective, they take two different approaches that can be seen as the opposite ends of a spectrum. So, I thought, it might be worthwhile to investigate them a little closer.