Compiling Java just in time

The Java programming language promises portable, secure execution of applications. Early Java implementations relied on interpretation, leading to poor performance compared to compiled programs. Compiling Java programs to the native machine instructions provides much higher performance. Because traditional compilation would defeat Java's portability and security, another approach is necessary. This article describes some of the important issues related to just-in-time, or JIT, compilation techniques for Java. We focus on the JIT compilers developed by Sun for use with the JDK (Java Development Kit) virtual machine running on SPARC and Intel processors. (Access the Web at www.sun. com/workshop/java/jit for these compilers and additional information.) We also discuss performance improvements and limitations of JIT compilers. Future Java implementations may provide even better performance, and we outline some specific techniques that they may use     

Java编译程序技术与Java性能

概述了Java编译程序技术,把Java编译程序分成5类:具有解释技术的编译程序;具有及时(JIT)编译技术的编译程序;具有自适应优化技术的编译程序;本地编译程序和翻译程序.详细描述和分析了它们的体系结构和工作原理.同时也分析了编译程序技术对Java性能的影响.     

Efficient Register Mapping and Allocation in LaTTe, an Open-Source Java Just-in-Time Compiler

Java just-in-time (JIT) compilers improve the performance of a Java virtual machine (JVM) by translating Java bytecode into native machine code on demand. One important problem in Java JIT compilation is how to map stack entries and local variables to registers efficiently and quickly, since register-based computations are much faster than memory-based ones, while JIT compilation overhead is part of the whole running time. This paper introduces LaTTe, an open-source Java JIT compiler that performs fast generation of efficiently register-mapped RISC code. LaTTe first maps "all" local variables and stack entries into pseudoregisters, followed by real register allocation which also coalesces copies corresponding to pushes and pops between local variables and stack entries aggressively. Our experimental results indicate that LaTTe's sophisticated register mapping and allocation really pay off, achieving twice the performance of a naive JIT compiler that maps all local variables and stack entries to memory. It is also shown that LaTTe makes a reasonable trade-off between quality and speed of register mapping and allocation for the bytecode. We expect these results will also be beneficial to parallel and distributed Java computing: 1) by enhancing single-thread Java performance; and 2) by significantly reducing the number of memory accesses which the rest of the system must properly order to maintain coherence and keep threads synchronized     

在嵌入式Java芯片中使用即时编译技术

Java虚拟机具有面向堆栈与面向对象的特点,不利于硬件有效支持字节码的直接执行,传统JIT也不适应嵌入式系统的应用环境,介绍了在自行设计的嵌入式Java芯片中使用JIT的技术途径,通过对Java虚拟机堆栈和复杂指令的支持,密切配合JIT软件,较好地解决了Java芯片设计中的问题。测试结果表明,相对于目前前界最好的picoJava-Ⅱ内核而言内核而言,JC401的编译后代码性能提高了1．2至1．9倍,在硬件复杂度、执行速度、内存开销等方面都有较大程度的改善,适合于嵌入式应用。     

基于即时编译的GNU Octave性能优化

GNU Octave是一款数值计算软件,具有免费、开源以及几乎完全兼容MATLAB语言的优点。然而,Octave内置的基于LLVM的实验性即时编译器仅支持对少部分代码进行即时编译,无法有效解决Octave效率低下的问题。基于Octave即时编译器探究对Octave的性能优化方案,从工作原理角度出发,对该即时编译器整体工作原理和其中的类型推断系统进行分析;从工作现状角度出发,评估该即时编译器对Octave代码的适用范围和性能提升效果;针对该即时编译器的内置函数调用、索引运算与算术逻辑运算进行特性修复和功能新增,使Octave获得性能提升。实验结果表明,基于即时编译器的优化方案有效扩展了即时编译器的适用范围,为Octave代码执行带来56~283倍不等的性能提升。此外,总结了该即时编译器中存在的16类缺陷,对进一步优化Octave性能具有参考意义。     

保证Java精确异常的软件流水线技术

Java对精确异常的支持严重限制了JIT编译器的动态优化的能力.目前已经有不少在精确异常存在下的优化技术,但它们都是针对代码块内部顺序指令的调度算法,依然没有在软件流水线这样循环级别做带精确异常的优化的算法.针对存在精确异常要求的Java程序,提出了一种软件流水线的算法,并以安腾作为底层平台对该算法进行了测试,实验结果显示该算法在保证Java精确异常要求的情况下能够大幅度提高Java程序的性能.     

基于Harmony的提前编译技术

