An intermediate representation for speculative optimizations in a dynamic compiler

Duboscq, Gilles; Würthinger, Thomas; Wimmer, Christian; Simon, Doug; Mössenböck, Hanspeter

doi:10.1145/2542142.2542143

Cited by 94 publications

(54 citation statements)

References 26 publications

(23 reference statements)

Supporting

Mentioning

Contrasting

Order By: Relevance

“…For example, when accessing an Array object, it does the following: Dynamic compilers (such as the Graal compiler) can eliminate many of these checks and can therefore reduce the run-time overhead [12,13,38,44]. Using conditional elimination [38], the Graal compiler can remove redundant run-time checks by merging them.…”

Section: Discussionmentioning

confidence: 99%

“…Conditional elimination reduces the number of conditional expressions by performing a data-flow analysis over the IR graph and pruning conditions that can be proven to be true. Loop invariant code motion [12,13] moves run-time checks out of loops if the compiler can prove that a condition is loop-invariant. In this case, the static number of checks remains the same, but a check outside a loop is likely to be executed less often than inside a loop.…”

Section: Discussionmentioning

confidence: 99%

See 1 more Smart Citation

Memory-safe Execution of C on a Java VM

Grimmer

Schatz²,

Seaton

et al. 2015

Proceedings of the 10th ACM Workshop on Programming Languages and Analysis for Security

Self Cite

View full text Add to dashboard Cite

In low-level languages such as C, spatial and temporal safety errors (e.g. buffer overflows or dangling pointer dereferences) are hard to find and can cause security vulnerabilities. Modern high-level languages such as Java avoid these problems by running programs on a virtual machine that provides automated memory management.In this paper we show how we can safely execute C code on top of a modern runtime (e.g., a Java Virtual Machine) by allocating all data on the managed heap. We reuse the memory management of the runtime, hence, we can ensure spatial and temporal safety with little effort. Nevertheless, we retain all characteristics that are typical for unsafe languages (such as pointer arithmetic, pointers into objects, or arbitrary type casts). We discuss how our approach complies with the C99 standard.Compared to an optimized unsafe execution of a C program (compiled with the GNU C compiler and all optimizations enabled) our approach has overhead of 15% on average (peak-performance).

show abstract

Section: Discussionmentioning

confidence: 99%

Section: Discussionmentioning

confidence: 99%

Memory-safe Execution of C on a Java VM

Grimmer

Schatz²,

Seaton

et al. 2015

Proceedings of the 10th ACM Workshop on Programming Languages and Analysis for Security

Self Cite

View full text Add to dashboard Cite

show abstract

“…Our high-level API is inspired from the array programming model and provides the user with composable algorithmic patterns such as map or reduce as seen in the previous section. The OpenCL code generator extends the new Oracle Graal VM [13] (just in time compiler written in Java) to compile Java byte into OpenCL. Finally, our third component handles data transfer and device management.…”

Section: System Overviewmentioning

confidence: 99%

“…For example, for the map pattern, the customizing lambda expression is handed over to Graal which parses the corresponding byte-code into its own internal IR [13].…”

Section: Graal Ir Generation and Optimizationmentioning

confidence: 99%

Runtime Code Generation and Data Management for Heterogeneous Computing in Java

Fumero

Remmelg

Steuwer

et al. 2015

Proceedings of the Principles and Practices of Programming on the Java Platform

View full text Add to dashboard Cite

GPUs (Graphics Processing Unit) and other accelerators are nowadays commonly found in desktop machines, mobile devices and even data centres. While these highly parallel processors offer high raw performance, they also dramatically increase program complexity, requiring extra effort from programmers. This results in difficult-to-maintain and non-portable code due to the low-level nature of the languages used to program these devices.This paper presents a high-level parallel programming approach for the popular Java programming language. Our goal is to revitalise the old Java slogan -Write once, run anywhere -in the context of modern heterogeneous systems. To enable the use of parallel accelerators from Java we introduce a new API for heterogeneous programming based on array and functional programming. Applications written with our API can then be transparently accelerated on a device such as a GPU using our runtime OpenCL code generator.In order to ensure the highest level of performance, we present data management optimizations. Usually, data has to be translated (marshalled) between the Java representation and the representation accelerators use. This paper shows how marshal affects runtime and present a novel technique in Java to avoid this cost by implementing our own customised array data structure. Our design hides low level data management from the user making our approach applicable even for inexperienced Java programmers.We evaluated our technique using a set of applications from different domains, including mathematical finance and machine learning. We achieve speedups of up to 500× over sequential and multi-threaded Java code when using an external GPU.

show abstract

“…Using R as a use case, we extend the existing FastR [18] interpreter which is built upon the Truffle framework [23] and we use the Graal [2] JIT compiler to produce OpenCL code. The R interpreter is modified slightly to detect parallel operations and represent them as parallel nodes in the Abstract Syntax Tree (AST) interpreter.…”

Section: Introductionmentioning

confidence: 99%

Just-In-Time GPU Compilation for Interpreted Languages with Partial Evaluation

et al. 2017

Self Cite

View full text Add to dashboard Cite

Computer systems are increasingly featuring powerful parallel devices with the advent of many-core CPUs and GPUs. This offers the opportunity to solve computationally-intensive problems at a fraction of the time traditional CPUs need. However, exploiting heterogeneous hardware requires the use of low-level programming language approaches such as OpenCL, which is incredibly challenging, even for advanced programmers.On the application side, interpreted dynamic languages are increasingly becoming popular in many domains due to their simplicity, expressiveness and flexibility. However, this creates a wide gap between the high-level abstractions offered to programmers and the low-level hardware-specific interface. Currently, programmers must rely on high performance libraries or they are forced to write parts of their application in a low-level language like OpenCL. Ideally, nonexpert programmers should be able to exploit heterogeneous hardware directly from their interpreted dynamic languages.In this paper, we present a technique to transparently and automatically offload computations from interpreted dynamic languages to heterogeneous devices. Using just-intime compilation, we automatically generate OpenCL code at runtime which is specialized to the actual observed data types using profiling information. We demonstrate our technique using R, which is a popular interpreted dynamic language predominately used in big data analytic. Our experimental results show the execution on a GPU yields speedups of over 150x compared to the sequential FastR implementation and the obtained performance is competitive with manually written GPU code. We also show that when taking into account start-up time, large speedups are achievable, even when the applications run for as little as a few seconds.

show abstract

An intermediate representation for speculative optimizations in a dynamic compiler

Cited by 94 publications

References 26 publications

Memory-safe Execution of C on a Java VM

Memory-safe Execution of C on a Java VM

Runtime Code Generation and Data Management for Heterogeneous Computing in Java

Just-In-Time GPU Compilation for Interpreted Languages with Partial Evaluation

Contact Info

Product

Resources

About