Jikes RVM动态编译技术分析与性能评测

随着Java语言的广泛应用,Java虚拟机的性能越来越受到人们重视,而虚拟机的动态编译技术是影响其性能的重要因素.Jikes RVM使用Java语言实现了一个Java虚拟机.首先分析了Jikes RVM的3个主要动态编译器的结构及其涉及的关键编译技术,包括基线编译、优化编译和自适应编译,然后利用SPECjvm Client98对Jikes RVM和Sun JVM的动态编译性能进行了测试和比较.测试结果显示,Jikes RVM的性能和Sun JVM性能基本相同,最后针对Jikes RVM的不足提出了改进Jikes RVM 编译器的方法.     

Perl扩展到JVM的移植

Perl扩展作为Perl语言与其他语言的接口,使得Perl能够解决更加复杂的问题。该文从Perl扩展的创建入手,深入分析了Perl解释器的动态链接技术以及Perl扩展的工作原理。然后分析了Perl扩展到Java虚拟机移植的可行性和难点,最后给出了移植的几个实现方案及其评估。     

在静态编译器中实现Java异常机制的算法

将Java程序静态编译成可执行程序是使用Java虚拟机动态编译／解释执行Java程序的另一种运行Java程序的方式。针对Java异常机制的特点和静态编译的需求,在介绍Java异常处理逻辑的基础上,提出一种在静态编译器中实现Java异常机制的算法,结合Open64开源编译器,给出该算法的具体步骤以及实现方式,以SPECjvm98为测试集,验证该算法的有效性。     

编译原理——C教学编译器设计

该文根据目前编译原理的教学现状,设计了一个C教学编译器。它是一个基于Windows平台的编译器,不但能全面体现编译器的设计和实现过程而且还采用了教学上新的算法和结构设计思想。如基于需要给标识符分配空间、半缓冲区的应用,分离哈希链表的设计。同时,编译器在生成目标代码时,先生成虚拟机代码,再对虚拟机代码进行解释执行得出最终运行结果。这样就便于在不同目标机器上移植了。此技术在Java上已经广泛应用,但在C语言上还是尝试。     

JNI设计实践之路

本文为在32位Windows平台上实现Java本地方法提供了实用的示例、步骤和准则。本文中的示侧使用Sun公司的Java Development Kit(JDK)版本1．42。甩C++语言编写的本地代码是用Microsoft Visual C十+6．0编译器编译生成。规定在Java程序中funcdon/method称为方法，在C++程序中称为函数。     

全新ARM Jazelle RCT技术降低Java占用的内存空间

2005年6月27日，ARM公司在加利富尼亚州旧金山市召开的JavaOne大会上发布了其全新的Jazelle RCT技术，该技术能在移动电话和消费电子产品等众多应用终端上显著地降低Java应用程序占用的内存空间，同时提高性能并降低功耗．ARM Jazelle RCT(运行时间编译器目标,Rtmtime Compiler Target)架构扩展集扩展了Jazelle技术范围，使其涵盖了运行时间和提前时间编译器技术的最优化，如即时编译(Just In Time Compiler，JIT)和动态适应编译(DAC)，并同时支持所有领先的Java技术和其他执行环境。     

基于Java的编译原理课程案例教学方法初探

针对编译原理教学实际,在分析和修改工业级开源编译器实现代码的基础上,提出一个基于Java的编译原理课程案例教学过程,结合Java这种日益普及的面向对象程序设计语言,这种教学过程在编译原理课程教学方面取得良好效果。     

面向RISC-V处理器的GCC移植与优化

嵌入式RISC-V处理器交叉开发生成高质量目标代码的关键是GCC的移植与优化.分析GCC的基本结构和RISC-V体系结构的数据与指令特点,建立GCC后端移植机制,采用机器描述方法,生成32位riscv-none-embed-gcc编译器,实现RISC-V处理器的GCC移植,设计强度削弱的窥孔优化方法解决中间代码生成过程中CPU计算代价高的问题.验证与测试结果表明编译器编译正确并具有通用功能,优化后编译生成的目标代码体积减少约11％,提高了目标代码质量,节省了嵌入式处微理器的存储空间.     

