What optimizations do modern JavaScript engines perform?

Question

By now, most mainstream browsers have started integrating optimizing JIT compilers to their JavaScript interpreters/virtual machines. That's good for everyone. Now, I'd be hard-pressed to know exactly which optimizations they do perform and how to best take advantage of them. Could anyone point me to references on optimizations in each of the major JS engines?

Background:

I'm working on a compiler that generates JavaScript from a higher-level & safer language (shameless plug: it's called OPA and it's very cool) and, given the size of applications I'm generating, I'd like my JS to be as fast and as memory-efficient as possible. I can handle high-level optimizations but I need to know more about which runtime transformations are performed, so as to know which low-level code will produce best results.

One example, from the top of my mind: the language I'm compiling will soon integrate support for laziness. Do JIT engines behave well with lazy function definitions?

Answer 1

This article series discusses the optimisations of V8. In summary:

• It generates native machine code - not bytecode (V8 Design Elements)
• Precise garbage collection (Wikipedia)
• Inline caching of called methods (Wikipedia)
• Storing class transition information so that objects with the same properties are grouped together (V8 Design Elements)

The first two points might not help you very much in this situation. The third might show insight into getting things cached together. The last might help you create objects with same properties so they use the same hidden classes.

This blog post discusses some of the optimisations of SquirrelFish Extreme:

• Bytecode optimizations
• Polymorphic inline cache (like V8)
• Context threaded JIT (introduction of native machine code generation, like V8)
• Regular expression JIT

TraceMonkey is optimised via tracing. I don't know much about it but it looks like it detects the type of a variable in some "hot code" (code run in loops often) and creates optimised code based on what the type of that variable is. If the type of the variable changes, it must recompile the code - based off of this, I'd say you should stay away from changing the type of a variable within a loop.