SPLASH Workshops 2018
2018 ACM SIGPLAN International Conference on Systems, Programming, Languages, and Applications: Software for Humanity (SPLASH Workshops 2018)
Powered by
Conference Publishing Consulting

10th ACM SIGPLAN International Workshop on Virtual Machines and Intermediate Languages (VMIL 2018), November 4, 2018, Boston, MA, USA

VMIL 2018 – Advance Table of Contents

Contents - Abstracts - Authors

10th ACM SIGPLAN International Workshop on Virtual Machines and Intermediate Languages (VMIL 2018)


Title Page

Message from the Chairs

On the Self in Selfie (Invited Talk)
Christoph M. Kirsch
(University of Salzburg, Austria)

Article Search
Beam: A Virtual Machine for Handling Millions of Messages per Second (Invited Talk)
Erik Stenman
(Happi Hacking, Sweden)

Article Search
A Cost Model for a Graph-Based Intermediate-Representation in a Dynamic Compiler
David Leopoldseder, Lukas Stadler, Manuel Rigger, Thomas Würthinger, and Hanspeter Mössenböck
(JKU Linz, Austria; Oracle Labs, Austria; Oracle Labs, Switzerland)

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.

Article Search
Towards Compilation of an Imperative Language for FPGAs
Baptiste Pauget, David J. Pearce, and Alex Potanin
(ENS, France; Victoria University of Wellington, New Zealand)

Article Search
Using Compiler Snippets to Exploit Parallelism on Heterogeneous Hardware: A Java Reduction Case Study
Juan Fumero and Christos Kotselidis
(University of Manchester, UK; The University of Manchester, UK)
Parallel skeletons are essential structured design patterns for efficient heterogeneous and parallel programming. They allow programmers to express common algorithms in such a way that it is much easier to read, maintain, debug and implement for different parallel programming models and parallel architectures. Reductions are one of the most common parallel skeletons. Many programming frameworks have been proposed for accelerating reduction operations on heterogeneous hardware. However, for the Java programming language, little work has been done for automatically compiling and exploiting reductions in Java applications on GPUs. In this paper we present our work in progress in utilizing compiler snippets to express parallelism on heterogeneous hardware. In detail, we demonstrate the usage of Graal's snippets, in the context of the Tornado compiler, to express a set of Java reduction operations for GPU acceleration. The snippets are expressed in pure Java with OpenCL semantics, simplifying the JIT compiler optimizations and code generation. We showcase that with our technique we are able to execute a predefined set of reductions on GPUs within 85% of the performance of the native code and reach up to 20x over the Java sequential execution.
Article Search
Efficient VM-Independent Runtime Checks for Parallel Programming
Michael Faes and Thomas R. Gross
(ETH Zurich, Switzerland)

Many concurrent or parallel programming languages rely on runtime checking to ensure safety. To implement such a language on a virtual machine (VM), such runtime checks are often implemented in a VM-independent way, using source-to-source translation or bytecode instrumentation. This approach avoids modifying complex VM components like the just-in-time (JIT) compiler and offers great portability. However, obtaining good performance is challenging, as the approach cannot profit from custom JIT optimizations to eliminate redundant checks.

In this paper, we present and evaluate two techniques to make the VM-independent approach efficient, using the example of a parallel programming language called Rolez. To guarantee that concurrent threads do not interfere, Rolez relies heavily on runtime checks: for every field access, the runtime system checks that the state of the target object currently permits this operation (unless the check is optimized away). The Rolez compiler we present here generates standard Java source code and the runtime system is implemented as a Java library. Nevertheless, many Rolez programs deliver performance roughly on par with manually synchronized Java implementations, which is achieved using these two techniques: 1) code-managed runtime data, which improves runtime check efficiency by passing performance-critical information from method to method, and 2) an interprocedural but modular concurrency analysis, which eliminates many runtime checks that are actually redundant.

Article Search
Building JIT Compilers for Dynamic Languages with Low Development Effort
Baptiste Saleil and Marc Feeley
(Université de Montréal, Canada)

Article Search
Two Decades of Smalltalk VM Development
Eliot Miranda, Clément Béra, Elisa Gonzalez Boix, and Dan Ingalls
(feenk, n.n.; Vrije Universiteit Brussel, Belgium; ARCOS, n.n.)

Article Search

proc time: 3.14