Java处理器关键技术分析

传统的Java程序利用软件Java虚拟机(Java Virtual Machine,JVM)对Java字节码文件进行解释或二次编译后交由本地CPU执行,其运行速度大大受限,而硬件JVM处理器可直接执行Java字节码,因而大幅提高了Java程序的运行速度,所以硬件JVM处理器是突破Java程序性能瓶颈的最有效方法.本文以Jop Java及picoJava为例,根据Java虚拟机的规范分析了硬件JVM处理器中最重要的流水线结构、堆栈结构及操作的实现方式、指令折叠技术和字节码与微码的映射技术,并提出了改进措施.     

英特尔宣布嵌入式处理器

JSR 223规范为JVM加入了动态语言运行时的支持。当动态语言代码转换为字节码运行在JVM之上,可以方便地享用Java平台在拓展性、移植性和安全性等方面的诸多优势,同时可以引入了Java API和为数众多的第三方库。JavaFX是运行在、JVM上的脚本语言,自两年前在JavaOne大会诞生算起,     

改进型程序切片方法的测试需求约简技术研究

传统的测试用例集约简技术大多采用由测试需求集直接生成测试用例集的方法.该方法虽然能够约简测试用例集,但出现测试需求冗余,约简后的测试用例集不够精准等问题.针对这些问题,提出了一种基于六元结构表的程序切片方法.利用程序切片精简测试代码,省去构造程序依赖图的复杂步骤;根据代码间的相互关系和模块间的耦合度,利用启发式算法约简测试需求;在约简后的测试需求上,精简测试用例集.将该方法应用到当前主流的Android平台上比较约简前后G,GRE的用例集.实验结果表明:约简后的测试需求集能够在获得较少的测试用例集的前提下保证较高的覆盖率.     

Java指令集结构的研究

1 引言 Java是一种编程语言,用其编写的程序具有安全、模块化和可移植等特点。当前Java在Internet有广泛应用,在网站主页的HTML代码中嵌入Java类文件,可以增强界面的动画效果,这种类文件称为小程序(Applet),它是Java源程序的可执行代码。当浏览器访问包含小程序的主页时,相应的类文件从服务器传送到在客户机上运行的Java虚拟机(JVM)上,由JVM生成相应的类对象,并执行相应的方法。Netscape浏览器中就包含这种JVM。     

基于Java的虚拟机技术的应用实践

Java虚拟机（Java Virtual Machine,JVM）是一种用于执行Java字节码的抽象计算机,为Java程序提供了一个运行环境。基于Java的虚拟机技术在许多领域得到了广泛应用,如Web服务器、移动应用、桌面应用等。基于此,文章探讨基于Java的虚拟机技术的应用实践。     

基于程序频谱的两阶段缺陷定位方法

缺陷定位是软件质量保证中关键且困难的一项工作,随着软件规模的增大,人工进行缺陷定位的成本越来越高,自动化缺陷定位技术成为研究热点。现有的基于程序频谱的缺陷定位技术可以将缺陷定位到程序语句,但对于大型复杂的软件系统,这种定位方法将带来较大的时间花销。针对此问题,提出一种基于程序频谱的两阶段缺陷定位方法,第一阶段为粗粒度定位,将缺陷定位到程序模块;第二阶段为细粒度定位,在定位的程序模块中再将缺陷定位到语句;最后输出可疑语句推荐列表,辅助开发人员的调试工作。实验结果表明,相比于传统的方法,该方案在保证定位效果的前提下平均减少了10.24%的定位时间。     

面向Java锁机制的字节码自动重构框架

Java语言提供了同步锁、可重入锁和读写锁等几种锁机制,在并行程序设计中不同的数据结构使用这几种锁机制时获得的性能通常是不同的。为了在不同的锁机制之间进行自动转换,进而帮助程序员了解程序的性能,提出了一种面向Java锁机制的字节码自动重构框架,并基于该框架实现了字节码重构工具Lock2Lock。Lock2Lock在Quad中间表示的基础上对字节码进行静态分析,并对分析的结果进行一致性验证,通过Javassist完成字节码的重构。使用红黑树、消费者生产者程序以及SPECjbb2005 3个测试程序对Lock2Lock重构工具进行了测试,结果表明,Lock2Lock可以成功地实现从同步锁到可重入锁或读写锁的重构。     

