PLDI '89 Proceedings of the ACM SIGPLAN 1989 Conference on Programming language design and implementation
Fast, effective code generation in a just-in-time Java compiler
PLDI '98 Proceedings of the ACM SIGPLAN 1998 conference on Programming language design and implementation
The Jalapeño dynamic optimizing compiler for Java
JAVA '99 Proceedings of the ACM 1999 conference on Java Grande
Dynamo: a transparent dynamic optimization system
PLDI '00 Proceedings of the ACM SIGPLAN 2000 conference on Programming language design and implementation
A dynamic optimization framework for a Java just-in-time compiler
OOPSLA '01 Proceedings of the 16th ACM SIGPLAN conference on Object-oriented programming, systems, languages, and applications
Efficient implementation of the smalltalk-80 system
POPL '84 Proceedings of the 11th ACM SIGACT-SIGPLAN symposium on Principles of programming languages
LLVM: A Compilation Framework for Lifelong Program Analysis & Transformation
Proceedings of the international symposium on Code generation and optimization: feedback-directed and runtime optimization
The java hotspotTM server compiler
JVM'01 Proceedings of the 2001 Symposium on JavaTM Virtual Machine Research and Technology Symposium - Volume 1
Improved optimization of FORTRAN object programs
IBM Journal of Research and Development
Improving performance through deep value profiling and specialization with code transformation
Computer Languages, Systems and Structures
Hi-index | 0.00 |
Component-based frameworks for high-performance computing (HPC) are being developed in response to the increasing complexity of HPC software. These frameworks promote the development of clear programming interfaces that allow easy code reuse, distributed development, and inter-language operability. Unfortunately, the decoupled and dynamic nature of component-based applications prevent static compilers from applying optimization across components. Consequently, if components are used at too fine of a granularity they can impose a significant performance overhead -- a serious consequence in the HPC community. Therefore, this paper proposes dynamic compilation as a method for improving performance of component-based HPC applications, which would allow programmers to express programs at the most natural granularity. We introduce a technique called IR annotation in which a high-level intermediate representation (IR) of a program is embedded inside an optimized native executable. This approach leverages the benefits of multiple program representations at the cost of increased code size. The optimized code enables immediate execution at native speed while the IR allows selective dynamic re-compilation if runtime monitoring exposes performance problems. Our experimental results for using IR annotation on the Common Component Architecture (CCA), a component-based HPC framework, show that the program size increase is only about 2.5x. Finally, we propose several ideas that can potentially further reduce the code growth due to IR annotation.