基于Java技术的PHP编译器的设计与开发方式刍议

随着信息技术水平的不断提高,人们对信息量的需求也越来越大,对信息质量的要求也越来越高,研究和开发新的Java技术编译器具有重要的意义。因此,本文主要针对Java技术下的PHP编译器进行分析,阐述了YPHP编译器的设计原理和基本机构,针对PHP编译器的设计结构进行深入的研究,掌握PHP编译器的结构原理,了解其主要功能。为PHP编译器的开发和应用提出一些建议,指明Java技术的PHP编码器的开发方向,为相关研究人员提供一些依据。     

ARM9平台上KVM移植的研究和实现

在移动应用开发中,为了将J2ME技术应用到ARM9嵌入式平台上,需要事先在该ARM9平台上成功移植KVM.但是,在将SUN公司的CLDC 1.1参考实现移植到ARM9平台的过程中,由于编译工具版本更新导致的编译工具与参考实现之间的版本不兼容问题,影响了KVM的成功移植.为此,研究了KVM的代码执行机制,并分析了SUN公司的CLDC 1.1参考实现的build过程.在此基础上,采用目前主流编译器来移植KVM,对编译生成KVM各个阶段产生的所有错误和警告进行了深入分析,并给出了消除那些影响移植结果的错误和警告的适当解决方法.所提出的解决方法不仅实现了参考实现源码的成功编译,而且提高了移植后KVM程序的健壮性.KVM移植测试的实验结果表明,KVM成功地被移植到了ARM9+Embedded Linux平台上.     

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     

Integration of semantic verifiers into Java language compilers

This paper introduces one method for source code static semantic analysis at compilation time directly within standard compilers. The method is implemented via unified integration with Java compilers to get full access to Abstract Syntax Tree (AST) of compiled files after semantic analysis stage of compilation process. The unified integration is implemented by common AST interfaces and adapters to AST implementations of Sun/Oracle javac and Eclipse Compiler for Java (ecj) compilers. This method provides transparent integration with Eclipse and Netbeans integrated developer environments without a need for any special plugins. Several examples of program verification rules are presented to demonstrate the method.     

Java性能优化技术综述

Java由于其简单、面向对象、独立于硬件体系结构、安全等特点在各种应用领域内获得广泛的应用,但在很多情况下其运行性能仍有待提高.优化Java应用的运行性能成为当前业界迫切要解决的问题和当前研究的热点.本文简要回顾了当前在Java性能优化方面的最新研究成果,对其中的关键技术进行了深入探讨,并结合作者的经验提出对未来发展的一些看法.     

Design and implementation of Java just-in-time compiler

Early Java implementations relied on interpretation,leading to poor performance compared to compiled programs,Java just-in-time(JIT) compiler can compile Java programs at runtime,so it not only improves Java‘s performance prominently,but also preserves Java‘s portability.In this paper the design and implementing techniques of Java JIT complier based on Chinese open system are discussed in detail.To enhance the portability,a translating method which combines the static simulating method and macro expansion method is adopted.The optimization technique for JIT compiler is also discussed and a way to evaluate the hotspots in Java programs is presented.Experiments have been conducted to verify JIT compilation technique as an efficient way to accelerate Java.     

A Tree-Based Alternative to Java Byte-Codes

Despite the apparent success of the Java Virtual Machine, its lackluster performance makes it ill-suited for many speed-critical applications. Although the latest just-in-time compilers and dedicated Java processors try to remedy this situation, optimized code compiled directly from a C program source is still considerably faster than software transported via Java byte-codes. This is true even if the Java byte-codes are subsequently further translated into native code. In this paper, we claim that these performance penalties are not a necessary consequence of machine-independence, but related to Java's particular intermediate representation and runtime architecture. We have constructed a prototype and are further developing a software transportability scheme founded on a tree-based alternative to Java byte-codes. This tree-based intermediate representation is not only twice as compact as Java byte-codes, but also contains more high-level information, some of which is critical for advanced code optimizations. Our architecture not only provides on-the-fly code generation from this intermediate representation, but also continuous re-optimization of the existing code-base by a low-priority background process. The re-optimization process is guided by up-to-the-minute profiling data, leading to superior runtime performance.     

