M. Ertl. Proceedings of the ACM SIGPLAN 1995 Conference on Programming Language Design and Implementation, page 315--327. ACM, (1995)
DOI: 10.1145/207110.207165
Abstract
An interpreter can spend a significant part of its execution time on accessing arguments of virtual machine instructions. This paper explores two methods to reduce this overhead for virtual stack machines by caching top-of-stack values in (real machine) registers. The dynamic method is based on having, for every possible state of the cache, one specialized version of the whole interpreter; the execution of an instruction usually changes the state of the cache and the next instruction is executed in the version corresponding to the new state. In the static method a state machine that keeps track of the cache state is added to the compiler. Common instructions exist in specialized versions for several states, but it is not necessary to have a version of every instruction for every cache state. Stack manipulation instructions are optimized away.
%0 Conference Paper
%1 Ertl:1995:Stack
%A Ertl, M. Anton
%B Proceedings of the ACM SIGPLAN 1995 Conference on Programming Language Design and Implementation
%D 1995
%I ACM
%K Cache Caching Interpreter Stack
%P 315--327
%R 10.1145/207110.207165
%T Stack Caching for Interpreters
%U http://portal.acm.org/citation.cfm?id=207165
%X An interpreter can spend a significant part of its execution time on accessing arguments of virtual machine instructions. This paper explores two methods to reduce this overhead for virtual stack machines by caching top-of-stack values in (real machine) registers. The dynamic method is based on having, for every possible state of the cache, one specialized version of the whole interpreter; the execution of an instruction usually changes the state of the cache and the next instruction is executed in the version corresponding to the new state. In the static method a state machine that keeps track of the cache state is added to the compiler. Common instructions exist in specialized versions for several states, but it is not necessary to have a version of every instruction for every cache state. Stack manipulation instructions are optimized away.
@inproceedings{Ertl:1995:Stack,
abstract = {An interpreter can spend a significant part of its execution time on accessing arguments of virtual machine instructions. This paper explores two methods to reduce this overhead for virtual stack machines by caching top-of-stack values in (real machine) registers. The dynamic method is based on having, for every possible state of the cache, one specialized version of the whole interpreter; the execution of an instruction usually changes the state of the cache and the next instruction is executed in the version corresponding to the new state. In the static method a state machine that keeps track of the cache state is added to the compiler. Common instructions exist in specialized versions for several states, but it is not necessary to have a version of every instruction for every cache state. Stack manipulation instructions are optimized away.},
added-at = {2009-08-14T13:57:41.000+0200},
author = {Ertl, M. Anton},
biburl = {https://www.bibsonomy.org/bibtex/2c635875b85fae030ef3260e501470b7d/gron},
booktitle = {Proceedings of the ACM SIGPLAN 1995 Conference on Programming Language Design and Implementation},
description = {Stack caching for interpreters},
doi = {10.1145/207110.207165},
interhash = {fae69c9bdeb38d10e254ab49c4da4627},
intrahash = {c635875b85fae030ef3260e501470b7d},
issn = {0362-1340},
keywords = {Cache Caching Interpreter Stack},
pages = {315--327},
publisher = {ACM},
series = {PLDI'95},
timestamp = {2019-09-04T22:55:00.000+0200},
title = {{Stack Caching for Interpreters}},
url = {http://portal.acm.org/citation.cfm?id=207165},
year = 1995
}