The third post of this series is about how I started using Truffle and Graal, pretty much 4 years ago. It might be in parts ranty, but I started using it when it was in a very early stage. So, things are a lot better today.

Concurrency needs Performance, usually

As mentioned in the last post, the result of my PhD was an ownership-based metaobject protocol that is meant to enable VMs to support a wide range of different concurrency models. The major problem with the approach, and also my evaluation, was that I couldn’t show that it is practical. The RoarVM is a simple bytecode interpreter, and the literature on compiling and optimizing metaobject protocols talked only about static systems with restrictions that would make the ownership-based MOP impossible. Worse, MOPs were kind of abandoned by the research community, because performance was an issue. Many researchers moved on to aspect-oriented approaches, at least in part, because aspects are applied more targeted and thus, incur less general overhead than MOPs.

A hard problem, abandoned for 20 years, and nobody really interested in it anymore? Pretty much sounds like it’s a stupid idea, right? It probably was, and perhaps still is. But concurrency researchers typically want to show that their techniques are useful for performance critical applications. And, I wanted to do that, too.

How to get a fast VM?

So, I needed a new platform for my research. One option would have been to take the RoarVM all the way. Build a state-of-the-art JIT compiler for it. Another would be to apply the ideas of the RoarVM to the CogVM and improve its JIT compiler. But building another JIT compiler? That’s a huge undertaking. Would probably take a few person years to get anywhere useful. And, while I am curious about compilers, I am not really seeing myself building more than a baseline JIT compiler.

But what other options do we have? RPython is a pretty interesting project. It promises you a meta-tracing JIT compiler for your simple interpreter. Sounds great. But there’s a catch: RPython doesn’t really have a concurrency story compatible with my goals. There’s a bit of experimenting with STM going on, but no decent shared-memory GC.

And then, there was that Truffle thing, colleagues from Oracle Labs kept talking about. It was just released as open source at that point. Truffle promised that simple AST-based interpreters combined with partial evaluation would run applications as fast as Java on a JVM. Sounds great. And, the JVM got everything I need for my research, too.

TruffleSOM: The first steps with a simple Smalltalk on top of Truffle

Truffle it is, I thought, and started implementing the little Smalltalk I had been toying around with in 2007 on top of it. There was already a Java version, simply called SOM. So, how hard could it be?

Well, turns out, much harder than expected. Me being not really a compiler person, I had no intuition for how partial evaluation would work on my interpreter. And as a testament to how hard it was for me, apparently even to this date, I am third in the ranking of who spammed the graal-dev mailing list most.

I suppose there were three important reasons for it. As I mentioned before, I had no intuition of how the partial evaluation really works, and what kind of optimizations I can expect from the systems. The second reason was that I did not really have access to the expertise. Mailing lists are fine but slow. And people need to be willing to take the time to answer. So, during my endeavor of building a fast Smalltalk, the most helpful conversations were actually in person at conferences with people from the Truffle team, or when I actually got the chance to visit them in Linz. And the third reason, which is fixed by now, was the overall stability of the system. To me it was very surprising that I ran into many bugs in Truffle and the Graal compiler. I could somehow not really believe that the Truffle team didn’t encounter those issues with their JavaScript and Ruby implementations. But as it turns out, each new language implementation does things somewhat different and the languages are just different enough to trigger new edge cases that haven’t been considered before. As far as I know, there is still a little of that happening today with Graal. Every new language leads to one or two bugs being discovered that none of the previous languages hit.

How can this be sooo hard???

All in all, my experience to build a new language with Truffle and Graal was far from pleasant. On the contrary, it was frustrating. I often just didn’t have the knowledge to debug problems myself. And the Truffle team didn’t really have time to teach an outsider all those basics.

So, yeah, I was very close to throwing in the towel. Well, I actually kind of did. At least a little. There was a moment of “fuck this, how can it be so hard? screw Truffle! Let’s look into RPython!”

And PySOM was born. PySOM is a literal port of the SOM bytecode interpreter to Python. SOM is really a simple and small language. If you know what you’re doing, and can type reasonably fast, you can implement it in 3 or 4 days in a new language.

PySOM was the first step. The next step was RPySOM: a port from Python to RPython, which is the Python subset that the RPython toolchain can compile statically into a fast interpreter with a meta-tracing JIT compiler. This experience was sooo much more pleasant. One big reason was that the PyPy+RPython community uses an IRC channel for communication and was super friendly and happy to help with all my problems. Another reason was that I knew Carl Friedrich, one of the PyPy people already for a while, and he guided me through the classic pit falls. And, I suppose, RPython at that point was already much more mature than Truffle used to be. So, fewer crashes, and I think, I didn’t really trigger much bugs in RPython either. And, since it is a trace-based compiler, understanding what the optimizer did was also much easier, because the result mapped much more directly back to the input code of the interpreter than with a fancy graph-based compiler IR. So, yeah, RPySOM was born, and with that additional knowledge, I kind of managed to make TruffleSOM a reality, too.

Some of this story, and what we learned was written down in the Are We There Yet? article.

And Finally, Fast Metaprogramming!

Then it was time to get back to my original problem: how do I get my ownership-based metaobject protocol fast? Well, turns out if you got a fancy JIT compiler, the solution is pretty simple and already existed in other Truffle interpreters: dispatch chains. Dispatch chains are essentially lexical caches for dispatch operations. A generalization of polymorphic inline caches if you will.

Together with Chris Seaton, we published a paper on Zero-Overhead Meta Programming, where we were able to show how all kind of reflective operations can be made fast, and were I was finally able to show that my metaobject protocol can be realized without sacrificing performance.

A bit later, I also wrote up a longer paper comparing meta-tracing and partial evaluation in more detail.

Cutting a long story short: nothing is as easy as it sounds. In total, it took me two years to go from a simple Smalltalk AST interpreter to a system that can take on Java. But, things should be better today. When starting to implement a new language with Truffle, there are now a few tutorials, and other resources, and the platform is much more mature and pleasant to use!

Next week, I might take a break from this series, but there are at least two more posts coming:

• Concurrency and Tooling, or ‘What is project MetaConc?’
• and, Growing the SOM Family