The Experts below are selected from a list of 4567098 Experts worldwide ranked by ideXlab platform
David I. August - One of the best experts on this subject based on the ideXlab platform.
-
CGO - Automatically exploiting cross-invocation parallelism using runtime information
Proceedings of the 2013 IEEE ACM International Symposium on Code Generation and Optimization (CGO), 2013Co-Authors: David I. August, Jialu Huang, Stephen R. Beard, Nick P. Johnson, Thomas B. JablinAbstract:Automatic parallelization is a promising approach to producing scalable multi-threaded programs for multicore architectures. Many existing automatic techniques only parallelize iterations within a loop invocation and synchronize threads at the end of each loop invocation. When parallel code contains many loop invocations, synchronization can easily become a performance bottleneck. Some automatic techniques address this problem by exploiting cross-invocation parallelism. These techniques use static analysis to partition iterations among threads to avoid crossthread dependences. However, this partitioning is not always achievable at compile-time, because program input determines dependence patterns at run-time. By contrast, this paper proposes DOMORE, the first automatic parallelization technique that uses runtime information to exploit additional cross-invocation parallelism. Instead of partitioning iterations statically, DOMORE dynamically detects crossthread dependences and synchronizes only when necessary. DOMORE consists of a compiler and a runtime library. At compile time, DOMORE automatically parallelizes loops and inserts a custom runtime engine into programs. At run-time, the engine observes dependences and synchronizes iterations only when necessary. For six programs, DOMORE achieves a geomean loop speedup of 2.1× over parallel execution without cross-invocation parallelization and of 3.2 × over sequential execution on eight cores.
-
compiler optimization space exploration
Symposium on Code Generation and Optimization, 2003Co-Authors: Spyridon Triantafyllis, Manish Vachharajani, Neil Vachharajani, David I. AugustAbstract:To meet the demands of modern architectures, optimizing compilers must incorporate an ever larger number of increasingly complex transformation algorithms. Since code transformations may often degrade performance or interfere with subsequent transformations, compilers employ predictive heuristics to guide optimizations by predicting their effects a priori. Unfortunately, the unpredictability of optimization interaction and the irregularity of today's wide-issue machines severely limit the accuracy of these heuristics. As a result, compiler writers may temper high variance optimization with overly conservative heuristics or may exclude these optimizations entirely. While this process results in a compiler capable of generating good average code quality across the target benchmark set, it is at the cost of missed optimization opportunities in individual code segments.To replace predictive heuristics, researchers have proposed compilers which explore many optimization options, selecting the best one a posteriori. Unfortunately, these existing iterative compilation techniques are not practical for reasons of compile time and applicability. In this paper, we present the Optimization-Space Exploration (OSE) compiler organization, the first practical iterative compilation strategy applicable to optimizations in general-purpose compilers. Instead of replacing predictive heuristics, OSE uses the compiler writer's knowledge encoded in the heuristics to select a small number of promising optimization alternatives for a given code segment. Compile time is limited by evaluating only these alternatives for hot code segments using a general compiletime performance estimator. An OSE-enhanced version of lntel's highly-tuned, aggressively optimizing production compiler for IA-64 yields a significant performance improvement, more than 20% in some cases, on Itanium for SPEC codes.
-
CGO - Compiler optimization-space exploration
International Symposium on Code Generation and Optimization 2003. CGO 2003., 2003Co-Authors: Spyridon Triantafyllis, Manish Vachharajani, Neil Vachharajani, David I. AugustAbstract:To meet the demands of modern architectures, optimizing compilers must incorporate an ever larger number of increasingly complex transformation algorithms. Since code transformations may often degrade performance or interfere with subsequent transformations, compilers employ predictive heuristics to guide optimizations by predicting their effects a priori. Unfortunately, the unpredictability of optimization interaction and the irregularity of today's wide-issue machines severely limit the accuracy of these heuristics. As a result, compiler writers may temper high variance optimization with overly conservative heuristics or may exclude these optimizations entirely. While this process results in a compiler capable of generating good average code quality across the target benchmark set, it is at the cost of missed optimization opportunities in individual code segments.To replace predictive heuristics, researchers have proposed compilers which explore many optimization options, selecting the best one a posteriori. Unfortunately, these existing iterative compilation techniques are not practical for reasons of compile time and applicability. In this paper, we present the Optimization-Space Exploration (OSE) compiler organization, the first practical iterative compilation strategy applicable to optimizations in general-purpose compilers. Instead of replacing predictive heuristics, OSE uses the compiler writer's knowledge encoded in the heuristics to select a small number of promising optimization alternatives for a given code segment. Compile time is limited by evaluating only these alternatives for hot code segments using a general compiletime performance estimator. An OSE-enhanced version of lntel's highly-tuned, aggressively optimizing production compiler for IA-64 yields a significant performance improvement, more than 20% in some cases, on Itanium for SPEC codes.
-
compiler optimization space exploration
Symposium on Code Generation and Optimization, 2003Co-Authors: Spyridon Triantafyllis, Manish Vachharajani, Neil Vachharajani, David I. AugustAbstract:To meet the demands of modern architectures, optimizing compilers must incorporate an ever larger number of increasingly complex transformation algorithms. Since code transformations may often degrade performance or interfere with subsequent transformations, compilers employ predictive heuristics to guide optimizations by predicting their effects a priori. Unfortunately, the unpredictability of optimization interaction and the irregularity of today's wide-issue machines severely limit the accuracy of these heuristics. As a result, compiler writers may temper high variance optimization with overly conservative heuristics or may exclude these optimizations entirely. While this process results in a compiler capable of generating good average code quality across the target benchmark set, it is at the cost of missed optimization opportunities in individual code segments.To replace predictive heuristics, researchers have proposed compilers which explore many optimization options, selecting the best one a posteriori. Unfortunately, these existing iterative compilation techniques are not practical for reasons of compile time and applicability. In this paper, we present the Optimization-Space Exploration (OSE) compiler organization, the first practical iterative compilation strategy applicable to optimizations in general-purpose compilers. Instead of replacing predictive heuristics, OSE uses the compiler writer's knowledge encoded in the heuristics to select a small number of promising optimization alternatives for a given code segment. Compile time is limited by evaluating only these alternatives for hot code segments using a general compiletime performance estimator. An OSE-enhanced version of lntel's highly-tuned, aggressively optimizing production compiler for IA-64 yields a significant performance improvement, more than 20% in some cases, on Itanium for SPEC codes.
Charles E. Leiserson - One of the best experts on this subject based on the ideXlab platform.
-
tapir embedding fork join parallelism into llvm s intermediate representation
ACM SIGPLAN Symposium on Principles and Practice of Parallel Programming, 2017Co-Authors: Tao B Schardl, William S. Moses, Charles E. LeisersonAbstract:This paper explores how fork-join parallelism, as supported by concurrency platforms such as Cilk and OpenMP, can be embedded into a compiler's intermediate representation (IR). Mainstream compilers typically treat parallel linguistic constructs as syntactic sugar for function calls into a parallel runtime. These calls prevent the compiler from performing optimizations across parallel control constructs. Remedying this situation is generally thought to require an extensive reworking of compiler analyses and code transformations to handle parallel semantics. Tapir is a compiler IR that represents logically parallel tasks asymmetrically in the program's control flow graph. Tapir allows the compiler to optimize across parallel control constructs with only minor changes to its existing analyses and code transformations. To prototype Tapir in the LLVM compiler, for example, we added or modified about 6000 lines of LLVM's 4-million-line codebase. Tapir enables LLVM's existing compiler optimizations for serial code -- including loop-invariant-code motion, common-subexpression elimination, and tail-recursion elimination -- to work with parallel control constructs such as spawning and parallel loops. Tapir also supports parallel optimizations such as loop scheduling.
-
PPOPP - Tapir: Embedding Fork-Join Parallelism into LLVM's Intermediate Representation
Proceedings of the 22nd ACM SIGPLAN Symposium on Principles and Practice of Parallel Programming, 2017Co-Authors: Tao B Schardl, William S. Moses, Charles E. LeisersonAbstract:This paper explores how fork-join parallelism, as supported by concurrency platforms such as Cilk and OpenMP, can be embedded into a compiler's intermediate representation (IR). Mainstream compilers typically treat parallel linguistic constructs as syntactic sugar for function calls into a parallel runtime. These calls prevent the compiler from performing optimizations across parallel control constructs. Remedying this situation is generally thought to require an extensive reworking of compiler analyses and code transformations to handle parallel semantics. Tapir is a compiler IR that represents logically parallel tasks asymmetrically in the program's control flow graph. Tapir allows the compiler to optimize across parallel control constructs with only minor changes to its existing analyses and code transformations. To prototype Tapir in the LLVM compiler, for example, we added or modified about 6000 lines of LLVM's 4-million-line codebase. Tapir enables LLVM's existing compiler optimizations for serial code -- including loop-invariant-code motion, common-subexpression elimination, and tail-recursion elimination -- to work with parallel control constructs such as spawning and parallel loops. Tapir also supports parallel optimizations such as loop scheduling.
Tao B Schardl - One of the best experts on this subject based on the ideXlab platform.
-
tapir embedding fork join parallelism into llvm s intermediate representation
ACM SIGPLAN Symposium on Principles and Practice of Parallel Programming, 2017Co-Authors: Tao B Schardl, William S. Moses, Charles E. LeisersonAbstract:This paper explores how fork-join parallelism, as supported by concurrency platforms such as Cilk and OpenMP, can be embedded into a compiler's intermediate representation (IR). Mainstream compilers typically treat parallel linguistic constructs as syntactic sugar for function calls into a parallel runtime. These calls prevent the compiler from performing optimizations across parallel control constructs. Remedying this situation is generally thought to require an extensive reworking of compiler analyses and code transformations to handle parallel semantics. Tapir is a compiler IR that represents logically parallel tasks asymmetrically in the program's control flow graph. Tapir allows the compiler to optimize across parallel control constructs with only minor changes to its existing analyses and code transformations. To prototype Tapir in the LLVM compiler, for example, we added or modified about 6000 lines of LLVM's 4-million-line codebase. Tapir enables LLVM's existing compiler optimizations for serial code -- including loop-invariant-code motion, common-subexpression elimination, and tail-recursion elimination -- to work with parallel control constructs such as spawning and parallel loops. Tapir also supports parallel optimizations such as loop scheduling.
-
PPOPP - Tapir: Embedding Fork-Join Parallelism into LLVM's Intermediate Representation
Proceedings of the 22nd ACM SIGPLAN Symposium on Principles and Practice of Parallel Programming, 2017Co-Authors: Tao B Schardl, William S. Moses, Charles E. LeisersonAbstract:This paper explores how fork-join parallelism, as supported by concurrency platforms such as Cilk and OpenMP, can be embedded into a compiler's intermediate representation (IR). Mainstream compilers typically treat parallel linguistic constructs as syntactic sugar for function calls into a parallel runtime. These calls prevent the compiler from performing optimizations across parallel control constructs. Remedying this situation is generally thought to require an extensive reworking of compiler analyses and code transformations to handle parallel semantics. Tapir is a compiler IR that represents logically parallel tasks asymmetrically in the program's control flow graph. Tapir allows the compiler to optimize across parallel control constructs with only minor changes to its existing analyses and code transformations. To prototype Tapir in the LLVM compiler, for example, we added or modified about 6000 lines of LLVM's 4-million-line codebase. Tapir enables LLVM's existing compiler optimizations for serial code -- including loop-invariant-code motion, common-subexpression elimination, and tail-recursion elimination -- to work with parallel control constructs such as spawning and parallel loops. Tapir also supports parallel optimizations such as loop scheduling.
Spyridon Triantafyllis - One of the best experts on this subject based on the ideXlab platform.
-
compiler optimization space exploration
Symposium on Code Generation and Optimization, 2003Co-Authors: Spyridon Triantafyllis, Manish Vachharajani, Neil Vachharajani, David I. AugustAbstract:To meet the demands of modern architectures, optimizing compilers must incorporate an ever larger number of increasingly complex transformation algorithms. Since code transformations may often degrade performance or interfere with subsequent transformations, compilers employ predictive heuristics to guide optimizations by predicting their effects a priori. Unfortunately, the unpredictability of optimization interaction and the irregularity of today's wide-issue machines severely limit the accuracy of these heuristics. As a result, compiler writers may temper high variance optimization with overly conservative heuristics or may exclude these optimizations entirely. While this process results in a compiler capable of generating good average code quality across the target benchmark set, it is at the cost of missed optimization opportunities in individual code segments.To replace predictive heuristics, researchers have proposed compilers which explore many optimization options, selecting the best one a posteriori. Unfortunately, these existing iterative compilation techniques are not practical for reasons of compile time and applicability. In this paper, we present the Optimization-Space Exploration (OSE) compiler organization, the first practical iterative compilation strategy applicable to optimizations in general-purpose compilers. Instead of replacing predictive heuristics, OSE uses the compiler writer's knowledge encoded in the heuristics to select a small number of promising optimization alternatives for a given code segment. Compile time is limited by evaluating only these alternatives for hot code segments using a general compiletime performance estimator. An OSE-enhanced version of lntel's highly-tuned, aggressively optimizing production compiler for IA-64 yields a significant performance improvement, more than 20% in some cases, on Itanium for SPEC codes.
-
CGO - Compiler optimization-space exploration
International Symposium on Code Generation and Optimization 2003. CGO 2003., 2003Co-Authors: Spyridon Triantafyllis, Manish Vachharajani, Neil Vachharajani, David I. AugustAbstract:To meet the demands of modern architectures, optimizing compilers must incorporate an ever larger number of increasingly complex transformation algorithms. Since code transformations may often degrade performance or interfere with subsequent transformations, compilers employ predictive heuristics to guide optimizations by predicting their effects a priori. Unfortunately, the unpredictability of optimization interaction and the irregularity of today's wide-issue machines severely limit the accuracy of these heuristics. As a result, compiler writers may temper high variance optimization with overly conservative heuristics or may exclude these optimizations entirely. While this process results in a compiler capable of generating good average code quality across the target benchmark set, it is at the cost of missed optimization opportunities in individual code segments.To replace predictive heuristics, researchers have proposed compilers which explore many optimization options, selecting the best one a posteriori. Unfortunately, these existing iterative compilation techniques are not practical for reasons of compile time and applicability. In this paper, we present the Optimization-Space Exploration (OSE) compiler organization, the first practical iterative compilation strategy applicable to optimizations in general-purpose compilers. Instead of replacing predictive heuristics, OSE uses the compiler writer's knowledge encoded in the heuristics to select a small number of promising optimization alternatives for a given code segment. Compile time is limited by evaluating only these alternatives for hot code segments using a general compiletime performance estimator. An OSE-enhanced version of lntel's highly-tuned, aggressively optimizing production compiler for IA-64 yields a significant performance improvement, more than 20% in some cases, on Itanium for SPEC codes.
-
compiler optimization space exploration
Symposium on Code Generation and Optimization, 2003Co-Authors: Spyridon Triantafyllis, Manish Vachharajani, Neil Vachharajani, David I. AugustAbstract:To meet the demands of modern architectures, optimizing compilers must incorporate an ever larger number of increasingly complex transformation algorithms. Since code transformations may often degrade performance or interfere with subsequent transformations, compilers employ predictive heuristics to guide optimizations by predicting their effects a priori. Unfortunately, the unpredictability of optimization interaction and the irregularity of today's wide-issue machines severely limit the accuracy of these heuristics. As a result, compiler writers may temper high variance optimization with overly conservative heuristics or may exclude these optimizations entirely. While this process results in a compiler capable of generating good average code quality across the target benchmark set, it is at the cost of missed optimization opportunities in individual code segments.To replace predictive heuristics, researchers have proposed compilers which explore many optimization options, selecting the best one a posteriori. Unfortunately, these existing iterative compilation techniques are not practical for reasons of compile time and applicability. In this paper, we present the Optimization-Space Exploration (OSE) compiler organization, the first practical iterative compilation strategy applicable to optimizations in general-purpose compilers. Instead of replacing predictive heuristics, OSE uses the compiler writer's knowledge encoded in the heuristics to select a small number of promising optimization alternatives for a given code segment. Compile time is limited by evaluating only these alternatives for hot code segments using a general compiletime performance estimator. An OSE-enhanced version of lntel's highly-tuned, aggressively optimizing production compiler for IA-64 yields a significant performance improvement, more than 20% in some cases, on Itanium for SPEC codes.
Arno Puder - One of the best experts on this subject based on the ideXlab platform.
-
PPPJ - Cross-compiling Java to JavaScript via tool-chaining
Proceedings of the 2013 International Conference on Principles and Practices of Programming on the Java Platform: Virtual Machines Languages and Tools, 2013Co-Authors: Arno Puder, Victor Woeltjen, Alon ZakaiAbstract:Cross-compilation translates between different high-level programming languages and enables programmers to use their skill-set on a platform that ordinarily does not support their preferred language. E.g., web applications for desktop browsers and mobile devices such as Firefox OS or Tizen need to be written in JavaScript and are not easily accessible to Java developers. The combinatoric explosion of possible Cross-Compilers between languages leads to the idea of tool-chaining: instead of a dedicated Cross-Compiler, chain two already existing Cross-Compilers. In this paper we demonstrate the chaining of two Cross-Compilers -- XMLVM and Emscripten -- to translate first from Java to C and then from C to JavaScript. We describe minor adjustments to XMLVM and Emscripten to optimize the generated code resulting in a competitive Cross-Compiler. Benchmarks show that tool-chaining yields similar performance relative to dedicated Cross-Compilers. Specifically, we will compare XMLVM/Emscripten with Google's GWT.
-
Cross-compiling Android applications to iOS and windows phone 7
Mobile Networks and Applications, 2013Co-Authors: Arno Puder, Oren AntebiAbstract:Android is currently leading the smartphone segment in terms of market share since its introduction in 2007. Android applications are written in Java using an API designed for mobile apps. Other smartphone platforms, such as Apple’s iOS or Microsoft’s Windows Phone 7, differ greatly in their native application programming model. App developers who want to publish their applications for different platforms are required to re-implement the application using the respective native SDK. In this paper we describe a cross-compilation approach, whereby Android applications are cross-compiled to C# for Windows Phone 7. We describe different aspects of our Cross-Compiler, from byte code level cross-compilation to API mapping. A prototype of our Cross-Compiler called XMLVM is available under an Open Source license.
-
MobiCASE - Cross-Compiling Android Applications to Windows Phone 7
Lecture Notes of the Institute for Computer Sciences Social Informatics and Telecommunications Engineering, 2012Co-Authors: Oren Antebi, Markus Neubrand, Arno PuderAbstract:Android is currently leading the smartphone segment in terms of market share since its introduction in 2007. Android applications are written in Java using an API designed for mobile apps. Other smartphone platforms, such as Apple’s iOS or Microsoft’s Windows Phone 7, differ greatly in their native application programming model. App developers who want to publish their applications for different platforms are required to re-implement the application using the respective native SDK. In this paper we describe a cross-compilation approach, whereby Android applications are cross-compiled to C# for Windows Phone 7. We describe different aspects of our Cross-Compiler, from byte code level cross-compilation to API mapping. A prototype of our Cross-Compiler called XMLVM is available under an Open Source license.
-
MOBILWARE - Running Android Applications without a Virtual Machine
Lecture Notes of the Institute for Computer Sciences Social Informatics and Telecommunications Engineering, 2012Co-Authors: Arno PuderAbstract:Android has gained significant popularity in the smartphone market since its introduction in 2007. While Android applications are written in Java, Android uses its own virtual machine called Dalvik. Other smartphone platforms, most notably Apple’s iOS, do not permit the installation of any kind of virtual machine. App developers who want to publish their applications for different platforms are required to re-implement the application using the respective native SDK. In this paper we describe a cross-compilation approach, whereby Android applications are cross-compiled to portable C code. With this approach it is not necessary to have a Dalvik virtual machine deployed on the target platform. We describe different aspects of our Cross-Compiler, from byte code level cross-compilation, memory management, to API mapping. A prototype of our Cross-Compiler called XMLVM is available under an Open Source license.
-
Smartphone Cross-Compilation Framework for Multiplayer Online Games
2010 Second International Conference on Mobile Hybrid and On-Line Learning, 2010Co-Authors: Arno Puder, Ilmi YoonAbstract:Social networks and multiplayer online games have drastically gained in popularity over the last decade. Likewise smartphones have become interesting targets for extending social networks and multiplayer games thanks to their innovative features such as intuitive user interfaces. Mobile versions of games and social network applications often make use of special capabilities of smartphones such as GPS and accelerometer. Porting these applications to different smartphones incurs high overhead due to their different programming models. To facilitate this porting effort, we introduce XMLVM, a byte code level Cross-Compiler to overcome the heterogeneity of the different programming models used by various smartphones. Specifically, we show how XMLVM can cross-compile an Android application to the iPhone and the Palm Pre, thereby significantly reducing the porting effort. The Cross-Compiler is based on Java byte code instructions that are translated to high-level programming languages supported by the targeted smartphone. Compatibility libraries map the API between smartphones. As a proof of concept, we have implemented a strategy game the demonstrate the feasibility of our approach.