基于VBA的Java语言源代码分析系统设计

针对Java系统再工程的需求,利用Microsoft Office软件中强大的VBA工具,设计开发一款适合部门内部使用,主要用户为SE及PG为主的开发人员的Java源代码分析软件。系统以Java程序级代码分析为主,根据程序的各种引用调用关系,生成树状结构图,展示代码结构,建立结构图与代码的链接,实现代码的快速定位查找,方便开发人员查看代码、理解程序结构,降低了对既存Java应用系统维护的风险和成本。     

基于WEHG模型的GUI软件测试用例生成方法

图形用户界面（GUI）是底层代码的前端表示。针对基于现有的模型生成的测试用例集不能尽快找到软件缺陷的问题,本文从代码层和界面层出发对待测程序进行分析,提出一种GUI测试模型WEHG,该模型的特点是：1）根据事件处理函数中定义变量和引用变量的数量和给对应的节点设置权重值,从而保证拥有更多变量的节点能够优先生成测试用例;2）根据事件处理函数的定义引用对给节点之间的依赖关系设置依赖值,使依赖度高的节点能够优先加入测试序列中。对比实验结果表明,该方法能够更快地发现软件中的缺陷,提高测试用例的缺陷探测效率,降低软件测试的成本。     

一种Java字节码保护技术的研究和实现

分析了Java字节码保护技术的现状,在此基础上提出了一种基于JVMTI的Java字节码保护技术,使得Java字节码的安全级别相当于传统的二进制代码。最后,给出了该技术在Win-dows平台和Linux平台下的实现方案。     

PicoJava: a direct execution engine for Java bytecode

Key to the central promise inherent in Java technology-“write once, run anywhere”-is the fact that Java programs run on the Java virtual machine, insulating them from any contact with the underlying hardware. Consequently, Java programs must execute indirectly through a translation layer built into the Java virtual machine. Translation essentially converts Java virtual machine instructions (called bytecodes) into corresponding machine-specific binary instructions. Bytecode is a single image of a program that will execute identically (in principle) on any system equipped with a JVM. The first step toward the development of a new class of Java processors was the creation of the bytecode execution engine itself, called the picoJava core. PicoJava directly executes Java bytecode instructions and provides hardware support for other essential functions of the JVM. Executing bytecode instructions in hardware eliminates the need for dynamic translation, thus extending the useful range of Java bytecode programs to embedded environments. By the end of 1998, Java processors like Sun's microJava 701 should be available for evaluation from several licensees of the picoJava core technology     

Architecture Independent Characterization of Embedded Java Workloads

This paper presents architecture independent characterization of embedded Java workloads based on the industry standard GrinderBench benchmark which includes different classes of real world embedded Java applications. This work is based on a custom built embedded Java virtual machine (JVM) simulator specifically designed for embedded JVM modeling and embodies domain specific details such as thread scheduling, algorithms used for native CLDC APIs and runtime data structures optimized for use in embedded systems. The results presented include dynamic execution characteristics, dynamic bytecode instruction mix, application and API workload distribution, object allocation statistics, instruction-set coverage, memory usage statistics and method code and stack frame characteristics.     

Completeness of a Bytecode Verifier and a Certifying Java-to-JVM Compiler

During an attempt to prove that the Java-to-JVM compiler generates code that is accepted by the bytecode verifier, we found examples of legal Java programs that are rejected by the verifier. We propose therefore to restrict the rules of definite assignment for the try-finally statement as well as for the labeled statement so that the example programs are no longer allowed. Then we can prove, using the framework of Abstract State Machines, that each program from the slightly restricted Java language is accepted by the Bytecode Verifier. In the proof we use a new notion of bytecode type assignment without subroutine call stacks. This revised version was published online in August 2006 with corrections to the Cover Date.     

JBInsTrace: A tracer of Java and JRE classes at basic-block granularity by dynamically instrumenting bytecode

