Vortex: an optimizing compiler for object-oriented languages

Previously, techniques such as class hierarchy analysis and profile-guided receiver class prediction have been demonstrated to greatly improve the performance of applications written in pure object-oriented languages, but the degree to which these results are transferable to applications written in hybrid languages has been unclear. In part to answer this question, we have developed the Vortex compiler infrastructure, a language-independent optimizing compiler for object-oriented languages, with front-ends for Cecil, C++, Java, and Modula-3. In this paper, we describe the Vortex compiler's intermediate language, internal structure, and optimization suite, and then we report the results of experiments assessing the effectiveness of different combinations of optimizations on sizable applications across these four languages. We characterize the benchmark programs in terms of a collection of static and dynamic metrics, intended to quantify aspects of the "object-orientedness" of a program.

[1]  David Robson,et al.  Smalltalk-80: The Language and Its Implementation , 1983 .

[2]  L. Peter Deutsch,et al.  Efficient implementation of the smalltalk-80 system , 1984, POPL.

[3]  Alfred V. Aho,et al.  Compilers: Principles, Techniques, and Tools , 1986, Addison-Wesley series in computer science / World student series edition.

[4]  Randall B. Smith,et al.  SELF: The power of simplicity , 1987, OOPSLA '87.

[5]  Ralph E. Johnson,et al.  TS: an optimizing compiler for smalltalk , 1988, OOPSLA '88.

[6]  Brian W. Kernighan,et al.  The C Programming Language, Second Edition , 1988 .

[7]  Daniel G. Bobrow,et al.  Common lisp object system specification , 1988, SIGP.

[8]  Bjarne Stroustrup,et al.  Multiple Inheritance for C++ , 1989, Comput. Syst..

[9]  Craig Chambers,et al.  Customization: optimizing compiler technology for SELF, a dynamically-typed object-oriented programming language , 1989, PLDI '89.

[10]  Patrick Lincoln,et al.  Efficient implementation of lattice operations , 1989, TOPL.

[11]  Doug Lea.  Customization in C++ , 1990, C++ Conference.

[12]  Proceedings of the ACM SIGPLAN 1998 conference on Programming language design and implementation , 1990, PLDI 1990.

[13]  Craig Chambers,et al.  Iterative type analysis and extended message splitting; optimizing dynamically-typed object-oriented programs , 1990, PLDI '90.

[14]  Craig Chambers,et al.  Optimizing Dynamically-Typed Object-Oriented Languages With Polymorphic Inline Caches , 1991, ECOOP.

[15]  Bjarne Stroustrup,et al.  The C++ Programming Language, Second Edition , 1991 .

[16]  Bjarne Stroustrup,et al.  The C++ programming language (2nd ed.) , 1991 .

[17]  Greg Nelson,et al.  Systems programming in modula-3 , 1991 .

[18]  Steven W. K. Tjiang,et al.  Sharlit—a tool for building optimizers , 1992, PLDI '92.

[19]  Craig Chambers,et al.  Object-Oriented Multi-Methods in Cecil , 1992, ECOOP.

[20]  Craig Chambers,et al.  The cecil language: specification and rationale , 1993 .

[21]  Andrew A. Chien,et al.  Concurrent Aggregates: Supporting Modularity in Massively Parallel Programs , 1993 .

[22]  D. B. Davis,et al.  Sun Microsystems Inc. , 1993 .

[23]  Andrew A. Chien,et al.  Precise Concrete Type Inference for Object-Oriented Languages , 1994, OOPSLA.

[24]  Dirk Grunwald,et al.  Reducing indirect function call overhead in C++ programs , 1994, POPL '94.

[25]  Barbara G. Ryder,et al.  Static Type Determination for C++ , 1994, C++ Conference.

[26]  Urs Hölzle,et al.  Optimizing dynamically-dispatched calls with run-time type feedback , 1994, PLDI '94.

[27]  David Grove,et al.  Selective specialization for object-oriented languages , 1995, PLDI '95.

[28]  James M. Bieman,et al.  Reuse through inheritance: a quantitative study of C++ software , 1995, SSR '95.

[29]  Mary F. Fernández,et al.  Simple and effective link-time optimization of Modula-3 programs , 1995, PLDI '95.

[30]  Urs Hölzle,et al.  Type feedback vs. concrete type inference: a comparison of optimization techniques for object-oriented languages , 1995, OOPSLA.

[31]  David Grove,et al.  Profile-guided receiver class prediction , 1995, OOPSLA.

[32]  Urs Hölzle,et al.  Dynamic versus Static Optimization Techniques for Object-Oriented Languages , 1995, Theory Pract. Object Syst..

[33]  David Grove,et al.  Optimization of Object-Oriented Programs Using Static Class Hierarchy Analysis , 1995, ECOOP.

[34]  Keith D. Cooper,et al.  Combining analyses, combining optimizations , 1995, TOPL.

[35]  Ole Agesen.  The Cartesian Product Algorithm: Simple and Precise Type Inference Of Parametric Polymorphism , 1995, ECOOP.

[36]  Andrew W. Appel,et al.  A type-based compiler for standard ML , 1995, PLDI '95.

[37]  David Grove,et al.  A Framework for Selective Recompilation in the Presence of Complex Intermodule Dependencies , 1995, 1995 17th International Conference on Software Engineering.

[38]  Urs Hölzle,et al.  Eliminating Virtual Function Calls in C++ Programs , 1996, ECOOP.

[39]  Guy L. Steele,et al.  The Java Language Specification , 1996 .

[40]  Amer Diwan,et al.  Simple and effective analysis of statically-typed object-oriented programs , 1996, OOPSLA '96.

[41]  Urs Hölzle,et al.  Dynamic vs . Static Optimization Techniques for Object-Oriented Languages , 1996 .

[42]  Craig Chambers,et al.  Whole-program optimization of object-oriented languages , 1996 .

[43]  David F. Bacon,et al.  Fast static analysis of C++ virtual function calls , 1996, OOPSLA '96.

[44]  Robert Harper,et al.  TIL: a type-directed optimizing compiler for ML , 1996, PLDI '96.