Dynamic Event Generation for Runtime Checking using the JDI

Approaches to runtime checking have to track the execution of a software system and therefore have to deal with generating and processing execution events. Often these techniques are applied at the code level – either by inserting new source code prior to the compilation or by modifying the target code, e.g. Java byte code, before running the program.The jassda [4,3] framework and tool enable runtime checking of Java programs against a CSP-like specification. For generating events it uses the Java Debug Interface (JDI) and thus no modifications to the code are necessary. Another advantage is that events are generated on demand, i.e. dynamically at runtime it is determined which events to generate for the current debug run without modifying the program itself. This paper shows how this event generation is done by the jassda framework.     

Runtime Engine for Dynamic Profile Guided Stride Prefetching

Stride prefetching is recognized as an important technique to improve memory access performance. The prior work usually profiles and/or analyzes the program behavior offline, and uses the identified stride patterns to guide the compilation process by injecting the prefetch instructions at appropriate places. There are some researches trying to enable stride prefetching in runtime systems with online profiling, but they either cannot discover cross-procedural prefetch opportunity, or require special supports in hardware or garbage collection. In this paper, we present a prefetch engine for JVM （Java Virtual Machine）. It firstly identifies the candidate load operations during just-in-time （JIT） compilation, and then instruments the compiled code to profile the addresses of those loads. The runtime profile is collected in a trace buffer, which triggers a prefetch controller upon a protection fault. The prefetch controller analyzes the trace to discover any stride patterns, then modifies the compiled code to inject the prefetch instructions in place of the instrumentations. One of the major advantages of this engine is that, it can detect striding loads in any virtual code places for both regular and irregular code, not being limited with plain loop or procedure scopes. Actually we found the cross-procedural patterns take about 30% of all the prefetchings in the representative Java benchmarks. Another major advantage of the engine is that it has runtime overhead much smaller （the maximal is less than 4.0%） than the benefits it brings. Our evaluation with Apache Harmony JVM shows that the engine can achieve an average 6.2% speed-up with SPECJVM98 and DaCapo on Intel Pentium 4 platform, in spite of the runtime overhead.     

主从式单边异构多核处理器编程模型和编译架构

主从式单边异构体系结构的异构多核处理器广泛应用于面向专门应用领域的计算加速,如异构多核嵌入式处理器、DSP、SoC等;高性能的该类处理器也可用于一些大规模科学和工程计算问题的处理。主从式单边异构处理器对编程模型和编译技术提出了很多挑战性问题,如编程模型的选择、编程语言的设计、编译器架构设计以及运行库的设计等。本文分析了这一类处理器结构特点和执行模型,认为功能卸载模型是最适用于这一体系结构的编程模型;并分析了面向功能卸载模型的编程语言设计关键问题,提出了编译系统的架构,讨论了相应的运行库设计问题。     

Quantifying the Benefits of SSA-Based Mobile Code

High-performance just-in-time compilers for Java need to invest considerable effort before actual code generation can commence. This is in part due to the very nature of the Java Virtual Machine, which is not well matched to the requirements of optimizing code generators. Alternative transportation formats based on Static Single Assignment form should theoretically be superior to virtual machines, but this claim has not previously been validated in practice. This paper revisits the topic and attempts to quantify the effect of using an SSA-based mobile code representation (IR) instead of a virtual-machine based one.To this end, we have integrated full support for a verifiable SSA-based IR into Jikes RVM, an existing Java execution environment. The resulting system is capable of loading and executing Java programs represented in either format, traditional JVM bytecode as well as the SSA-based representation, and it can even execute programs made up of a mixture of the two formats. In our implementation, the two alternative just-in-time compilation pipelines share a common low-level code generator.Performance results are encouraging and show simultaneous improvements in both compilation time and code quality relative to Jikes RVM's standard optimizing compiler for JVM class files. They support the hypothesis that SSA-based intermediate representations offer advantages in the context of just-in-time compilation.