Java HotSpot Client Compiler优化设计

需积分: 5 23 浏览量更新于2024-06-22 收藏 1.09MB PDF 举报

"Java HotSpot Client Compiler的设计与优化" 这篇技术文档主要介绍了Java HotSpot VM在Java 6版本中的客户端（Client）即时编译器（JIT）的重新设计和优化。HotSpot VM是由Sun Microsystems开发的一款高性能的Java虚拟机，它包含了一个客户端和一个服务器端的编译器。客户端编译器主要用于桌面应用程序，因为这些应用更注重启动速度和响应时间，而非峰值性能。新设计的客户端编译器结合了近年来的研究成果，其架构有了显著的改进。文档中提到了以下几个关键知识点： 1. **中间表示（Intermediate Representation, IR）**：客户端编译器现在采用了静态单赋值形式（Static Single Assignment, SSA）。SSA是一种优化编译器的IR形式，它使得每个变量在任何时刻只有一个定义，有助于简化分析和优化过程。 2. **线性扫描算法（Linear Scan Algorithm）**：用于全局寄存器分配。这是编译器优化的一个重要环节，通过高效的寄存器分配，可以减少内存访问，提高代码执行效率。 3. **异常处理（Exception Handling）**：文档指出，新客户端编译器对异常处理进行了优化，以满足Java编程语言动态特性的需求。这包括快速的异常处理机制，确保程序在出现异常时能正确地跳转和恢复。 4. **去优化（Deoptimization）**：当Java的运行时信息（如类加载或监控数据）表明已编译的代码不再适应当前的运行状态时，需要进行去优化。客户端编译器提供了高效的支持，以便在必要时回滚到解释执行状态，然后重新编译优化。 5. **性能评估**：通过对SPECjvm98基准测试套件的执行，新客户端编译器显示出在更短的时间内生成了更好的代码，证明了其优化效果。SPECjvm98是一组广泛使用的Java性能测试工具，可以衡量Java虚拟机的性能。这份文档揭示了Java HotSpot客户端编译器如何通过引入现代编译技术来提升Java应用程序的启动速度和运行效率，尤其是在交互式桌面应用的场景下。同时，文档还展示了编译器设计与优化对于提升Java平台性能的重要性。

7:6

•

T. Kotzmann et al.

single point in the program where a value is assigned to it. An instruction that

loads or computes a value represents both the operation and its result, so that

operands can be represented as pointers to previous instructions. Both during

and after generation of the HIR, several optimizations are performed, such as

constant folding, value numbering, method inlining, and null check elimination.

They beneﬁt from the simple structure of the HIR and the SSA form.

The back end of the compiler translates the optimized HIR into a low-level

intermediate representation (LIR). The LIR is conceptually similar to machine

code, but still mostly platform-independent. In contrast to HIR instructions,

LIR operations operate on virtual registers instead of references to previous

instructions. The LIR facilitates various low-level optimizations and is the input

for the linear scan register allocator, which maps virtual registers to physical

ones.

After register allocation, machine code can be generated in a rather simple

and straightforward way. The compiler traverses the LIR, operation by opera-

tion, and emits appropriate machine instructions into a code buffer. This process

also yields object maps and debugging information.

2.1 High-Level Intermediate Representation

The high-level intermediate representation (HIR) is a graph-based represen-

tation of the method using SSA form [Cytron et al. 1991]. It is platform-

independent and represents the method at a high level where global optimiza-

tions are easy to apply. We build the SSA form at parse time of the bytecodes,

similarly to Click and Paleczny [1995]. The modeling of instruction types as a

C++ class hierarchy and the representation of operands are other similarities

to this intermediate representation.

The control ﬂow is modeled using an explicit CFG, whose nodes represent

basic blocks, i.e. longest possible sequences of instructions without jumps or

jump targets in the middle. Only the last instruction can be a jump to one or

