检索结果-内蒙古大学图书馆

Exceptionization: A Java VM Optimization for Non-Java Languages

ACM TRANSACTIONS ON ARCHITECTURE AND CODE OPTIMIZATION 2017年第1期14卷 5-5页

作者： Yang, Byung-Sun Kim, Jae-Yun Moon, Soo-Mook Seoul Natl Univ Dept Elect Engn & Comp Sci Seoul 08826 South Korea

Java virtual machine (JVM) has recently evolved into a general-purpose language runtime environment to execute popular programming languages such as JavaScript, Ruby, Python, and Scala. These languages have complex non-Java features, including dynamic typing and first-class function, so additional language runtimes (engines) arc provided on top of the JVM to support them with by extensions. Although there are high-performance JVMs with powerful just-in-time (-HT) compilers, running these languages efficiently on the JVM is still a challenge. This article introduces a simple and novel technique for the JVM JIT compiler called exeeptionization to improve the performance of JVM-based language runtimes. We observed that the JVM executing some non-Java languages encounters at least 2 times more branch bytecodes than Java, most of which are highly biased to take only one target. Exceptionization treats such a highly biased branch as some implicit exception throwing instruction. This allows the JVM JIT compiler to prune the infrequent target of the branch from the frequent control flow, thus compiling the frequent control flow more aggressively with better optimization. If a pruned path were taken, then it would run like a Java exception handler, that is, a catch block. We also devised de-exceptionization, a mechanism to cope with the case when a pruned path is executed more often than expected. Since exceptionization is a generic JVM optimization, independent of any specific language runtime, it would be generally applicable to other language runtimes on the JVM. Our experimental result shows that exceptionization accelerates the performance of several non-Java languages. For example, JavaScript-onJVM runs faster by as much as 60% and by 6% on average, when experimented with the Octane benchmark suite on Oracle's latest Nashorn JavaScript engine and HotSpot ***. Furthermore, the performance of Ruby-on-JVM shows an improvement by as much as 60% and by 6% on average, wh

关键词： Javascript Java virtual machine just-in-time compiler non Java languages

来源：评论

学校读者我要写书评

暂无评论

A Novel Lightweight Instruction Scheduling Algorithm for just-in-time compiler

A Novel Lightweight Instruction Scheduling Algorithm for Jus...

引用

World Congress on Software Engineering

作者： Shi, Xiaohua Guo, Peng Beihang Univ Sch Comp Sci Beijing Peoples R China Intel Corp Microprocessor Technol Labs Santa Clara CA 95054 USA

ISBN: (纸本)9780769535708

In this paper, we present a lightweight algorithm of instruction scheduling to reduce the pipeline stalls on XScale. The algorithm is designed for and implemented in a J2ME just-In-time (JET) compiler. It is not based on Directed Acyclic Graphs (DAGs) or expression trees, but a novel data structure namely extended dependency matrix (EDM). The algorithm has almost linear time complexity to one order of magnitude less of the code length in practice, and linear to the code length in the worst cases. It consumes only about 1 KB constant memory space. On the benchmarks we studied, it can eliminate up to 41% data dependency stalls at runtime. The algorithm is on average 2 times faster than a list scheduling implementation, in terms of compilation time. On all benchmarks we studied, the performance is more than 90% as efficient as that obtained using more time and memory consuming algorithms on average.

关键词： Instrution Scheduling just-in-time compiler

来源：评论

学校读者我要写书评

暂无评论

Swift: A Register-based JIT compiler for Embedded JVMs 12

Swift: A Register-based JIT Compiler for Embedded JVMs

引用

8th ACM SIGPLAN-SIGOPS Conference on Virtual Execution Environments

作者： Zhang, Yuan Yang, Min Zhou, Bo Yang, Zhemin Zhang, Weihua Zang, Binyu Fudan Univ Parallel Proc Inst Shanghai Peoples R China

ISBN: (纸本)9781450311762

