@InProceedings{ramsey03, author = {Norman Ramsey}, title = {Embedding an Interpreted Language Using Higher-Order Functions and Types}, booktitle = {Interpreters, Virtual Machines and Emulators (IVME~'03)}, pages = {6--14}, year = {2003}, url1 = {http://www.complang.tuwien.ac.at/anton/ivme03/proceedings/ramsey.ps.gz}, url2 = {http://portal.acm.org/ft_gateway.cfm?id=858571&type=pdf}, abstract = {Using an embedded, interpreted language to control a complicated application can have significant software-engineering benefits. But existing interpreters are designed for embedding into C code. To embed an interpreter into a different language requires a suitable API. Lua-ML is a new API that uses higher-order functions and types to simplify the use of an embedded interpreter. A typical application-program function can be added to a Lua-ML interpreter simply by describing the function's type.} } @InProceedings{liu&moore03, author = {Hanbing Liu and J. Strother Moore}, title = {Executable JVM Model for Analytical Reasoning: A Study}, booktitle = {Interpreters, Virtual Machines and Emulators (IVME~'03)}, pages = {15--23}, year = {2003}, url1 = {http://www.complang.tuwien.ac.at/anton/ivme03/proceedings/liu.ps.gz}, url2 = {http://portal.acm.org/ft_gateway.cfm?id=858572&type=pdf}, abstract = {To study the properties of the Java Virtual Machine(JVM) and Java programs, our research group has produced a series of JVM models written in a functional subset of Common Lisp. In this paper, we present our most complete JVM model from this series, namely, M6, which is derived from a careful study of the J2ME KVM[16] implementation.} } @InProceedings{franz+03, author = {Michael Franz and Deepak Chandra and Andreas Gal and Vivek Haldar and Fermin Reig and Ning Wang}, title = {A Portable Virtual Machine Target for Proof-Carrying Code}, booktitle = {Interpreters, Virtual Machines and Emulators (IVME~'03)}, pages = {24--31}, year = {2003}, url1 = {http://www.complang.tuwien.ac.at/anton/ivme03/proceedings/franz.ps.gz}, url2 = {http://portal.acm.org/ft_gateway.cfm?id=858573&type=pdf}, abstract = {Virtual Machines (VMs) and Proof-Carrying Code (PCC) are two techniques that have been used independently to provide safety for (mobile) code. Existing virtual machines, such as the Java VM, have several drawbacks: First, the effort required for safety verification is considerable. Second and more subtly, the need to provide such verification by the code consumer inhibits the amount of optimization that can be performed by the code producer. This in turn makes just-in-time compilation surprisingly expensive. Proof-Carrying Code, on the other hand, has its own set of limitations, among which are the sizes of the proofs and the fact that the certified code is no longer machine-independent. In this paper, we describe work in progress on combining these approaches. Our hybrid safe-code solution uses a virtual machine that has been designed specifically to support proof-carrying code, while simultaneously providing efficient just-in-time compilation and target-machine independence. In particular, our approach reduces the complexity of the required proofs, resulting in fewer proof obligations that need to be discharged at the target machine. } } @InProceedings{lattendresse&feeley03, author = {Mario Latendresse and Marc Feeley}, title = {Generation of Fast Interpreters for {Huffman} Compressed Bytecode}, booktitle = {Interpreters, Virtual Machines and Emulators (IVME~'03)}, pages = {32--40}, year = {2003}, url1 = {http://www.complang.tuwien.ac.at/anton/ivme03/proceedings/latendresse.ps.gz}, url2 = {http://portal.acm.org/ft_gateway.cfm?id=858574&type=pdf}, abstract = {Embedded systems often have severe memory constraints requiring careful encoding of programs. For example, smart cards have on the order of 1K of RAM, 16K of non-volatile memory, and 24K of ROM. A virtual machine can be an effective approach to obtain compact programs but instructions are commonly encoded using one byte for the opcode and multiple bytes for the operands, which can be wasteful and thus limit the size of programs runnable on embedded systems. Our approach uses canonical Huffman codes to generate compact opcodes with custom-sized operand fields and with a virtual machine that directly executes this compact code. We present techniques to automatically generate the new instruction formats and the decoder. In effect, this automatically creates both an instruction set for a customized virtual machine and an implementation of that machine. We demonstrate that, without prior decompression, fast decoding of these virtual compressed instructions is feasible. Through experiments on Scheme and Java, we demonstrate the speed of these decoders. Java benchmarks show an average execution slowdown of 9%. Compression factors highly depend on the original bytecode and the training sample, but typically vary from 30% to 60%. } } @InProceedings{davis+03, author = {Brian Davis and Andrew Beatty and Kevin Casey and David Gregg and John Waldron}, title = {The Case for Virtual Register Machines}, booktitle = {Interpreters, Virtual Machines and Emulators (IVME~'03)}, pages = {41--49}, year = {2003}, url1 = {http://www.complang.tuwien.ac.at/anton/ivme03/proceedings/davis.ps.gz}, url2 = {http://portal.acm.org/ft_gateway.cfm?id=858575&type=pdf}, abstract = {Virtual machines (VMs) are a popular target for language implementers. Conventional wisdom tells us that virtual stack architectures can be implemented with an interpreter more efficiently, since the location of operands is implicit in the stack pointer. In contrast, the operands of register machine instructions must be specified explicitly. In this paper, we present a working system for translating stack-based Java virtual machine (JVM) code to a simple register code. We describe the translation process, the complicated parts of the JVM which make translation more difficult, and the optimisations needed to eliminate copy instructions. Experimental results show that a register format reduces the number of executed instructions by 34.88%, while increasing the number of bytecode loads by an average of 44.81%. Overall, this corresponds to an increase of 2.32 loads for each dispatch removed. We believe that the high cost of dispatches makes register machines attractive even at the cost of increased loads.} } @InProceedings{sullivan+03, author = {Gregory T. Sullivan and Derek L. Bruening and Iris Baron and Timothy Garnett and Saman Amarasinghe}, title = {Dynamic Native Optimization of Interpreters}, booktitle = {Interpreters, Virtual Machines and Emulators (IVME~'03)}, pages = {50--57}, year = {2003}, url1 = {http://www.complang.tuwien.ac.at/anton/ivme03/proceedings/sullivan.ps.gz}, url2 = {http://portal.acm.org/ft_gateway.cfm?id=858576&type=pdf}, abstract = {For domain specific languages, "scripting languages", dynamic lan- guages, and for virtual machine-based languages, the most straight-forward implementation strategy is to write an interpreter. A simple interpreter consists of a loop that fetches the next bytecode, dispatches to the routine handling that bytecode, then loops. There are many ways to improve upon this simple mechanism, but as long as the execution of the program is driven by a representation of the program other than as a stream of native instructions, there will be some "interpretive overhead".\par There is a long history of approaches to removing interpretive overhead from programming language implementations. In practice, what often happens is that, once an interpreted language becomes popular, pressure builds to improve performance until eventually a project is undertaken to implement a native Just In Time (JIT) compiler for the language. Implementing a JIT is usually a large effort, affects a significant part of the existing language implementation, and adds a significant amount of code and complexity to the overall code base.\par In this paper, we present an innovative approach that dynamically removes much of the interpreted overhead from language implementations, with minimal instrumentation of the original interpreter. While it does not give the performance improvements of hand-crafted native compilers, our system provides an appealing point on the language implementation spectrum.} } @InProceedings{whaley03, author = {John Whaley}, title = {Joeq: A Virtual Machine and Compiler Infrastructure}, booktitle = {Interpreters, Virtual Machines and Emulators (IVME~'03)}, pages = {58-66}, year = {2003}, url1 = {http://www.complang.tuwien.ac.at/anton/ivme03/proceedings/whaley.ps.gz}, url2 = {http://portal.acm.org/ft_gateway.cfm?id=858577&type=pdf}, abstract = {Joeq is a virtual machine and compiler infrastructure designed to facilitate research in virtual machine technologies such as Just-In-Time and Ahead-Of-Time compilation, advanced garbage collection techniques, distributed computation, sophisticated scheduling algorithms, and advanced run time techniques. Joeq is entirely implemented in Java, leading to reliability, portability, maintainability, and efficiency. It is also language-independent, so code from any supported language can be seamlessly compiled, linked, and executed - all dynamically. Each component of the virtual machine is written to be independent with a general but well-defined interface, making it easy to experiment with new ideas. Joeq is released as open source software, and is being used as a framework by researchers all over the world on topics ranging from automatic distributed virtual machines to whole-program pointer analysis.} } @InProceedings{palacz+03, author = {K. Palacz and J. Baker and C. Flack and C. Grothoff and H. Yamauchi and J. Vitek}, title = {Engineering a Customizable Intermediate Representation}, booktitle = {Interpreters, Virtual Machines and Emulators (IVME~'03)}, pages = {67--76}, year = {2003}, url1 = {http://www.complang.tuwien.ac.at/anton/ivme03/proceedings/palacz.ps.gz}, url2 = {http://portal.acm.org/ft_gateway.cfm?id=858578&type=pdf}, abstract = {The Ovm framework is a set of tools and components for building language runtimes. We present the intermediate representation and software design patterns used throughout the framework. One of the main themes in this work has been to support experimentation with new linguistic constructs and implementation techniques. To this end, framework components were designed to be parametric with respect to the instruction set on which they operate. We argue that our approach eases the task of writing new components without sacrificing efficiency.} } @Proceedings{ivme03, title = {Interpreters, Virtual Machines and Emulators (IVME~'03)}, booktitle = {Interpreters, Virtual Machines and Emulators (IVME~'03)}, year = {2003}, key = {IVME~'03}, editor = {M. Anton Ertl}, url = {http://www.complang.tuwien.ac.at/anton/ivme03/proceedings/ivme.ps.gz}, url2 = {http://portal.acm.org/toc.cfm?id=858570&type=proceeding} }