more successor blocks or represent the end of the method. Because instructions

that can throw exceptions do not terminate a basic block, control can also be

transferred to an exception handler in the middle of a block (see Section 2.5).

The instruction types of the HIR are represented by a class hierarchy with a

subclass for each kind of instruction. The instruction nodes also form the data

ﬂow: Instructions refer to their arguments via pointers to other instructions.

This way, an instruction represents both the computation of a result and the

result itself. Because of this equivalence, an instruction is often referred to as

a value. The argument need not be deﬁned in the same block, but can also be

deﬁned in a dominator, i.e. a common predecessor on all input paths. Instead of

explicit instructions for accessing local variables, instructions reference those

instructions that compute the most recent value of the variables. Figure 3 shows

an example for the control and data ﬂow of a short loop.

The HIR is constructed in two passes over the bytecodes. The ﬁrst pass de-

tects the boundaries of all basic blocks and performs a simple loop analysis

to mark loop header blocks. Backward-branch targets of irreducible loops are

are also treated as loop headers. The basic blocks are created, but not linked

ACM Transactions on Architecture and Code Optimization, Vol. 5, No. 1, Article 7, Publication date: May 2008.

Design of the Java HotSpot Client Compiler for Java 6

•

7:7

constant "1"

add

invoke "f"

jump if "<"

phi

exception handler

control flow

data flow (inverse)

int i = 1;

do {

i++;

} while (i < f())

exception edge

basic block

instruction

Java code fragment:

10: iconst_1

11: istore_0

12: iinc 0, 1

15: iload_0

16: invokestatic f()

19: if_icmplt 12

Bytecodes:

Fig. 3. HIR example with control and data ﬂow.

together. The second pass creates the instructions by abstract interpretation of

the bytecodes, appends them to their basic block, and links the blocks to build

the CFG.

Inlining of methods is embedded into the analysis: When the bytecodes con-

tain a call to a short method that can be statically bound, the HIR construction is

called recursively for the callee and the resulting basic blocks and instructions

are appended to the CFG.

The SSA form requires a single point of assignment for each variable. When

control ﬂow joins, so-called phi functions merge different values of the same

variable. In the example, the phi function merges the initial value 1 and the

result of the addition for the loop variable i. If a block has more than one pre-

decessor, phi functions might be necessary at the beginning of this block. They

are created before the instructions of the block are inserted using the following

strategy that does not require data-ﬂow analysis. The server compiler [Paleczny

et al. 2001] uses a similar approach.

—When the block is no loop header, all predecessors are already ﬁlled with

instructions. If a variable has different values at the end of the predecessors,

a phi function is created. If the value is equal in all predecessors, no phi

function is necessary and the value is used directly.

—For loop headers, the state of the variables for the backward branch is not yet

known. Therefore, phi functions are created conservatively for all variables.

The loop analysis of the ﬁrst pass is used for further optimizations: If a vari-

able is never assigned a value inside a loop, the phi function for this variable

can also be omitted in loop headers. With this, no phi functions are created for

method parameters that are not changed inside the method, e.g. for the fre-

quently accessed this pointer. This simpliﬁes optimizations that are applied

during HIR construction because the type of parameters and loop-invariant in-

structions is not hidden behind a phi function. Nevertheless, the conservative

ACM Transactions on Architecture and Code Optimization, Vol. 5, No. 1, Article 7, Publication date: May 2008.

剩余31页未读，继续阅读

weixin_44079197

粉丝: 1639
资源: 598

Java HotSpot Client Compiler优化设计

《JAVA程序的设计》.pdf

Java组件设计.pdf

The Java HotSpot VM.pdf

Memory Management in the Java HotSpot Virtual Machine.pdf

Java 虚拟机.pdf

Java虚拟机.pdf

HotSpot实战.pdf

深入java虚拟机.pdf

08-java11-hotspot-guide.pdf

hotspot.tar.gz

最新资源