Code quality and compilation speed are two challenges to JIT compilers, while selective compilation is commonly used to trade-off these two issues. Meanwhile, with more and more Java applications running in mobile devices, selective compilation meets many problems. Since these applications always have flat execution profile and short live time, a lightweight JIT technique without losing code quality is extremely needed. However, the overhead of compiling stack-based Java bytecode to heterogeneous register-based machine code is significant in embedded devices. This paper presents a fast and effective JIT technique for mobile devices, building on a register-based Java bytecode format which is more similar to the underlying machine architecture. Through a comprehensive study on the characteristics of Java applications, we observe that virtual registers used by more than 90% Java methods can be directly fulfilled by 11 physical registers. Based on this observation, this paper proposes Swift, a novel JIT compiler on register-based bytecode, which generates native code for RISC machines. After mapping virtual registers to physical registers, the code is generated efficiently by looking up a translation table. And the code quality is guaranteed by the static compiler which is used to generate register-based bytecode. Besides, we design two lightweight optimizations and an efficient code unloader to make Swift more suitable for embedded environment. As the prevalence of Android, a prototype of Swift is implemented upon DEX bytecode which is the official distribution format of Android applications. Swift is evaluated with three benchmarks (SPECjvm98, EmbeddedCaffeineMark3 and JemBench2) on two different ARM SOCs: S3C6410 (armv6) and OMAP3530 (armv7). The results show that Swift achieves a speedup of 3.13 over the best-performing interpreter on the selected benchmarks. Compared with the state-of-the-art JIT compiler in Android, JITC-Droid, Swift achieves a speedup of 1.42.

关键词： Performance Language Design Register-based Bytecode just-in-time compiler Embedded JVM Android

来源：评论

学校读者我要写书评

暂无评论

HYBRID JAVA COMPILATION OF just-IN-time AND AHEAD-OF time FOR EMBEDDED SYSTEMS

引用

JOURNAL OF CIRCUITS SYSTEMS AND COMPUTERS 2012年第2期21卷 1240001-1-1240001-22页

作者： Oh, Hyeong-Seok Moon, Soo-Mook Jung, Dong-Heon Seoul Natl Univ Sch Elect Engn & Comp Sci Seoul 151742 South Korea

Many embedded Java software platforms execute two types of Java classes: those installed statically on the client device and those downloaded dynamically from service providers at runtime. For higher performance, it would be desirable to compile static Java classes by ahead-of-time compiler (AOTC) and to handle dynamically downloaded classes by just-in-time compiler (JITC), providing a hybrid compilation environment. This paper proposes a hybrid Java compilation approach and performs an initial case study with a hybrid environment, which is constructed simply by merging an existing AOTC and a JITC for the same Java virtual machine. Both compilers are developed independently for their own performance advantages with a generally accepted approach of compilation, but we merged them as effciently as possible. Contrary to our expectations, the hybrid environment does not deliver a performance, in-between of full-JITC's and full-AOTC's. In fact, its performance is even lower than full-JITC's for many benchmarks. We analyzed the result and found that a naive merge of JITC and AOTC may result in ineffciencies, especially due to calls between JITC methods and AOTC methods. Based on these observations, we propose some ideas to reduce such a call overhead. We also observed that the distribution of JITC methods and AOTC methods is also important, and experimented with various distributions to understand when a hybrid environment can deliver a desired performance. Finally, we discuss how JITC and AOTC should be designed for efficient hybrid execution.

关键词： Hybrid Java compilation ahead-of-time compiler just-in-time compiler JVM

来源：评论

学校读者我要写书评

暂无评论

A Method-Based Ahead-of-time compiler for Android Applications

A Method-Based Ahead-of-Time Compiler for Android Applicatio...

引用

14th Confernece on compilers, Architectures and Synthesis for Embedded Systems (CASES)

作者： Wang, Chih-Sheng Perez, Guillermo A. Chung, Yeh-Ching Hsu, Wei-Chung Shih, Wei-Kuan Hsu, Hong-Rong Natl Tsing Hua Univ Hsinchu Taiwan Natl Chiao Tung Univ Hsinchu Taiwan MediaTek Inc Hsinchu Taiwan

ISBN: (纸本)9781450307130

The execution environment of Android system is based on a virtual machine called Dalvik virtual machine (DVM) in which the execution of an application program is in interpret-mode. To reduce the interpretation overhead of DVM, Google has included a trace-based just-in-time compiler (JITC) in the latest version of Android. Due to limited resources and the requirement for reasonable response time, the JITC is unable to apply deep optimizations to generate high quality code. In this paper, we propose a method-based ahead-of-time compiler (AOTC), called Icing, to speed up the execution of Android applications without the modification of any components of Android framework. The main idea of Icing is to convert the hot methods of an application program from DEX code to C code and uses the GCC compiler to translate the C code to the corresponding native code. With the Java Native Interface (JNI) library, the translated native code can be called by DVM. Both AOTC and JITC have their strength and weakness. In order to combine the strength and avoid the weakness of AOTC and JITC, in Icing, we have proposed a cost model to determine whether a method should be handled by AOTC or JITC during profiling. To evaluate the performance of Icing, four benchmarks used by Google JITC are used as test cases. The performance results show that, with Icing, the execution time of an application is two to three times faster than that without JITC, and 25% to 110% faster than that with JITC.

