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

12th ACM SIGPLAN International Workshop on Virtual Machines and Intermediate Languages (VMIL 2020), November 17, 2020, Virtual, USA

VMIL 2020 – Proceedings

Contents - Abstracts - Authors

12th ACM SIGPLAN International Workshop on Virtual Machines and Intermediate Languages (VMIL 2020)

Frontmatter

Title Page


Welcome from the Chairs
Welcome to the 12th ACM Workshop on Virtual Machines and Language Implementations (VMIL'20). The workshop is co-located with SPLASH’20 in Chicago, US. The workshop aims at advancing the state of the art on the design and implementation of programming systems, with virtual machines — broadly defined — as a focus.
Due to COVID-19, many computing conferences, including VMIL, have struggled to obtain submissions. The workshop had two submission deadlines. The first deadline was intended for mature work to be published as part of these proceedings. The second deadline was intended for work-in-progress papers, new ideas, and emerging results. In total, the workshop attracted one full-length paper and no work-in-progress submissions. Due to the low number of submissions, the submitted paper received eight reviews. The program committee accepted this submission for publication and presentation in the workshop.
Additionally, this year we have four invited talks from industry and academia. Matthew Flatt on Racket’s intermediate language for control. Mark Stoodley on JitBuilder2.0, a new framework for optimizing DLS compilers. Chris Seaton on new tools to help understanding the Graal IR, and finally, Vyacheslav Egorov on the evolution of the Dart programming language.
We would like to thank the authors for their submission, and all program committee members for their high-quality and insightful reviews. Finally, we thank all attendees for their participation.

Invited Talks

Racket’s Intermediate Language for Control (Invited Talk)
Matthew Flatt
(University of Utah, USA)
As a language that is intended for building languages in a composable way, Racket provides an especially rich set of constructs for control, including delimited continuations and efficient reflection on continuations. This talk will explain Racket’s constructs for control and describe how the implementation is built in layers.

Publisher's Version
In Pursuit of Easy(er) JITs (Invited Talk)
Mark Stoodley
(IBM, Canada)
n the early days of the Eclipse OMR project, we created the unimaginatively named JitBuilder API aiming to make it easier to build a JIT compiler. JitBuilder has been used to create prototype JIT compilers in a few thousand lines of C++ for WebAssembly, Lua, Smalltalk, Javascript, the Rosie Pattern Language, BF, Kaleidoscope, and Base9, as well as a number of other less language-centric dynamic code generators (including an alternative code generator for LLVM IR). Although it brings key facilities for privatizing virtual machine state and translating bytecode handlers, the JitBuilder API did not completely meet the “easy” goal particularly in the areas of extensibility and debuggability and did not offer strong DSL optimization possibilities. In this talk, I’ll explain and summarize the key features of the JitBuilder API before introducing some recent exploratory work to create the next version: JitBuilder2. This new fully-fledged (if currently in complete) compiler IL shares some directions with MLIR, but has some unique challenges and features, all designed around the pursuit of “easy” JIT compiler construction. Through the talk, I’ll show off some of these features (that’s right, I’ll demo a compiler IL!) and highlight some of the interesting directions I think we could take it from here.

Publisher's Version
Understanding Graal IR (Invited Talk)
Chris Seaton
(Shopify, USA)
The Graal compiler uses a graphical sea-of-nodes IR that can be difficult to understand and work with when trying to improve performance of complicated programs. When used with an automatic partial evaluator, such as Truffle, and with a high-level language with complex semantics such as Ruby, the resulting IR graphs become even harder to work with. At Shopify, we’re working on new tools to understand complex Graal IR graphs generated from the TruffleRuby and Sulong interpreters, as used to run a large, complex, production application. We’ll show what these tools enable us to do and what innovative ideas we can bring to understand the relevant parts of the graph without getting swamped in the expanse of it.

Publisher's Version
10 Years of Dart (Invited Talk)
Vyacheslav Egorov
(Google, Denmark)
Dart might be the only contemporary programming language that changed its core principles so radically between two major versions. 10 years ago, in 2010, it was born as a dynamically typed programming language with optional static types - ideas of Strongtalk wrapped into familiar C-like syntax. A language destined to be executed in a native VM with an adaptive JIT compiler. Yet over the years Dart has evolved into a language with a sound static type system, and is being deployed in contexts that require ahead-of-time compilation and prohibit JITing. Now, it is even trying to get rid of the “billion-dollar mistake” - null - and incrementally transition to non-nullable by default reference types. This talk focuses on the architecture of Dart Virtual Machine and how it followed the evolution of the Dart language, adapting to the new semantics and new execution environments, where users wanted to bring Dart to.

Publisher's Version

Paper

Programming Microcontrollers through High-Level Abstractions
Steven Varoumas, Basile Pesin, Benoît Vaugon, and Emmanuel Chailloux
(Sorbonne University, France; CNRS, France; LIP6, France; Inria, France; Armadillo, France)
In this paper, we present an approach for programming microcontrollers that provides more expressivity and safety than a low-level language approach traditionally used to program such devices. To this end, we provide various abstraction layers (abstraction of the microcontroller, of the electronic components of the circuit, and of concurrency) which, while being adapted to the scarce resources of the hardware, offer high-level programming traits for the development of embedded applications. The various presented abstractions make use of an OCaml virtual machine able to run on devices with limited resources and take advantage of the expressivity and extensibility of the language. We illustrate the interest of our work on both entertainment applications and embedded software examples.

Publisher's Version

proc time: 2.57