ACM Home Page
Please provide us with feedback. Feedback
YETI: a graduallY extensible trace interpreter
Full text PdfPdf (205 KB)
Source
ACM/Usenix International Conference On Virtual Execution Environments archive
Proceedings of the 3rd international conference on Virtual execution environments table of contents
San Diego, California, USA
SESSION: Compilation table of contents
Pages: 83 - 93  
Year of Publication: 2007
ISBN:978-1-59593-630-1
Authors
Mathew Zaleski  University of Toronto, Toronto, ON, Canada
Angela Demke Brown  University of Toronto, Toronto, ON, Canada
Kevin Stoodley  IBM, Toronto, ON, Canada
Sponsors
SIGPLAN: ACM Special Interest Group on Programming Languages
SIGOPS: ACM Special Interest Group on Operating Systems
ACM: Association for Computing Machinery
Publisher
ACM  New York, NY, USA
Bibliometrics
Downloads (6 Weeks): 9,   Downloads (12 Months): 92,   Citation Count: 0
Additional Information:

abstract   references   index terms   collaborative colleagues  

Tools and Actions: Review this Article  
Save this Article to a Binder    Display Formats: BibTex  EndNote ACM Ref   
DOI Bookmark: Use this link to bookmark this Article: http://doi.acm.org/10.1145/1254810.1254823
What is a DOI?

ABSTRACT

The design of new programming languages benefits from interpretation, which can provide a simple initial implementation, flexibility to explore new language features, and portability to many platforms. The only downside is speed of execution, as there remains a large performance gap between even efficient interpreters and mixed-mode systems that include a just-in-time compiler (or JIT for short). Augmenting an interpreter with a JIT, however, is not a small task. Today, JITs used for Java™ are loosely-coupled with the interpreter, with callsites of methods being the only transition point between interpreted and native code. To compile whole methods, the JIT must duplicate a sizable amount of functionality already provided by the interpreter, leading to a "big bang" development effort before the JIT can be deployed. Instead, adding a JIT to an interpreter would be easier if it were possible to leverage the existing functionality.

In earlier work we showed that packaging virtual instructions as lightweight callable routines is an efficient way to build an interpreter. In this paper we describe how callable bodies help our interpreter to efficiently identify and run traces. Our closely coupled dynamic compiler can fall back on the interpreter in various ways, permitting an incremental approach in which additional performance gains can be realized as it is extended in two dimensions: (i) generating code for more types of virtual instructions, and (ii) identifying larger compilation units. Currently, Yeti identifies straight line regions of code and traces, and generates non-optimized code for roughly 50 Java integer and object bytecodes. Yeti runs roughly twice as fast as a direct-threaded interpreter on SPECjvm98 benchmarks.


REFERENCES

Note: OCR errors may be found in this Reference List extracted from the full text article. ACM has opted to expose the complete List rather than only correct and linked references.

1
 
2
 
3
D. Bruening and E. Duesterwald. Exploring optimal compilation unit shapes for an embedded just-in-time compiler. In Proc. of the 3rd ACM Workshop on Feedback-Directed and Dynamic Optimization (FDDO-3), Dec. 2000.
 
4
 
5
W.-K. Chen, S. Lerner, R. Chaiken, and D. Gillies. Mojo: A dynamic optimization system. In Proc. of the 3rd ACMWorkshop on Feedback-Directed and Dynamic Optimization (FDDO-3), Dec. 2000.
 
6
 
7
8
9
10
 
11
E. Gagnon and L. Hendren. Effective inline threading of Java bytecode using preparation sequences. In Proc. of the 12th Intl. Conf. on Compiler Construction, volume 2622 of Lecture Notes in Computer Science, pages 170--184. Springer, Apr. 2003.
12
 
13
 
14
 
15
U. Hölzle. Adaptive Optimization For Self:Reconciling High Performance With Exploratory Programming. PhD thesis, Stanford University, 1994.
 
16
R. Lougher. JamVM {online}. Available from: http://jamvm.sourceforge.net/.
 
17
18
 
19
I. Piumarta. Ccg: A tool for writing dynamic code generators. In OOPSLA'99 Workshop on simplicity, performance and portability in virtual machine design, Nov. 1999.
20
 
21
SPECjvm98 benchmarks {online}. 1998. Available from: http://www.spec.org/osg/jvm98/.
 
22
D. Sugalski. Implementing an interpreter {online}. Available from: http://www.sidhe.org/%7Edan/presentations/Parrot%20Implementation.ppt. Notes for slide 21.
 
23
24
 
25
 
26
27

Collaborative Colleagues:
Mathew Zaleski: colleagues
Angela Demke Brown: colleagues
Kevin Stoodley: colleagues