Implementing a JIT-compiler with Rust | Hacker News Reader

Implementing a JIT-compiler with Rust

dinfuehr.github.io

126 pointsristem17 comments

What I especially like about this is getting the infrastructure needed to implement copying GC in early. This is really important to add at the beginning. It's very costly to add it later once you have an entire production-quality engine built on top of non-moving or conservative GC.

(In fact I only know of one project that successfully made the transition from conservative to precise moving GC after many years of deployment: SpiderMonkey.)

I believe Go initially had a conservative collector for the stack and switched to precise:

https://github.com/golang/go/issues/5134

Go doesn't use moving GC. (Though the work needed to implement precise GC gets you a lot of the way to moving GC.)

And given how much bad cgo code is out there i doubt they can ever change this.

I wasn't aware of that. This is why you do moving GC early!

Do you have more information on this? That sounds like very bad news for Go...

Aside from the difficulty of changing, can you give a couple of sentences on the pros/cons?

Are "moving GCs" mostly good for reducing fragmentation? I guess you'd get fewer annoying "holes" if you can compact memory, and better cache behaviour if live objects tend to be nearer to each other.

pcwalton has been outlining the cons of Go's GC on HN for quite some time :)

https://duckduckgo.com/?q=pcwalton+go+gc+site%3Aycombinator....

What do you think of the newer WebKit GC scheme where they removed compaction?

For a simple baseline JIT like that, you can improve the quality of the generated code a lot at basically no compile-time cost (still one pass) by doing some flavor of "destination driven code generation".

It also adds very little complexity to the compiler itself so it's a nice win.

I introduced myself to Rust by writing a compiler. It was a real trial-by-fire thanks to how tree structures have to be handled with the borrow checker.

> It was a real trial-by-fire thanks to how tree structures have to be handled with the borrow checker.

Eh, without parent-pointers you can just use a Box<T> in the obvious way. For more elaborate graphs you'd use arena allocation. Maybe not something a beginner would realize, but it's not that hard

It gets a lot hairier if you want to mutate anything, though.

>without parent-pointers

Well I had them. As soon as I realised it wasn't trivial I wanted to know how to do it and why it couldn't be trivial.

>Maybe not something a beginner would realize, but it's not that hard

It's OK to be bad at new things.

Just write an interpreter. Any compiler worth its salt will translate that interpreter into a JIT. ;)

Are you advocating writing an unoptimized interpreter and simply sending its IR to some optimizing backend?

Can you give us some examples of such compilers that are worth their salt?

Both PyPy and Truffle work this way.

Reply on news.ycombinator.com