Results 1 -
8 of
8
Field Analysis: Getting Useful and Low-cost Interprocedural Information
, 2000
"... We present a new limited form of interprocedural analysis called field analysis that can be used by a compiler to reduce the costs of modern language features such as objectoriented programming, automatic memory management, and run-time checks required for type safety. Unlike many previous interproc ..."
Abstract
-
Cited by 33 (2 self)
- Add to MetaCart
(Show Context)
We present a new limited form of interprocedural analysis called field analysis that can be used by a compiler to reduce the costs of modern language features such as objectoriented programming, automatic memory management, and run-time checks required for type safety. Unlike many previous interprocedural analyses, our analysis is cheap, and does not require access to the entire program. Field analysis exploits the declared access restrictions placed on fields in a modular language (e.g. field access modifiers in Java) in order to determine useful properties of fields of an object. We describe our implementation of field analysis in the Swift optimizing compiler for Java, as well a set of optimizations that exploit the results of field analysis. These optimizations include removal of run-time tests, compiletime resolution of method calls, object inlining, removal of unnecessary synchronization, and stack allocation. Our results demonstrate that field analysis is efficient and effectiv...
Supporting Precise Garbage Collection in Java Bytecodeto-C Ahead-of-Time Compiler for Embedded Systems
"... A Java bytecode-to-C ahead-of-time compiler (AOTC) can improve the performance of a Java virtual machine (JVM) by translating bytecode into C code, which is then compiled into machine code via an existing C compiler. Although AOTC is effective in embedded Java systems, a bytecode-to-C AOTC could not ..."
Abstract
- Add to MetaCart
A Java bytecode-to-C ahead-of-time compiler (AOTC) can improve the performance of a Java virtual machine (JVM) by translating bytecode into C code, which is then compiled into machine code via an existing C compiler. Although AOTC is effective in embedded Java systems, a bytecode-to-C AOTC could not easily employ precise garbage collection (GC) due to a difficulty in making a GC map, which keeps information on where each root live object is located when GC occurs. This is one of the reasons why all previous JVMs using a bytecode-to-C AOTC employed conservative GC, which can lead to poorer GC performance with more frequent memory shortage, especially in embedded systems where memory is tight. In this paper, we propose a way of allowing precise GC in a bytecode-to-C AOTC by generating additional C code which collects GC map-equivalent information at runtime. In order to reduce this runtime overhead, we also propose two optimization techniques which remove unnecessary C code. Our experimental results on Sun’s CVM indicate that we can support precise GC for bytecode-to-C AOTC with a relatively low overhead.
Abstract Field Analysis: Getting Useful and Low-cost Interprocedural Information
"... We present a new limited form of interprocedural analysis called field analysis that can be used by a compiler to reduce the costs of modern language features such as objectoriented programming, automatic memory management, and run-time checks required for type safety. Unlike many previous interproc ..."
Abstract
- Add to MetaCart
(Show Context)
We present a new limited form of interprocedural analysis called field analysis that can be used by a compiler to reduce the costs of modern language features such as objectoriented programming, automatic memory management, and run-time checks required for type safety. Unlike many previous interprocedural analyses, our analysis is cheap, and does not require access to the entire program. Field analysis exploits the declared access restrictions placed on fields in a modular language (e.g. field access modifiers in Java) in order to determine useful properties of fields of an object. We describe our implementation of field analysis in the Swift optimizing compiler for Java, as well a set of optimizations that exploit the results of field analysis. These optimizations include removal of run-time tests, compiletime resolution of method calls, object inlining, removal of unnecessary synchronization, and stack allocation. Our results demonstrate that field analysis is efficient and effective. Speedups average 7 % on a wide range of applications, with some times reduced by up to 27%. Compile time overhead of field analysis is about 10%. 1
Cross-Architectural Performance Portability of a Java Virtual Machine Implementation Abstract
, 2002
"... Permission is granted for noncommercial reproduction of the work for educational or research purposes. ..."
Abstract
- Add to MetaCart
(Show Context)
Permission is granted for noncommercial reproduction of the work for educational or research purposes.
Abstract Related Field Analysis
"... We present an extension of field analysis (see [4]) called related field analysis which is a general technique for proving relationships between two or more fields of an object. We demonstrate the feasibility and applicability of related field analysis by applying it to the problem of removing array ..."
Abstract
- Add to MetaCart
(Show Context)
We present an extension of field analysis (see [4]) called related field analysis which is a general technique for proving relationships between two or more fields of an object. We demonstrate the feasibility and applicability of related field analysis by applying it to the problem of removing array bounds checks. For array bounds check removal, we define a pair of related fields to be an integer field and an array field for which the integer field has a known relationship to the length of the array. This related field information can then be used to remove array bounds checks from accesses to the array field. Our results show that related field analysis can remove an average of 50 % of the dynamic array bounds checks on a wide range of applications. We describe the implementation of related field analysis in the Swift optimizing compiler for Java, as well as the optimizations that exploit the results of related field analysis. 1
A First Look at the Interplay of Code Reordering and Configurable Caches
, 2005
"... The instruction cache is a popular target for optimizations of microprocessor-based systems because of the cache's high impact on system performance and power, and because of the cache's predictable temporal and spatial locality. Optimization techniques can be designed based on this predic ..."
Abstract
- Add to MetaCart
The instruction cache is a popular target for optimizations of microprocessor-based systems because of the cache's high impact on system performance and power, and because of the cache's predictable temporal and spatial locality. Optimization techniques can be designed based on this predictability. We explore for the first time the interplay of two popular instruction cache optimization techniques: the long-known technique of code reordering and the relatively-new technique of cache configuration. We address the question of whether those two optimizations complement each other or if one optimization dominates the other. Through experiments using embedded system benchmarks, we show that cache configuration dominates a particular category of code reordering techniques with respect to optimizing performance and energy, obviating the need for reordering. We also examine the modern scenario of synthesized custom caches, and show that combining cache configuration with code reordering results in cache size reductions of 13% on average, and up to 89% in some benchmarks, beyond just cache configuration alone.
Lazy modules
- UNDER CONSIDERATION FOR PUBLICATION IN J. FUNCTIONAL PROGRAMMING
, 2009
"... We investigate evaluation strategies for ML-style modules supporting recursion. More precisely we propose and examine five evaluation strategies: a call-by-value strategy and four call-by-need strategies with different degrees of laziness. We formalize the strategies by translating a source syntax f ..."
Abstract
- Add to MetaCart
We investigate evaluation strategies for ML-style modules supporting recursion. More precisely we propose and examine five evaluation strategies: a call-by-value strategy and four call-by-need strategies with different degrees of laziness. We formalize the strategies by translating a source syntax for modules into target languages, which are very much inspired by Felleisen and Hieb’s callby-value lambda calculus with state and Ariola and Felleisen’s call-by-need cyclic lambda calculus. Different strategies are expressed by tweaking the translation as well as the operational semantics of the target languages. We look at the strategies through a series of examples and state inclusion between the strategies.
