Re: Academic references on interpreters

growe@computing.dundee.ac.uk (Glenn Rowe) writes:
>I was wondering if anyone knows of any academic (i.e. refereed journal
>papers or books) references on the writing of interpreters
>specifically (that is, NOT compilers). I'm mainly interested in
>interpreters for languages such as C++, Java or C#, but if anyone
>knows of *any* academic references on interpreters it would still be
>helpful.


Well, one example of a journal paper is [ertl+02]. You can find some
references to related papers there.


If you are also interested in refereed workshop and conference papers,
take a look at IVME (http://www.ics.uci.edu/~franz/ivme/,
http://www.cs.tcd.ie/David.Gregg/ivme03/; the next will be held on
June 7th, 2004) and (with less interpreter content) the Usenix VM
Symposium (http://www.usenix.org/events/bytopic/vm.html). You can
also find other papers through the bibliographies of these papers. In
addition, now and then you see an interpreter paper at general
conferences like PLDI, POPL, and ASPLOS.


@Article{ertl+02,
    author = {M. Anton Ertl and David Gregg and Andreas Krall and
                                    Bernd Paysan},
    title = {\textsf{vmgen} --- A Generator of Efficient Virtual
                                    Machine Interpreters},
    journal = {Software---Practice and Experience},
    year = {2002},
    volume = {32},
    number = {3},
    pages = {265--294},
    OPTmonth = {},
    url = {http://www.complang.tuwien.ac.at/papers/ertl+02.ps.gz},
    abstract-url = {http://www3.interscience.wiley.com/cgi-bin/abstract/90010508/START},
    keywords = {interpreter; virtual machine; generator; stack
                                    architecture; superinstruction; byte code},
    abstract = {In a virtual machine interpreter, the code for each
                                    virtual machine instruction has similarities to code
                                    for other instructions. We present an interpreter
                                    generator that takes simple virtual machine
                                    instruction descriptions as input and generates C
                                    code for processing the instructions in several
                                    ways: execution, virtual machine code generation,
                                    disassembly, tracing, and profiling. The generator
                                    is designed to support efficient interpreters: it
                                    supports threaded code, caching the top-of-stack
                                    item in a register, combining simple instructions
                                    into superinstructions, and other optimizations. We
                                    have used the generator to create interpreters for
                                    Forth and Java. The resulting interpreters are
                                    faster than other interpreters for the same
                                    languages and they are typically 2-10 times slower
                                    than code produced by native-code compilers. We also
                                    present results for the effects of the individual
                                    optimizations supported by the generator.}
}


- anton
--
M. Anton Ertl
anton@mips.complang.tuwien.ac.at
http://www.complang.tuwien.ac.at/anton/home.html

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