在开源Java平台Harmony上,设计并实现一种提前(AOT)编译技术.将可执行代码以文件形式存入本地磁盘或远程服务器,在编译时将文件读入虚拟机,对代码做重定位处理,实现异常信息注册及常量区构造,以确保代码的正确运行.运行结果表明,与解释编译技术和即时编译技术相比,该AOT技术能提高Java程序的响应能力,具有较高的编译效率.     

Java程序运行和编译技术综述

首先概要介绍了Ｊａｖａ语言编译及运行的过程,然后对Ｊａｖａ的４种运行和编译技术：解释执行,即时编译,动态编译和将Ｊａｖａ程序编译为本地机器代码进行了详细的分析和比较。     

一个基于混合并发模型的Java虚拟机

从解释执行到及时编译的转变极大地提高了Java程序的运行速度.但是,现有的Java虚拟机还有待进一步的改进.提出了一种新的Java虚拟机编译与执行模型--混合并发模型HCCEM(hybrid concurrent compilation and execution model).该模型通过多线程控制方式将字节码的编译与执行过程相重叠,从而获取加速的效果.另外还给出了基于HCCEM的Java虚拟机JAFFE的设计方案,并就实现中的执行模式切换、异常处理以及层次线程等问题进行了讨论.实验结果表明,HCCEM能     

Optimizing precision overhead for x86 processors

It is a major challenge for a Java JIT compiler to perform single-precision floating-point operations efficiently for the x86 processors. In previous research, the double-precision mode is set as the default precision mode when methods are invoked. Sophisticated approaches then use heuristic approaches to optimization by considering the trade-offs between roundings and mode switches. However, this convention introduces redundant mode switches across method boundaries. Furthermore, methods that include both single- and double-precision operations cannot switch the mode, even if single-precision operations are dominant. We propose a new approach to these problems. We eliminate redundant mode switches by ignoring the default precision mode and calling a method in the same precision mode as the caller. For methods that include both single- and double-precision methods, we reduce the overhead of rounding by isolating code segments of a given method that should be executed in the single-precision mode. We implemented our approach in IBM's Just-in-Time compiler, and obtained experimental results demonstrating that, in SPECjvm98, it consistently shows the best performance in any configuration of benchmark programs, inline policies, and processor architectures compared with previous research approaches. Copyright © 2004 John Wiley & Sons, Ltd.     

Optimizing Java bytecodes

We have developed a research compiler for Java class files. The compiler, which we call Briki, is designed to test new compilation techniques. We focus on optimizations which are only possible or much easier to perform on a high-level intermediate representation. We have designed such a representation, JavaIR, and have written a front-end which recovers the high-level structure from the information from the class file. Some of the high-level optimizations can be performed by the Java compiler which produces the class file. There is, however, a set of machine-dependent optimizations which have to be customized for the specific architecture and so can only be performed when the machine code is generated from the bytecodes, e.g. in a just-in-time (JIT) compiler. We choose memory hierarchy optimizations as an example of machine-dependent techniques. We show that there is an intersection of the set of machine-dependent optimizations and the set of high-level optimizations. One such example is array remapping, which requires multi-dimensional array references which are not present in the bytecodes and at the same time requires information about memory organization and the mapping of bytecodes to machine instructions. We develop a set of optimizations for accessing array elements and object fields and show their impact on a set of benchmarks which we run on two machines with a JIT compiler. The execution times are reduced by as much as 50% and we argue that the improvement could be even higher with a more mature JIT technology. © 1997 John Wiley & Sons, Ltd.     

Tail call elimination on the Java Virtual Machine

A problem that often has to be solved by compilers for functional languages targeting the Java Virtual Machine is the elimination of tail calls. This paper explains how we solved it in our Funnel compiler and presents some experimental results about the impact our technique has on both performance and size of the compiled programs.     

The Java Virtual Machine: a passing fad?

Java's portability and platform independence have made it the language of choice for developing Web-based applications. Yet Java actually consists of three parts: a language, a rich class library, and a distribution standard based on a virtual machine. It is this third link that the author considers most vulnerable to replacement. He explains why this is likely, drawing on his experience developing an alternative scheme to support software transportability, and given the eventual deployment of dynamic code generators     

GeoBuilder: A Geometric Algorithm Visualization and Debugging System for 2D and 3D Geometric Computing

