%0 Report %1 brunthaler2013speculative %A Brunthaler, Stefan %D 2013 %K Bytecode Interpreter Optimization Quickening %N arXiv:1310.2300 %T Speculative Staging for Interpreter Optimization %U http://arxiv.org/abs/1310.2300 %X Interpreters have a bad reputation for having lower performance than just-in-time compilers. We present a new way of building high performance interpreters that is particularly effective for executing dynamically typed programming languages. The key idea is to combine speculative staging of optimized interpreter instructions with a novel technique of incrementally and iteratively concerting them at run-time. This paper introduces the concepts behind deriving optimized instructions from existing interpreter instructions---incrementally peeling off layers of complexity. When compiling the interpreter, these optimized derivatives will be compiled along with the original interpreter instructions. Therefore, our technique is portable by construction since it leverages the existing compiler's backend. At run-time we use instruction substitution from the interpreter's original and expensive instructions to optimized instruction derivatives to speed up execution. Our technique unites high performance with the simplicity and portability of interpreters---we report that our optimization makes the CPython interpreter up to more than four times faster, where our interpreter closes the gap between and sometimes even outperforms PyPy's just-in-time compiler.

@techreport{brunthaler2013speculative, abstract = {Interpreters have a bad reputation for having lower performance than just-in-time compilers. We present a new way of building high performance interpreters that is particularly effective for executing dynamically typed programming languages. The key idea is to combine speculative staging of optimized interpreter instructions with a novel technique of incrementally and iteratively concerting them at run-time. This paper introduces the concepts behind deriving optimized instructions from existing interpreter instructions---incrementally peeling off layers of complexity. When compiling the interpreter, these optimized derivatives will be compiled along with the original interpreter instructions. Therefore, our technique is portable by construction since it leverages the existing compiler's backend. At run-time we use instruction substitution from the interpreter's original and expensive instructions to optimized instruction derivatives to speed up execution. Our technique unites high performance with the simplicity and portability of interpreters---we report that our optimization makes the CPython interpreter up to more than four times faster, where our interpreter closes the gap between and sometimes even outperforms PyPy's just-in-time compiler.}, added-at = {2014-03-19T15:32:19.000+0100}, author = {Brunthaler, Stefan}, biburl = {https://www.bibsonomy.org/bibtex/2fe7b1cff7918fee4502adc33dcbff1c6/gron}, description = {Speculative Staging for Interpreter Optimization}, interhash = {55f5f015ec5d67d89aac9d634de8ec8e}, intrahash = {fe7b1cff7918fee4502adc33dcbff1c6}, keywords = {Bytecode Interpreter Optimization Quickening}, month = {October}, number = {arXiv:1310.2300}, timestamp = {2014-03-19T15:32:19.000+0100}, title = {Speculative Staging for Interpreter Optimization}, url = {http://arxiv.org/abs/1310.2300}, year = 2013 }