关键词： Ahead-of-time compiler just-in-time compiler reverse engineering Android Dalvik bytecode static profiling

来源：评论

学校读者我要写书评

暂无评论

Lock Elision for Read-Only Critical Sections in Java 10

Lock Elision for Read-Only Critical Sections in Java

引用

ACM SIGPLAN Conference on Programming Language Design and Implementation

作者： Nakaike, Takuya Michael, Maged M. IBM Res Tokyo Tokyo Japan

ISBN: (纸本)9781450300193

It is not uncommon in parallel workloads to encounter shared data structures with read-mostly access patterns, where operations that update data are infrequent and most operations are read-only. Typically, data consistency is guaranteed using mutual exclusion or read-write locks. The cost of atomic update of lock variables result in high overheads and high cache coherence traffic under active sharing, thus slowing down single thread performance and limiting scalability. In this paper, we present SOLERO (Software Optimistic Lock Elision for Read-Only critical sections), a new lock implementation called for optimizing read-only critical sections in Java based on sequential locks. SOLERO is compatible with the conventional lock implementation of Java. However, unlike the conventional implementation, only critical sections that may write data or have side effects need to update lock variables, while read-only critical sections need only read lock variables without writing them. Each writing critical section changes the lock value to a new value. Hence, a read-only critical section is guaranteed to be consistent if the lock is free and its value does not change from the beginning to the end of the read-only critical section. Using Java workloads including SPECjbb2005 and the HashMap and TreeMap Java classes, we evaluate the performance impact of applying SOLERO to read-mostly locks. Our experimental results show performance improvements across the board, often substantial, in both single thread speed and scalability over the conventional lock implementation (mutual exclusion) and read-write locks. SOLERO improves the performance of SPECjbb2005 by 3-5% on single and multiple threads. The results using the HashMap and TreeMap benchmarks show that SOLERO outperforms the conventional lock implementation and read-write locks by substantial multiples on multi-threads.

关键词： Algorithms Languages Performance Java just-in-time compiler synchronization monitor lock optimization lock elision

来源：评论

学校读者我要写书评

暂无评论

Hybrid Java Compilation and Optimization for Digital TV Software Platform

Hybrid Java Compilation and Optimization for Digital TV Soft...

引用

8th International Symposium on Code Generation and Optimization

作者： Jung, Dong-Heon Moon, Soo-Mook Oh, Hyeong-Seok Seoul Natl Univ Sch Elect Engn & Comp Sci Seoul 151742 South Korea

ISBN: (纸本)9781605586359

The Java software platform for the interactive digital TV (DTV) is composed of the system/middleware classes statically installed on the DTV set-top box and the xlet classes dynamically downloaded from the TV stations, where xlets are executed only when the TV viewer initiates the interaction. In order to achieve high performance on this dual-component, user-initiated system, existing just-in-time compilation is not enough, but idle-time compilation and optimization as well as ahead-of-time compilation are also needed, requiring a hybrid compilation and optimization environment. We constructed such a hybrid environment for a commercial DTV software platform and experimented with real, on-air xlet applications. Our experimental results show that the proposed hybrid environment can improve the DTV Java performance by as much as an average of 150%, compared to the JITC-only environment.

关键词： Digital TV Java ahead-of-time compiler idle-time compiler just-in-time compiler xlets

来源：评论

学校读者我要写书评

暂无评论

Client ahead-of-time compiler for embedded Java platforms

引用

SOFTWARE-PRACTICE & EXPERIENCE 2009年第3期39卷 259-278页

作者： Hong, Sunghyun Kim, Jin-Chul Moon, Soo-Mook Shin, Jin Woo Lee, Jaemok Oh, Hyeong-Seok Choi, Hyung-Kyu Seoul Natl Univ Sch Elect Engn & Comp Sci Seoul 151742 South Korea