Algorithm visualization is a unique research topic that integrates engineering skills such as computer graphics, system programming, database management, computer networks, etc., to facilitate algorithmic researchers in testing their ideas, demonstrating new findings, and teaching algorithm design in the classroom. Within the broad applications of algorithm visualization, there still remain performance issues that deserve further research, e.g., system portability, collaboration capability, and animation effect in 3D environments. Using modern technologies of Java programming, we develop an algorithm visualization and debugging system, dubbed GeoBuilder, for geometric computing. The GeoBuilder system features Java's promising portability, engagement of collaboration in algorithm development, and automatic camera positioning for tracking 3D geometric objects. In this paper, we describe the design of the GeoBuilder system and demonstrate its applications.     

Optimizing Java: theory and practice

The enormous popularity of the Internet has made an instant star of the Java programming language. Java's portability, reusability, security and clean design has made it the language of choice for Web-based applications and a popular alternative to C++ for object-oriented programming. Unfortunately, the performance of the standard Java implementation, even with just-in-time compilation technology, is far behind the most popular languages today. The need for an aggressive optimizing compiler for Java is clear. Building on preliminary experience with the JavaSoft bytecode optimizer, this paper explores some of the issues that arise in building efficient implementations of Java. A number of interesting problems are presented by the Java language design, making classical optimization strategies much harder to implement. On the other hand, Java presents the opportunity for some new optimizations, unique for this language. © 1997 John Wiley & Sons, Ltd.     

嵌入式系统中Java的硬件支持策略

一、概述近来,具有平台无关、面向对象等诸多特点的Java语言得到了迅速的发展,以即时编译技术(JIT)为代表的软件实现的Java虚拟机在桌面系统中日趋成熟,在运行速度、内存需求、实时性能等方面都有较大的提高,以网页中的Java小程序为主的Java应用大量涌现,具备了一定的应用基础。     

Lightweight monitors for the Java virtual machine

Java supports the monitor construct for language‐level synchronization in the context of multi‐threading. This paper introduces the lightweight monitor, an efficient user‐level monitor implementation. The lightweight monitor is useful for single‐threaded Java programs as well as for multi‐threaded Java programs with little lock contention. A 32‐bit lock is embedded in each object for efficient lock access while other monitor data structures are managed using a hash table. We highly optimized the lock manipulation code, which is translated and inlined by a just‐in‐time (JIT) compiler. In the most probable cases, only nine SPARC instructions are spent for lock acquisition and five instructions are spent for lock release. Our experimental results indicate that the lightweight monitor is faster than the monitor implementation in the SUN JDK 1.2 RC1 by up to 21 times in the absence of lock contention and by up to seven times in the presence of lock contention. Copyright © 2004 John Wiley & Sons, Ltd.     

部分计值综述

部分计值是一种程序转换技术．在给定程序部分输入的情况下，可使用该技术对程序进行例化，完成程序中尽可能多的计算，最终得到高效的剩余代码。人们已经研究了许多程序设计语言的部分计值系统，并把它们应用到编译和编译器生成、计算机图形学等领域。本文介绍了部分计值理论及其应用．讨论了Java部分计值器的研究现状．并简单描述了本课题组设计的一个Java分布式部分计值系统DJmix。     

An evaluation of Java implementations of message‐passing

As an objected‐oriented programming language and a platform‐independent environment, Java has been attracting much attention. However, the trade‐off between portability and performance has not spared Java. The initial performance of Java programs has been poor, due to the interpretive nature of the environment. In this paper we present the communication performance results of three different types of message‐passing programs: native, Java and native communications, and pure Java. Despite concerns about performance and numerical issues, we believe the obtained results confirm that high‐performance parallel computing in Java is possible, as the technology matures and the approach is pragmatic.Copyright © 2000 John Wiley & Sons, Ltd.     

Exploring the Interaction between Java's Implicitly Thrown Exceptions and Instruction Scheduling

The frequent occurrence of implicitly thrown exceptions poses one of the challenges present in a Java compiler. Not only do these implicitly thrown exceptions directly affect the performance by requiring explicit checks, they also indirectly impact the performance by restricting code movement in order to satisfy the precise exception model in Java. In particular, instruction scheduling is one transformation that is restricted by implicitly thrown exceptions due to the heavy reliance on reordering instructions to exploit maximum hardware performance. The goal of this study is two-fold: first, investigate the degree to which implicitly thrown exceptions in Java hinder instruction scheduling, and second, find new techniques for allowing more efficient execution of Java programs containing implicitly thrown exceptions. Experimental results show that with aggressive scheduling techniques, such as superblock scheduling, the negative performance impact can be greatly reduced.