Optimizing compilers require accurate dependence testing to enable numerous, performance-enhancing transformations. However, data dependence testing is a difficult problem, particularly in the presence of pointers. Though existing approaches work well for pointers to named memory locations (i.e. other variables), they are overly conservative in the case of pointers to unnamed memory locations. The latter occurs in the context of dynamic, pointer-based data structures, used in a variety of applications rangin from 8 system software to computational geometry to -body and circuit simulations.In this paper we present a new technique for performing more accurate data dependence testing in the presence of dynamic, pointer-based data structures. We will demonstrate its effectiveness by breaking false dependence that existing approaches cannot, and provide results which show that removing these dependence enables significant parallelization of a real application.

The Java Bytecode language lacks expressiveness for traditional compiler optimizations, making this portable, secure software distribution format inefficient as a program representation for high performance. This inefficiency results from the underlying stack model, as well as the fact that many bytecode operations intrinsically include sub-operations (e.g., iaXoad includes the address computation, a,rray bounds checks and the actual load of the array element). The stack model, with no operand registers and limiting access to the top of the stack, prevents the reuse of values and bytecode reordering. In addition, the bytecodes have no mechanism to indicate which sub-operations in the bytecode stream are redundant or subsumed by previous ones. As a consequence, the Java Bytecode language inhibits the expression of important compiler optimizations, including common sub-expression elimination, register allocation and instruction scheduling.The bytecode stream generated by the Java frontend is a significantly under-optimized program representation. The most common solution to overcome this aspect of the language is the use of a Just-in-Time (JIT) compiler to not only generate native code, but perform optimization as well. However, the latter is a time consuming operation in an already time-constrained translation process. In this paper we present an alternative to an optimizing JIT compiler that makes use of code annotations generated by the Java front-end. These annotations carry information concerning compiler optimization. During the translation process, an annotationaware JIT (AJIT) system then uses this information to produce high-performance native code without per-*This work supported K part by CAPES.Permission to make digital or hard copies of all or part ofthis work fix personal or classroom use is granted without fee provided that topics are not made or distributed for profit or commercial advantage and that copies hear this notice and the full citation on the tirst page. To copy otherwise, to republish, to post on servers or to redistribute to lists. requires prior specific permission and/or a fee. JAVA'99 San Francisco California USA Copyright ACM 1999 I-581 13-161-5/99/06...$5.00 forming much of the necessary analyses or transformations. We describe the implementation of the first prototype of our annotation-aware JIT system and show performance results comparing our system with other Java Virtual Machines (JVMs) running on SPARC architecture.

High-performance architectures rely upon powerful optimizing and parallelizing compilers to maximize performance. Such compilers need accurate program analysis to enable their performance-enhancing transformations. In the domain of program analysis for parallelization, pointer analysis is a difficult and increasingly common problem. When faced with dynamic, pointer-based data structures, existing solutions are either too limited in the types of data structures they can analyze, or require too much effort on the part of the programmer. Recently we proposed a compromising approach, in which the programmer supplies some small amount of information, and the compiler performs the remaining analysis [HHN92a]. However, the language for conveying this information is unable to accurately describe a number of important data structures, and does not easily support the compiler's underlying alias analysis. In this paper we present a more powerful description language that also directly supports alias analysis. Ultimately, this will lead to more accurate program analysis for a larger class of programs, and hence the increased application of performance-enhancing transformations on these programs.

No abstract

SUMMARYThe efficient execution of Java programs presents a challenge to hardware and software designers alike. The difficulty, however, lies with the Java bytecodes. Their model of a simplistic, platform-independent stack machine is well-suited for portability, though at the expense of execution speed. Various approaches are being proposed to increase the speed of Java bytecode programs, including: (i) on-the-fly compilation to native code (also known as JIT or 'just-in-time' compilation); (ii) traditional ('ahead-of-time') compilation of bytecodes to some higher-level intermediate form and then to native code; and (iii) translation of bytecodes to a higher-level language and then use of an existing compiler to produce native code. Speedups of the order of 50 over standard bytecode interpretation have been claimed.All of these approaches rely upon bytecode analysis (of varying sophistication) to extract information about the program, which is then used to optimize the native code during the translation process. However, extracting information from a lower-level representation such as the Java bytecodes can be very expensive. Also, given the fact that most approaches for executing Java bytecodes cannot spend a great deal of time recovering high-level information, the solutions adopted during the translation process must use faster and less accurate analysis techniques, thus penalizing the quality of the native code.In this paper we propose an optimization approach based on bytecode annotations. The bytecodes are annotated during the original source code to bytecode translation, allowing both traditional interpretation by a JVM and aggressive optimization by an annotation-aware bytecode compiler. Annotations hinder neither portability nor compatibility, while preserving optimization information that is expensive to recompute. Preliminary results yield bytecode with C-like performance using JIT technology.