Since the introduction of the Java programming language, there has been widespread interest in the use of Java for high performance scientific computing. One major impediment to such use is the performance penalty paid relative to Fortran. Although Java implementations have made great strides, they still fall short on programs that use the full power of Java's object-oriented features. In this paper, we present an analysis of the cost associated with polymorphic, object-oriented scientific programming in Java, and discuss the compiler strategies that would reduce the overhead of such programming style. Our ultimate goal is to foster the development of compiler technology that will reward, rather than penalize good object-oriented programming practice. 1 Introduction When one considers Java as a platform for high-performance scientific applications, several general performance considerations quickly come into focus. Today's Java implementations are not yet on par with the native compil...

Virtual machines (vms) have enjoyed a resurgence as a way of allowing the same application program to be used across a range of computer systems. This flexibility comes from the abstraction that the vm provides over the native interface of a particular computer. However, this also means that the application is prevented from taking the features of particular physical machines into account in its implementation. This dissertation addresses the question of why, where and how it is useful, possible and practicable to provide an application with access to lower-level interfaces. It argues that many aspects of vm implementation can be devolved safely to untrusted applications and demonstrates this through a prototype which allows control over run-time compilation, object placement within the heap and thread scheduling. The proposed architecture separates these application-specific policy implementations from the application itself. This allows one application to be used with different policies on different systems and also allows nave or premature optimizations to be removed.

Object-oriented and generic programming are both supported in C++. The former provides high expressiveness whereas the latter leads to more efficient programs by avoiding dynamic typing. This paper presents SCOOP, a new paradigm which enables both classical object-oriented design and high performance in C++ by mixing object-oriented programming and generic programming. We show how classical and advanced object-oriented features such as virtual methods, multiple inheritance, argument covariance, virtual types and multimethods can be implemented in a fully statically typed model, hence without run-time overhead.

Java is the first widely accepted language that addresses heterogeneous resources, security, and portability problems, making it attractive for scientific computation. It also encourages programmers to use object-oriented techniques in programming. Unfortunately, such object-oriented programs also incur unacceptable performance penalties. For example, using a polymorphic number hierarchy in a linear algebra package resulted in a code that is four times shorter, more extensible and less bug-prone than the equivalent Fortran-style code, but also many times slower. To address the poor performance problem, this dissertation introduces several new compilation techniques that can improve the performance of scientific Java programs written in a polymorphic, object oriented style to within a factor of two of the equivalent hand-coded Fortran-style programs. These techniques also maintain an acceptable level of Java bytecode portability and flexibility, thus rewarding, rather than penalizing, good object-oriented programming practice. This dissertation first discards the typical one-class-at-a-time Java compilation model for a whole-program model. It then introduces two novel whole-program optimizations, class specialization and object inlining, which improve the performance of high-level, object-oriented, scientific Java programs by up to two orders of magnitude, effectively eliminating the penalty of object-oriented design. Next, this dissertation introduces a new Almost-whole-program compilation model. This model improves the flexibility of the generated code, while still permitting wholeprogram optimizations and incurring only modest performance penalties. It enables the programmer balance performance and flexibility of the program after the development phase, instead of ...

Abstract not found

Deeply embedded systems are forced to operate under extreme resource constraints in terms of memory, CPU time, and power consumption. The program family concept can be applied in this domain to implement reusable and highly configurable operating systems. In this paper we present our approach to use aspect-oriented programming to modify and optimize the inter-object relations and communication pathways in an object-oriented family of operating system. The aim of this approach is to produce streamlined application-specific operating systems, minimizing the code size and runtime overhead. 1

A primary objective in the SUIF compiler design has been to develop an infrastructure for research in a variety of compiler topics including optimizations on object-oriented languages. However, the task of optimizing object-oriented languages requires that highlevel object constructs be visible in SUIF. Java is a statically-typed, object-oriented and interpreted language that has the same requirements of high-performance as procedural languages. We have developed a Java front-end to SUIF, j2s, for the purpose of carrying out optimizations. This paper discusses the compilation issues in translating Java to SUIF and draws upon those experiences in proposing the solutions to incorporating object-oriented support in SUIF as well as the extensions that need to be made to support exceptions and threads. 1 Introduction Object-oriented languages with their features of inheritance and abstraction equip programmers with the tools to write reusable programs quickly and easily. However,...

Rights to individual papers remain with the author or the author's employer. Permission is granted for noncommercial reproduction of the work for educational or research purposes. This copyright notice must be included in the reproduced paper. USENIX acknowledges all trademarks herein.

Abstract. Customization aims to improve the performance of pure object-oriented languages by compiling multiple copies of a source method, each of them specialized for a certain revceiver type. Like other code duplication techniques, it gains performance by trading code space for better speed. Unfortunately, customization can significantly increase code space, especially for larger programs. We show that customization increases memory usage by almost a factor of three for some applications in the Self-93 system. We analyze and quantify the factors that lead to this space overhead and identify strategies to eliminate most of it. We focus on dynamically-compiled systems like Self-93 where it is impractical or undesirable to use whole-program analysis or programmer-directed profiling to guide customization decisions. Our experiments show that a combination of relatively straight-forward strategies can bring the code space consumption of customization to within 34 % or less of a completely non-customizing system. Thus, even in dynamically-compiled systems customization and efficient memory usage need not be mutually exclusive. 1.

Abstract not found