The Experts below are selected from a list of 144 Experts worldwide ranked by ideXlab platform
Toshio Nakatani - One of the best experts on this subject based on the ideXlab platform.
-
A region-based Compilation technique for dynamic compilers
ACM Transactions on Programming Languages and Systems, 2006Co-Authors: Toshio Suganuma, Toshiaki Yasue, Toshio NakataniAbstract:Method inlining and data flow analysis are two major optimization components for effective program transformations, but they often suffer from the existence of rarely or never executed code contained in the target method. One major problem lies in the assumption that the Compilation Unit is partitioned at method boundaries. This article describes the design and implementation of a region-based Compilation technique in our dynamic optimization framework, in which the compiled regions are selected as code portions without rarely executed code. The key parts of this technique are the region selection, partial inlining, and region exit handling. For region selection, we employ both static heuristics and dynamic profiles to identify and eliminate rare sections of code. The region selection process and method inlining decisions are interwoven, so that method inlining exposes other targets for region selection, while the region selection in the inline target conserves the inlining budget, allowing more method inlining to be performed. The inlining process can be performed for parts of a method, not just for the entire body of the method. When the program attempts to exit from a region boundary, we trigger reCompilation and then use on-stack replacement to continue the execution from the corresponding entry point in the recompiled code. We have implemented these techniques in our Java JIT compiler, and conducted a comprehensive evaluation. The experimental results show that our region-based Compilation approach achieves approximately 4p performance improvement on average, while reducing the Compilation overhead by 10p to 30p, in comparison to the traditional method-based Compilation techniques.
-
PLDI - A region-based Compilation technique for a Java just-in-time compiler
Proceedings of the ACM SIGPLAN 2003 conference on Programming language design and implementation - PLDI '03, 2003Co-Authors: Toshio Suganuma, Toshiaki Yasue, Toshio NakataniAbstract:Method inlining and data flow analysis are two major optimization components for effective program transformations, however they often suffer from the existence of rarely or never executed code contained in the target method. One major problem lies in the assumption that the Compilation Unit is partitioned at method boundaries. This paper describes the design and implementation of a region-based Compilation technique in our dynamic Compilation system, in which the compiled regions are selected as code portions without rarely executed code. The key part of this technique is the region selection, partial inlining, and region exit handling. For region selection, we employ both static heuristics and dynamic profiles to identify rare sections of code. The region selection process and method inlining decision are interwoven, so that method inlining exposes other targets for region selection, while the region selection in the inline target conserves the inlining budget, leading to more method inlining. Thus the inlining process can be performed for parts of a method, not for the entire body of the method. When the program attempts to exit from a region boundary, we trigger reCompilation and then rely on on-stack replacement to continue the execution from the corresponding entry point in the recompiled code. We have implemented these techniques in our Java JIT compiler, and conducted a comprehensive evaluation. The experimental results show that the approach of region-based Compilation achieves approximately 5% performance improvement on average, while reducing the Compilation overhead by 20 to 30%, in comparison to the traditional function-based Compilation techniques.
Toshio Suganuma - One of the best experts on this subject based on the ideXlab platform.
-
A region-based Compilation technique for dynamic compilers
ACM Transactions on Programming Languages and Systems, 2006Co-Authors: Toshio Suganuma, Toshiaki Yasue, Toshio NakataniAbstract:Method inlining and data flow analysis are two major optimization components for effective program transformations, but they often suffer from the existence of rarely or never executed code contained in the target method. One major problem lies in the assumption that the Compilation Unit is partitioned at method boundaries. This article describes the design and implementation of a region-based Compilation technique in our dynamic optimization framework, in which the compiled regions are selected as code portions without rarely executed code. The key parts of this technique are the region selection, partial inlining, and region exit handling. For region selection, we employ both static heuristics and dynamic profiles to identify and eliminate rare sections of code. The region selection process and method inlining decisions are interwoven, so that method inlining exposes other targets for region selection, while the region selection in the inline target conserves the inlining budget, allowing more method inlining to be performed. The inlining process can be performed for parts of a method, not just for the entire body of the method. When the program attempts to exit from a region boundary, we trigger reCompilation and then use on-stack replacement to continue the execution from the corresponding entry point in the recompiled code. We have implemented these techniques in our Java JIT compiler, and conducted a comprehensive evaluation. The experimental results show that our region-based Compilation approach achieves approximately 4p performance improvement on average, while reducing the Compilation overhead by 10p to 30p, in comparison to the traditional method-based Compilation techniques.
-
PLDI - A region-based Compilation technique for a Java just-in-time compiler
Proceedings of the ACM SIGPLAN 2003 conference on Programming language design and implementation - PLDI '03, 2003Co-Authors: Toshio Suganuma, Toshiaki Yasue, Toshio NakataniAbstract:Method inlining and data flow analysis are two major optimization components for effective program transformations, however they often suffer from the existence of rarely or never executed code contained in the target method. One major problem lies in the assumption that the Compilation Unit is partitioned at method boundaries. This paper describes the design and implementation of a region-based Compilation technique in our dynamic Compilation system, in which the compiled regions are selected as code portions without rarely executed code. The key part of this technique is the region selection, partial inlining, and region exit handling. For region selection, we employ both static heuristics and dynamic profiles to identify rare sections of code. The region selection process and method inlining decision are interwoven, so that method inlining exposes other targets for region selection, while the region selection in the inline target conserves the inlining budget, leading to more method inlining. Thus the inlining process can be performed for parts of a method, not for the entire body of the method. When the program attempts to exit from a region boundary, we trigger reCompilation and then rely on on-stack replacement to continue the execution from the corresponding entry point in the recompiled code. We have implemented these techniques in our Java JIT compiler, and conducted a comprehensive evaluation. The experimental results show that the approach of region-based Compilation achieves approximately 5% performance improvement on average, while reducing the Compilation overhead by 20 to 30%, in comparison to the traditional function-based Compilation techniques.
Toshiaki Yasue - One of the best experts on this subject based on the ideXlab platform.
-
A region-based Compilation technique for dynamic compilers
ACM Transactions on Programming Languages and Systems, 2006Co-Authors: Toshio Suganuma, Toshiaki Yasue, Toshio NakataniAbstract:Method inlining and data flow analysis are two major optimization components for effective program transformations, but they often suffer from the existence of rarely or never executed code contained in the target method. One major problem lies in the assumption that the Compilation Unit is partitioned at method boundaries. This article describes the design and implementation of a region-based Compilation technique in our dynamic optimization framework, in which the compiled regions are selected as code portions without rarely executed code. The key parts of this technique are the region selection, partial inlining, and region exit handling. For region selection, we employ both static heuristics and dynamic profiles to identify and eliminate rare sections of code. The region selection process and method inlining decisions are interwoven, so that method inlining exposes other targets for region selection, while the region selection in the inline target conserves the inlining budget, allowing more method inlining to be performed. The inlining process can be performed for parts of a method, not just for the entire body of the method. When the program attempts to exit from a region boundary, we trigger reCompilation and then use on-stack replacement to continue the execution from the corresponding entry point in the recompiled code. We have implemented these techniques in our Java JIT compiler, and conducted a comprehensive evaluation. The experimental results show that our region-based Compilation approach achieves approximately 4p performance improvement on average, while reducing the Compilation overhead by 10p to 30p, in comparison to the traditional method-based Compilation techniques.
-
PLDI - A region-based Compilation technique for a Java just-in-time compiler
Proceedings of the ACM SIGPLAN 2003 conference on Programming language design and implementation - PLDI '03, 2003Co-Authors: Toshio Suganuma, Toshiaki Yasue, Toshio NakataniAbstract:Method inlining and data flow analysis are two major optimization components for effective program transformations, however they often suffer from the existence of rarely or never executed code contained in the target method. One major problem lies in the assumption that the Compilation Unit is partitioned at method boundaries. This paper describes the design and implementation of a region-based Compilation technique in our dynamic Compilation system, in which the compiled regions are selected as code portions without rarely executed code. The key part of this technique is the region selection, partial inlining, and region exit handling. For region selection, we employ both static heuristics and dynamic profiles to identify rare sections of code. The region selection process and method inlining decision are interwoven, so that method inlining exposes other targets for region selection, while the region selection in the inline target conserves the inlining budget, leading to more method inlining. Thus the inlining process can be performed for parts of a method, not for the entire body of the method. When the program attempts to exit from a region boundary, we trigger reCompilation and then rely on on-stack replacement to continue the execution from the corresponding entry point in the recompiled code. We have implemented these techniques in our Java JIT compiler, and conducted a comprehensive evaluation. The experimental results show that the approach of region-based Compilation achieves approximately 5% performance improvement on average, while reducing the Compilation overhead by 20 to 30%, in comparison to the traditional function-based Compilation techniques.
Guido Salvaneschi - One of the best experts on this subject based on the ideXlab platform.
-
SuperCompCloud@SC - Leveraging Hybrid Cloud HPC with Multitier Reactive Programming
2020Co-Authors: Daniel Sokolowski, Jan-patrick Lehr, Christian Bischof, Guido SalvaneschiAbstract:The advent of cloud computing has enabled large-scale availability of on-demand computing and storage resources. However, these benefits are not yet at the fingertips of HPC developers: Typical HPC applications use on-premise computing resources and rely on static deployment setups, reliable hardware, and rather homogeneous resources. This hinders (partial) execution in the cloud, even though applications could benefit from scaling beyond on-premise resources and from the variety of hardware available in the cloud to speed up execution.To address this issue, we orchestrate computationally intensive kernels using a high-level programming language that ensures advanced optimization and improves execution flexibility—enabling hybrid cloud/on-premise HPC deployments. Our approach is based on multitier reactive programming, where distributed code is defined within the same Compilation Unit and computations are placed explicitly using placement types. We adjust placement based on performance characteristics measured before execution, apply our approach to a shortest vector problem (SVP) solver from cryptanalysis, and evaluate it to be effective.
-
A Survey of Multitier Programming
ACM Computing Surveys, 2020Co-Authors: Pascal Weisenburger, Johannes Wirth, Guido SalvaneschiAbstract:Multitier programming deals with developing the components that pertain to different tiers in the system (e.g., client and server), mixing them in the same Compilation Unit. In this paradigm, the c...
Hanspeter Mossenbock - One of the best experts on this subject based on the ideXlab platform.
-
VMIL@SPLASH - A cost model for a graph-based intermediate-representation in a dynamic compiler
Proceedings of the 10th ACM SIGPLAN International Workshop on Virtual Machines and Intermediate Languages - VMIL 2018, 2018Co-Authors: David Leopoldseder, Lukas Stadler, Manuel Rigger, Thomas Würthinger, Hanspeter MossenbockAbstract:Compilers provide many architecture-agnostic, high-level optimizations trading off peak performance for code size. High-level optimizations typically cannot precisely reason about their impact, as they are applied before the final shape of the generated machine code can be determined. However, they still need a way to estimate their transformation’s impact on the performance of a Compilation Unit. Therefore, compilers typically resort to modelling these estimations as trade-off functions that heuristically guide optimization decisions. Compilers such as Graal implement many such handcrafted heuristic trade-off functions, which are tuned for one particular high-level optimization. Heuristic trade-off functions base their reasoning on limited knowledge of the Compilation Unit, often causing transformations that heavily increase code size or even decrease performance. To address this problem, we propose a cost model for Graal’s high-level intermediate representation that models relative operation latencies and operation sizes in order to be used in trade-off functions of compiler optimizations. We implemented the cost model in Graal and used it in two code-duplication-based optimizations. This allowed us to perform a more fine-grained code size trade-off in existing compiler optimizations, reducing the code size increase of our optimizations by up to 50% compared to not using the proposed cost model in these optimizations, without sacrificing performance. Our evaluation demonstrates that the cost model allows optimizations to perform fine-grained code size and performance trade-offs outperforming hard-coded heuristics.
-
ManLang - Trace Register Allocation Policies: Compile-time vs. Performance Trade-offs
Proceedings of the 14th International Conference on Managed Languages and Runtimes, 2017Co-Authors: Josef Eisl, Thomas Würthinger, Stefan Marr, Hanspeter MossenbockAbstract:Register allocation is an integral part of Compilation, regardless of whether a compiler aims for fast Compilation or optimal code quality. State-of-the-art dynamic compilers often use global register allocation approaches such as linear scan. Recent results suggest that non-global trace-based register allocation approaches can compete with global approaches in terms of allocation quality. Instead of processing the whole Compilation Unit (i.e., method) at once, a trace-based register allocator divides the problem into linear code segments, called traces. In this work, we present a register allocation framework that can exploit the additional flexibility of traces to select different allocation strategies based on the characteristics of a trace. This provides us with fine-grained control over the trade-off between compile time and peak performance in a just-in-time compiler. Our framework features three allocation strategies: a linear-scan-based approach that achieves good code quality, a single-pass bottom-up strategy that aims for short allocation times, and an allocator for trivial traces. To demonstrate the flexibility of the framework, we select 8 allocation policies and show their impact on compile time and peak performance. This approach can reduce allocation time by 7%--43% at a peak performance penalty of about 1%--11% on average. For systems that do not focus on peak performance, our approach allows to adjust the time spent for register allocation, and therefore the overall Compilation time, thus finding the optimal balance between compile time and peak performance according to an application's requirements.
-
PPPJ - Trace-based Register Allocation in a JIT Compiler
Proceedings of the 13th International Conference on Principles and Practices of Programming on the Java Platform: Virtual Machines Languages and Tools, 2016Co-Authors: Josef Eisl, Thomas Würthinger, Matthias Grimmer, Doug Simon, Hanspeter MossenbockAbstract:State-of-the-art dynamic compilers often use global approaches, like Linear Scan or Graph Coloring, for register allocation. These algorithms consider the complete Compilation Unit for allocation, which increases the complexity of the implementation (e.g., support for lifetime holes in Linear Scan) and potentially also affects Compilation time. We propose a novel non-global algorithm, which splits a Compilation Unit into traces based on profiling feedback and subsequently performs register allocation within each trace individually. Traces reduce the problem size to a single linear code segment, which simplifies the problem a register allocator needs to solve. Additionally, we can apply different register allocation algorithms to each trace. We show that this non-global approach can achieve results competitive to global register allocation. We present an implementation of Trace Register Allocation based on the Graal VM and show an evaluation for common Java benchmarks. We demonstrate that performance of this non-global approach is within 3% (on AMD64) and 1% (on SPARC) of global Linear Scan register allocation.