一句话：通过 RPython 与 GraalVM 实现成对解释器，实证 AST 解释器在元编译系统中与字节码解释器性能相当且内存权衡不同。
元编译与元追踪使仅实现解释器即可获得接近最先进的峰值性能，但此类系统仍需改善内存占用与预热。论文检验“字节码解释器在内存和运行时性能上优于 AST 解释器”的假设，在 RPython 与 GraalVM 上分别实现 AST 与字节码解释器，并尽量缩小二者差异，以评估纯解释器性能、峰值性能、预热、内存占用及单项优化影响。结果显示，两系统均接近 Node.js/V8；纯解释执行时 AST 解释器与字节码相当甚至略快，JIT 后大致持平，说明字节码并无普遍性能优势。字节码在内存中更紧凑，利于大型应用；但小型应用因装箱消除受限及具象化栈等结构，字节码解释器反而分配更多内存。
Thanks to partial evaluation and meta-tracing, it became practical to build language implementations that reach state-of-the-art peak performance by implementing only an interpreter. Systems such as RPython and GraalVM provide components such as a garbage collector and just-in-time compiler in a language-agnostic manner, greatly reducing implementation effort. However, meta-compilation-based language implementations still need to improve further to reach the low memory use and fast warmup behavior that custom-built systems provide. A key element in this endeavor is interpreter performance. Folklore tells us that bytecode interpreters are superior to abstract-syntax-tree (AST) interpreters both in terms of memory use and run-time performance. This work assesses the trade-offs between AST and bytecode interpreters to verify common assumptions and whether they hold in the context of meta-compilation systems. We implemented four interpreters, each an AST and a bytecode one using RPython and GraalVM. We keep the difference between the interpreters as small as feasible to be able to evaluate interpreter performance, peak performance, warmup, memory use, and the impact of individual optimizations. Our results show that both systems indeed reach performance close to Node.js/V8. Looking at interpreter-only performance, our AST interpreters are on par with, or even slightly faster than their bytecode counterparts. After just-in-time compilation, the results are roughly on par. This means bytecode interpreters do not have their widely assumed performance advantage. However, we can confirm that bytecodes are more compact in memory than ASTs, which becomes relevant for larger applications. However, for smaller applications, we noticed that bytecode interpreters allocate more memory because boxing avoidance is not as applicable, and because the bytecode interpreter structure requires memory, e.g., for a reified stack. Our results show AST interpreters to be competitive on top of meta-compilation systems. Together with possible engineering benefits, they should thus not be discounted so easily in favor of bytecode interpreters.
@article{paperbot1892,
title = {AST vs. Bytecode: Interpreters in the Age of Meta-Compilation},
author = {Octave Larose and Sophie Kaleba and Humphrey Burchell and Stefan Marr},
journal = {Proceedings of the ACM on Programming Languages},
volume = {7},
number = {OOPSLA2},
year = {2023},
doi = {10.1145/3622808}
}