Understanding what happens during the runtime of a Java program is difficult. Tracking runtime flow can bring valuable information for program understanding and behavior analysis. Polymorphism, thread concurrency or even simple facts like the number of method invocations and the number of executed bytecodes are valuable information to track, but are difficult to compute outside the Java Virtual Machine (JVM) on running programs. In this paper, we present JBInsTrace, a new tool that instruments and traces Java bytecode. It produces static information about source code and a very fine grained trace of Java software execution, combining them to allow detailed analysis of the runtime. Our tool differs from others because it does not only trace program classes but also JRE classes, and does so at basic block level, without altering the JVM and without statically modifying class files. We explain JBInsTrace design, focused towards efficiency, which results in reasonable performance penalty.     

Java in high performance environments

Java programs are executed by a Java virtual machine (JVM), which interprets intermediate compiled bytecode that is nominally platform independent. Although early versions of Java interpreted unoptimized bytecode in a relatively unsophisticated manner, recent developments including static analysis, just-in-time compilation, JVM optimization, and instruction-level optimizations have improved execution efficiency. Consequently, Java is now competitive with C and C++ for some applications and on some platforms. Despite Java's increasing popularity, there is a lingering perception that deficiencies in the language make it unsuitable for high-performance computing. In this paper we address some of those deficiencies and discuss the suitability of using Java in a distributed environment.     

On the implementation of bytecode compression for interpreted languages

This paper describes a new method for code space optimization for interpreted languages called LZW‐CC . The method is based on a well‐known and widely used compression algorithm, LZW , which has been adapted to compress executable program code represented as bytecode. Frequently occurring sequences of bytecode instructions are replaced by shorter encodings for newly generated bytecode instructions. The interpreter for the compressed code is modified to recognize and execute those new instructions. When applied to systems where a copy of the interpreter is supplied with each user program, space is saved not only by compressing the program code but also by automatically removing the unused implementation code from the interpreter. The method's implementation within two compiler systems for the programming languages Haskell and Java is described and implementation issues of interest are presented, notably the recalculations of target jumps and the automated tailoring of the interpreter to program code. Applying LZW‐CC to nhc98 Haskell results in bytecode size reduction by up to 15.23% and executable size reduction by up to 11.9%. Java bytecode is reduced by up to 52%. The impact of compression on execution speed is also discussed; the typical speed penalty for Java programs is between 1.8 and 6.6%, while most compressed Haskell executables run faster than the original. Copyright © 2008 John Wiley & Sons, Ltd.     

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.     

WCET可预测的Java指令集硬件实现

为能以硬件方式直接执行CISC结构的Java字节码,设计并实现适用于32位嵌入式实时Java平台的JPOR-32指令集。分析Java虚拟机规范中各Java字节码的功能和实现原理,设定执行每条指令时信号和数据在Java处理器数据通路上的变化,采用微指令方式执行复杂指令,简单指令直接执行,从而使JPOR-32的指令集具有RISC特性。实验结果验证了指令集的正确性及其最坏情况执行时间(WCET)的可预测性。     

Using Bytecode Instruction Counting as Portable CPU Consumption Metric

Accounting for the CPU consumption of applications is crucial for software development to detect and remove performance bottlenecks (profiling) and to evaluate the performance of algorithms (benchmarking). Moreover, extensible middleware may exploit resource consumption information in order to detect a resource overuse of client components (detection of denial-of-service attacks) or to charge clients for the resource consumption of their deployed components. The Java Virtual Machine (JVM) is a predominant target platform for application and middleware developers, but it currently lacks standard mechanisms for resource management.In this paper we present a tool, the Java Resource Accounting Framework, Second Edition (J-RAF2), which enables precise CPU management on standard Java runtime environments. J-RAF2 employs a platform-independent CPU consumption metric, the number of executed JVM bytecode instructions. We explain the advantages of this approach to CPU management and present five case studies that show the benefits in different settings.     

A Program Logic for Bytecode

Program logics for bytecode languages such as Java bytecode or the .NET CIL can be used to apply Proof-Carrying Code concepts to bytecode programs and to verify correctness properties of bytecode programs. This paper presents a Hoare-style logic for a sequential bytecode kernel language similar to Java bytecode and CIL. The logic handles object-oriented features such as inheritance, dynamic method binding, and object structures with destructive updates, as well as unstructured control flow with jumps. It is sound and complete.