Results 1 - 10
of
31
From Flop to MegaFlops: Java for Technical Computing
- ACM Transactions on Programming Languages and Systems
, 1998
"... . Although there has been some experimentation with Java as a language for numerically intensive computing, there is a perception by many that the language is not suited for such work. In this paper we show how optimizing array bounds checks and null pointer checks creates loop nests on which ag ..."
Abstract
-
Cited by 52 (11 self)
- Add to MetaCart
(Show Context)
. Although there has been some experimentation with Java as a language for numerically intensive computing, there is a perception by many that the language is not suited for such work. In this paper we show how optimizing array bounds checks and null pointer checks creates loop nests on which aggressive optimizations can be used. Applying these optimizations by hand to a simple matrix-multiply test case leads to Java compliant programs whose performance is in excess of 500 Mflops on an RS/6000 SP 332MHz SMP node. We also report in this paper the effect that each optimization has on performance. Since all of these optimizations can be automated, we conclude that Java will soon be a serious contender for numerically intensive computing. 1 Introduction The scientific programming community has recently demonstrated a great deal of interest in the use of Java for technical computing. There are many compelling reasons for such use of Java: a large supply of programmers, it is obj...
An Automatic Object Inlining Optimization and its Evaluation
- In PLDI 2000
, 2000
"... Automatic object inlining [19, 20] transforms heap data structures by fusing parent and child objects together. It can improve runtime by reducing object allocation and pointer dereference costs. We report continuing work studying object inlining optimizations. In particular, we present a new semant ..."
Abstract
-
Cited by 51 (0 self)
- Add to MetaCart
(Show Context)
Automatic object inlining [19, 20] transforms heap data structures by fusing parent and child objects together. It can improve runtime by reducing object allocation and pointer dereference costs. We report continuing work studying object inlining optimizations. In particular, we present a new semantic derivation of the correctness conditions for object inlining, and program analysis which extends our previous work. And we present an object inlining transformation, focusing on a new algorithm which optimizes class field layout to minimize code expansion. Finally, we detail a fuller evaluation on eleven programs and libraries (including Xpdf, the 25,000 line Portable Document Format (PDF) le browser) that utilizes hardware measures of impact on the memory system. We show that our analysis scales effectively to large programs, nding many inlinable elds (45 in xpdf) at acceptable cost, and we show that, on some programs, it finds nearly all fields for which object inlining is correct, and a...
An Evaluation of Automatic Object Inline Allocation Techniques
- In 1998 ACM SIGPLAN Conference on Object-Oriented Programming Systems, Languages, and Applications
, 1998
"... Object-oriented languages such as Java and Smalltalk provide a uniform object reference model, allowing objects to be conveniently shared. If implemented directly, these uniform reference models can suffer in efficiency due to additional memory dereferences and memory management operations. Automati ..."
Abstract
-
Cited by 28 (1 self)
- Add to MetaCart
Object-oriented languages such as Java and Smalltalk provide a uniform object reference model, allowing objects to be conveniently shared. If implemented directly, these uniform reference models can suffer in efficiency due to additional memory dereferences and memory management operations. Automatic inline allocation of child objects within parent objects can reduce overheads of heap-allocated pointer-referenced objects. We present three compiler analyses to identify inlinable fields by tracking accesses to heap objects. These analyses span a range from local data flow to adaptive whole-program, flow-sensitive inter-procedural analysis. We measure their cost and effectiveness on a suite of moderate-sized C++ programs (up to 30,000 lines including libraries). We show that aggressive interprocedural analysis is required to enable object inlining, and our adaptive inter-procedural analysis [23] computes precise information efficiently. Object inlining eliminates typically 40% of object a...
An Evaluation of Java for Numerical Computing
- In Proceedings of ISCOPE'98
, 1998
"... This paper describes the design and implementation of high performance numerical software in Java. Our primary goals are to characterize the performance of object-oriented numerical software written in Java and to investigate whether Java is a suitable language for such endeavors. We have implemente ..."
Abstract
-
Cited by 26 (1 self)
- Add to MetaCart
(Show Context)
This paper describes the design and implementation of high performance numerical software in Java. Our primary goals are to characterize the performance of object-oriented numerical software written in Java and to investigate whether Java is a suitable language for such endeavors. We have implemented JLAPACK, a subset of the LAPACK library in Java. LAPACK is a high-performance Fortran 77 library used to solve common linear algebra problems. JLAPACK is an object-oriented library, using encapsulation, inheritance, and exception handling. It performs within a factor of four of the optimized Fortran version for certain platforms and test cases. When used with the native BLAS library, JLAPACK performs comparably with the Fortran version using the native BLAS library. We conclude that high-performance numerical software could be written in Java if a handful of concerns about language features and compilation strategies are adequately addressed.
Run-time evaluation of opportunities for object inlining in Java
- In JGI ’02: Proceedings of the 2002 joint ACM-ISCOPE conference on Java Grande
, 2002
"... Object-oriented languages, such as Java, encourage the use of many small objects linked together by field references, instead of a few monolithic structures. While this practice is beneficial from a program design perspective, it can slow down program execution by incurring many pointer indirections ..."
Abstract
-
Cited by 21 (0 self)
- Add to MetaCart
Object-oriented languages, such as Java, encourage the use of many small objects linked together by field references, instead of a few monolithic structures. While this practice is beneficial from a program design perspective, it can slow down program execution by incurring many pointer indirections. One solution to this problem is object inlining: when the compiler can safely do so, it fuses small objects together, thus removing the reads/writes to the removed field, saving the memory needed to store the field and object header, and reducing the number of object allocations. The objective of this paper is to measure the potential for object inlining by studying the run-time behaviour of a comprehensive set of Java programs. We study the traces of program executions in order to determine which fields behave
High Performance Numerical Computing in Java: Language and Compiler Issues
- 12th International Workshop on Languages and Compilers for Parallel Computing
, 1999
"... Poor performance on numerical codes has slowed the adoption of Java within the technical computing community. In this paper we describe a prototype array library and a research prototype compiler that support standard Java and deliver near-Fortran performance on numerically intensive codes. We dis ..."
Abstract
-
Cited by 20 (6 self)
- Add to MetaCart
(Show Context)
Poor performance on numerical codes has slowed the adoption of Java within the technical computing community. In this paper we describe a prototype array library and a research prototype compiler that support standard Java and deliver near-Fortran performance on numerically intensive codes. We discuss in detail our implementation of: (i) an efficient Java package for true multidimensional arrays; (ii) compiler techniques to generate efficient access to these arrays; and (iii) compiler optimizations that create safe, exception free regions of code that can be aggressively optimized. These techniques work together synergistically to make Java an efficient language for technical computing. In a set of four benchmarks, we achieve between 50 and 90% of the performance of highly optimized Fortran code. This represents a several-fold improvement compared to what can be achieved by the next best Java environment. 1
Prospects for Scientific Computing in Polymorphic, Object-Oriented Style
- In Proceedings of the Ninth SIAM Conference on Parallel Processing for Scientific Computing
, 1999
"... 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 ..."
Abstract
-
Cited by 10 (4 self)
- Add to MetaCart
(Show Context)
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...
Compiling Java for High Performance and the Internet
, 2001
"... 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 i ..."
Abstract
-
Cited by 10 (4 self)
- Add to MetaCart
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 ...
TurboJ, a Java Bytecode-to-Native Compiler
- In Proc. of LCTES’98, volume 1474 of LNCS
"... . TurboJ is an off-line Java compiler, translating Java bytecodes to native code. TurboJ operates in conjunction with a Java Virtual Machine (JVM); among the supported JVMs are those on HPUX, Linux, and Wind River's Tornado for Java (running under VxWorks). Interfacing with a standard JVM e ..."
Abstract
-
Cited by 9 (3 self)
- Add to MetaCart
. TurboJ is an off-line Java compiler, translating Java bytecodes to native code. TurboJ operates in conjunction with a Java Virtual Machine (JVM); among the supported JVMs are those on HPUX, Linux, and Wind River's Tornado for Java (running under VxWorks). Interfacing with a standard JVM entails benefits not enjoyed by the alternate "standalone" approach; particularly important for embedded systems is the opportunity to reduce the memory footprint via mixed-mode execution. In this paper, we discuss the characteristics of TurboJ as currently implemented, focusing on two aspects of TurboJ: its interactions with the JVM, and the optimizations it makes. We then briefly summarize TurboJ 's current status, compare it with some other Java off-line compilers, and outline future plans. 1 Introduction TurboJ is an off-line Java-to-native compiler, translating Java bytecodes to native code. At run-time, the TurboJ-generated code interfaces with a standard Java Virtual Machine (JVM),...
Is Java ready for computational science?
, 1998
"... This paper provides quantitative and qualitative arguments that help to decide whether Java is ready for computational science. Current shortcomings of Java as well as appropriate countermeasures are discussed. ..."
Abstract
-
Cited by 9 (0 self)
- Add to MetaCart
This paper provides quantitative and qualitative arguments that help to decide whether Java is ready for computational science. Current shortcomings of Java as well as appropriate countermeasures are discussed.
