"Register Variables" in interpreted languages

Recently there has been a fair bit of discussion in comp.compilers about
compiler register allocation for optimisation. As a developer of an
interpreted language I would like to move the discusion toward similar
optimisation tricks that can be done in interpreted environments. I am
particularly interested in expression analysis as I already have a very
fast statement interpeter. Now I use a fairly standard stack based
expression evaluator. I am interested in optimisation tricks in such an
environment. eg:


a) ways to reduce the number of push's and pops


b) notions of 'registers' to bypass the stack operations


c) methods of reducing the overhead of function calling.


etc.
NOTE: I realise there are other ways of evaluating expresions (eg: graph
reduction) that may be faster than the standard technique mentioned above,
but I am more interested in stack based evaluation.


There does not seem to much literature in optimising interpreted
languages.


Outside these sorts of small optimisations there is also the possibility
in an interpreted environment for the code to optimise itself as it runs -
for example we employ dynamic typing but remember type bindings in loops
(the code therefore self optimises at run-time). Does anyone have any
experience with optimisation as you run?


graham
--
Graham Matthews
Pure Math, Uni.Sydney, Oz
graham@maths.su.oz.au
--

Return to the comp.compilers page.
Search the comp.compilers archives again.