Managed Programming Languages and RuntimesMPLR 2019

What if you had to compile a language that is actively trying to make compilation impossible? What if every program had to be viewed as a maleficent adversary trying to break any attempt to optimize its code? Well, we would say that you are probably trying to compile R, the programming language of choice for statistics. This talk feature tall tales of trying, and often failing, to compile R. We will explain what makes R adversarial and why it got that way. We will discuss steps that language implementers take to protect themselves, and conclude with ideas on how to smooth the sharp edges of the language.

Olivier Flückiger

Northeastern University

United States

Jan Vitek

Northeastern University

United States

Break

On-stack replacement (OSR) is a common technique employed by dynamic compilers to reduce program warm-up time. OSR allows switching from interpreted to compiled code during the execution of this code. The main targets are long running loops, which need to be represented explicitly, with dedicated information about condition and body, to be optimized at run time. Bytecode interpreters, however, represent control flow implicitly via unstructured jumps and thus do not exhibit the required high-level loop representation. To enable OSR also for jump-based—often called unstructured—languages, we propose the partial reconstruction of loops in order to explicitly represent them in a bytecode interpreter. Besides an outline of the general idea, we implemented our approach in Sulong, a bytecode interpreter for LLVM bitcode, which allows the execution of C/C++. We conducted an evaluation with a set of C benchmarks, which showed speed-ups in warm-up of up to 9x for certain benchmarks. This facilitates execution of programs with long-running loops in rarely called functions, which would yield significant slowdown without OSR. While shown with a prototype implementation, the overall idea of our approach is generalizable for all bytecode interpreters.

Raphael Mosaner

Johannes Kepler University Linz

David Leopoldseder

Johannes Kepler University Linz

Austria

Manuel Rigger

ETH Zurich

Switzerland

Roland Schatz

Johannes Kepler University Linz

Hanspeter Mössenböck

JKU Linz, Austria

Austria

Polyglot programming provides software developers with a broader choice in terms of software libraries and frameworks available for building applications. Previous research and engineering activities have focused on language interoperability and the design and implementation of fast polyglot runtimes. To make polyglot programming more approachable for developers, novel software development tools are needed that help them build polyglot applications. We believe a suitable prototyping platform helps to more quickly evaluate new ideas for such tools. In this paper we present GraalSqueak, a Squeak/Smalltalk virtual machine implementation for the GraalVM. We report our experience implementing GraalSqueak, evaluate the performance of the language and the programming environment, and discuss how the system can be used as a tooling platform for polyglot programming.

Fabio Niephaus

Hasso Plattner Institute, University of Potsdam

Germany

Tim Felgentreff

Oracle Labs, Potsdam

Germany

Robert Hirschfeld

Hasso-Plattner-Institut (HPI), Germany

Germany

It is extremely hard and time-consuming to make correct and efficient programs for micro-controllers. Usually micro-controllers are programmed in a low level programming language such as C which makes them hard to debug and maintain. To raise the abstraction level, many high level programming languages have provided support for programming micro-controllers. Examples include Python, Lua, C#and JavaScript. Using these languages has the downside that they are orders of magnitude slower than the low-level languages. Moreover, they often provide no remote debugging support. In this talk we investigate the feasibility of using WebAssembly to program Arduino compatible micro-controllers.Our experiments lead to extending the standard WebAssembly VM with: 1) safe live code updates for functions and data 2) remote debugging support at the VM level 3) programmer configurable (Arduino) modules in order to keep the virtual machine’s footprint as small as possible. The resulting WARDuino VM enables the programmer to have better performance than an interpreted approach while simultaneously increasing the ease of development.To evaluate our approach, we implemented a simple break-out game and conducted micro benchmarks which show that the VM runs approximately 5 times faster than Espruino, a popular JavaScript interpreter for the ESP32 micro-controller.

Robbert Gurdeep Singh

Universiteit Gent, Belgium

Belgium

Christophe Scholliers

Universiteit Gent, Belgium

VMs contain many assumptions about how programs typically operate – and VM developers and researchers have many assumptions about how VMs typically operate. In this talk, I will present a number of partly, or wholly, unstated assumptions that we have about VMs and their development. Together they may help partly, although probably not wholly, how VMs got to where they are today – and also offer suggestions for how we can things differently in the future.

Laurence Tratt

King's College London

United Kingdom

Programmer / researcher.

With micro-services continuously gaining popularity and low-power processors making their way into data centers, efficient execution of managed runtime systems on low-power architectures is also gaining interest. Apart from the inherent performance differences between high and low power processors, porting a managed runtime system to a low-power architecture may result in spuriously introducing additional overheads and design trade-offs. In this work we investigate how the lack of strong hardware support for Self Modifying Code (SMC) in low-power architectures, influences Just-In-Time (JIT) compilation and execution in modern virtual machines. In particular, we examine how low-power architectures, with no or limited hardware support for SMC, impose restrictions on call-site implementations, when the latter need to be patchable by the runtime system. We present four different memory-safe implementations for call-site generation and discuss their advantages and disadvantages in the absence of strong hardware support for SMC. Finally, we evaluate each technique on different workloads using micro-benchmarks and we evaluate the best two techniques on the Dacapo benchmark suite showcasing performance differences up to 15%.

Link to Publication: https://dl.acm.org/citation.cfm?id=3361027

Tim Hartley

The University of Manchester

Foivos S. Zakkak

University of Manchester, UK

Christos Kotselidis

University of Manchester, UK

United Kingdom

Mikel Luján

University of Manchester

The actor model is popular for many types of server applications. Efficient snapshotting of applications is crucial in the deployment of pre-initialized applications or moving running applications to different machines, e.g for debugging purposes. A key issue is that snapshotting blocks all other operations. In modern latency-sensitive applications, stopping the application to persist its state needs to be avoided, because users may not tolerate the increased request latency. In order to minimize the impact of snapshotting on request latency, our approach persists the application’s state asynchronously by capturing partial heaps, completing snapshots step by step. Additionally, our solution is transparent and supports arbitrary object graphs. We prototyped our snapshotting approach on top of the Truffle/Graal platform and evaluated it with the Savina benchmarks and the Acme Air microservice application. When performing a snapshot every thousand Acme Air requests, the number of slow requests ( 0.007% of all requests) with latency above 100ms increases by 5.43%. Our Savina microbenchmark results detail how different utilization patterns impact snapshotting cost. To the best of our knowledge, this is the first system that enables asynchronous snapshotting of actor applications, i.e. without stop-the-world synchronization, and thereby minimizes the impact on latency. We thus believe it enables new deployment and debugging options for actor systems.

Dominik Aumayr

Johannes Kepler University Linz, Austria

Austria

Stefan Marr

University of Kent

United Kingdom

Elisa Gonzalez Boix

Vrije Universiteit Brussel, Belgium

Belgium

Hanspeter Mössenböck

JKU Linz, Austria

Austria