Many embedded Java platforms execute two types of Java classes: those installed statically on the client device and those downloaded dynamically from service providers at run time. For achieving higher performance, the static Java classes can be compiled into machine code by ahead-of-time compiler (AOTC) in the server, and the translated machine code can be installed on the client device. Unfortunately, AOTC cannot be applicable to the dynamically downloaded classes. This paper proposes client-AOTC (c-AOTC), which performs AOTC on the client device using the just-in-time compiler (JITC) module installed on the device, obviating the JITC overhead and complementing the server-AOTC. The machine code of a method translated by JITC is cached on a persistent memory of the device, and when the method is invoked again in a later run of the program, the machine code is loaded and executed directly without any translation overhead. A major issue in c-AOTC is relocation because sonic of the address constants embedded in the cached machine code are not correct when the machine code is loaded and used in a different run;those addresses should be corrected before they are used. Constant pool resolution and inlining complicate the relocation problem, and we propose our solutions. The persistent memory overhead for saving the relocation information is also an issue, and we propose a technique to encode the relocation information and compress the machine code efficiently. We developed a c-AOTC on Sun's CDC VM reference implementation, and our evaluation results indicate that c-AOTC can improve the performance significantly, as much as an average of 12% for EEMBC and 4% for SpecJVM98, with a persistent memory overhead of 1% on average. Copyright (c) 2008 John Wiley & Sons, Ltd.

关键词： Java ahead-of-time compiler just-in-time compiler relocation early binding Java virtual machine J2ME CDC

来源：评论

学校读者我要写书评

暂无评论

Java client ahead-of-time compiler for embedded systems

引用

ACM SIGPLAN NOTICES 2007年第7期42卷 63-72页

作者： Hong, Sunghyun Kim, Jin-Chul Shin, Jin Woo Moon, Soo-Mook Oh, Hyeong-Seok Lee, Jaemok Choi, Hyung-Kyu Seoul Natl Univ Sch Elect Engn & Comp Sci Seoul 151742 South Korea

The performance of embedded Java virtual machine can be improved by ahead-of-time compiler ( AOTC), which translates bytecode into machine code in the server and installs the machine code on the client device. Although AOTC is more advantageous than just-in-time compiler (JITC) due to its absence of the translation overhead, AOTC cannot be applicable to dynamically downloaded classes at runtime. This paper proposes client-AOTC (c-AOTC) which performs AOTC on the client device using the JITC module installed on the device, complementing the server-AOTC. The machine code of a method translated by JITC is cached on a persistent memory of the device, and when the method is invoked again in a later run of the program, the machine code is loaded and executed directly without the translation and interpretation overhead. One of major issues in c-AOTC is relocation because some of the addresses used by the cached machine code are not correct when the machine code is loaded and used in a different run;those addresses should be corrected before they are used. Constant pool resolution and inlining complicate the relocation problem and we propose our solutions. We developed a c-AOTC on Sun's CDC VM reference implementation ( RI) and our evaluation results indicate that cAOTC can improve the performance significantly, as much as an average of 12%. We also experiment with the issue of reducing the number of c-AOTC methods to be cached when the persistent space is tight, with a graceful degradation of performance.

关键词： Java ahead-of-time compiler just-in-time compiler relocation early binding Java virtual machine J2ME CDC performance experimentation languages

来源：评论

学校读者我要写书评

暂无评论

Java client ahead-of-time compiler for embedded systems 07

Java client ahead-of-time compiler for embedded systems

引用

Conference on Languages, compilers and Tools for Embedded Systems

作者： Hong, Sunghyun Kim, Jin-Chul Shin, Jin Woo Moon, Soo-Mook Oh, Hyeong-Seok Lee, Jaemok Choi, Hyung-Kyu Seoul Natl Univ Sch Elect Engn & Comp Sci Seoul 151742 South Korea

ISBN: (纸本)9781595936325

关键词： Java ahead-of-time compiler just-in-time compiler relocation early binding Java virtual machine J2ME CDC performance experimentation languages

来源：评论

学校读者我要写书评

暂无评论

建议与咨询留下您的常用邮箱和电话号码，以便我们向您反馈解决方案和替代方法

时间限定

文献类型

馆藏选择

核心期刊

语言

文献类型

帮助

文字说明：

检索规则说明：

检索范例：

分类表

所选分类

限定检索结果

文献类型

馆藏范围

日期分布

学科分类号

主题

机构

作者

语言

请选择保存的检索档案：

请选择收藏分类：

通借通还

建议与咨询 留下您的常用邮箱和电话号码，以便我们向您反馈解决方案和替代方法

时间限定

文献类型

馆藏选择

核心期刊

语言

文献类型

帮助

文字说明：

检索规则说明：

检索范例：

分类表

所选分类

限定检索结果

文献类型

馆藏范围

日期分布

学科分类号

主题

机构

作者

语言

请选择保存的检索档案： 新增检索档案 确定 取消

请选择收藏分类： 新增自定义分类 确定 取消

通借通还

建议与咨询留下您的常用邮箱和电话号码，以便我们向您反馈解决方案和替代方法

请选择保存的检索档案：

请选择收藏分类：