I've remarked several times in the past that I'd like to get rid of the VM implementation that currently runs most Epoch code. This is motivated by a few factors, but primarily performance and a desire to eliminate duplication. As it stands, the VM is redundant for any Epoch features that can be JITted into native code - which is a subset of all implemented Epoch functionality, but a rapidly growing subset.
Tonight, though, I ran into what amounts to the last straw for the VM.
There is an obscure test failure in the compiler test suite at the moment, related to algebraic sum types and aggregate constructors generated by the compiler. In a nutshell, the problem is that the Epoch function calling convention allows algebraic sum types to be passed to functions "compacted" while the JIT calling convention expects sum typed values to be passed full-size.
An example might help illuminate things.
Suppose we define the following sum type:
type Fictional : integer | boolean
If we pass a value of this Fictional type to a function, the Epoch VM will do one of two things, based on the actual concrete type of the value. If the Fictional variable holds an integer, the VM pushes 4 bytes onto the stack. On the other hand, if the variable holds a boolean, the VM pushes only one byte. In both cases, a type signature is also placed on the stack, so the VM knows how many bytes to retrieve from the stack when the invoked function goes to read the variable.
The JITter, on the other hand, will always pass 4 bytes - because that's the largest size that the sum type can hold.
This becomes a problem when VM-executed code needs to interact with native JITted code. In particular, the problem with the compiler test suite is that all constructors generated by the compiler are JITted by default. So if I define an aggregate (structure) type that contains a sum type, the constructor will have a sum-typed parameter. When the JITted constructor goes to read that parameter, it might walk off the end of the stack frame if the value passed is smaller than the maximum size of the sum type.
After ferreting out the details of this bug, I found myself confronted with a couple of options, none of which seem particularly appealing:
- Only call native constructors from native code. This would pass the tests, but fail again for user-defined native functions accepting sum-typed parameters if they ever happened to be called from the VM, thereby merely deferring the bug until later.[/*]
- Modify the calling convention of the VM to match the JITter. This is less than savory because it involves maintaining VM code which I'm trying to kill off.[/*]
- Modify the JITter to match the VM. This is even worse than modifying the VM, because the JITter gets substantial simplicity and speed boosts from not needing to handle unpredictable stack frame sizes.[/*]
I pondered these choices for a while, and finally decided to take the simple way out.
I'm killing the VM now rather than later. The only real major functionality left in the VM is marshaling between Epoch and C libraries, and that isn't terribly hard to port to the JITter. There will be some work required to get the compilation test suite passing as pure native code, but it's all stuff I'd have to do eventually anyways.
The bottom line is that there's really no point in keeping the VM on life support any longer. It was a useful bootstrapping construct, but its time has come and gone, and now I want it dead.
So my project for the next week or so is to strip out the VM and get all of Epoch running as native code. Considering that the raytracer is already mostly native, and marshaling is the only major area left to port, it shouldn't be a total nightmare.
Famous last words, I suppose.