Tobias Pape

Pycket: a tracing JIT for a functional language

We present Pycket, a high-performance tracing JIT compiler for Racket. Pycket supports a wide variety of the sophisticated features in Racket such as contracts, continuations, classes, structures, dynamic binding, and more. On average, over a standard suite of benchmarks, Pycket outperforms existing compilers, both Rackets JIT and other highly-optimizing Scheme compilers. Further, Pycket provides much better performance for Racket proxies than existing systems, dramatically reducing the overhead of contracts and gradual typing. We validate this claim with performance evaluation on multiple existing benchmark suites. The Pycket implementation is of independent interest as an application of the RPython meta-tracing framework (originally created for PyPy), which automatically generates tracing JIT compilers from interpreters. Prior work on meta-tracing focuses on bytecode interpreters, whereas Pycket is a high-level interpreter based on the CEK abstract machine and operates directly on abstract syntax trees. Pycket supports proper tail calls and first-class continuations. In the setting of a functional language, where recursion and higher-order functions are more prevalent than explicit loops, the most significant performance challenge for a tracing JIT is identifying which control flows constitute a loop---we discuss two strategies for identifying loops and measure their impact.

The SOM family: virtual machines for teaching and research

This paper introduces the SOM (Simple Object Machine) family of virtual machine (VM) implementations, a collection of VMs for the same Smalltalk dialect addressing students at different levels of expertise. Starting from a Java-based implementation, several ports of the VM to different programming languages have been developed and put to successful use in teaching at both undergraduate and graduate levels since 2006. Moreover, the VMs have been used in various research projects. The paper documents the rationale behind each of the SOM VMs and results that have been achieved in teaching and research.

SqueakJS: a modern and practical smalltalk that runs in any browser

We report our experience in implementing SqueakJS, a bit-compatible implementation of Squeak/Smalltalk written in pure JavaScript. SqueakJS runs entirely in the Web browser with a virtual filesystem that can be directed to a server or client-side storage. Our implementation is notable for simplicity and performance gained through adaptation to the host object memory and deployment leverage gained through the Lively Web development environment. We present several novel techniques as well as performance measurements for the resulting virtual machine. Much of this experience is potentially relevant to preserving other dynamic language systems and making them available in a browser-based environment.

Are We There Yet?: Simple Language Implementation Techniques for the 21st Century

Research on language implementation techniques has regained importance with the rise of domain-specific languages (DSLs). Although DSLs can help manage a domains complexity, building highly optimizing compilers or virtual machines is rarely affordable. So, performance remains an issue. Ideally, you would implement a simple interpreter and still be able to achieve acceptable performance. RPython and Truffle are implementation techniques based on simple interpreters; they promise to perform at the same order of magnitude as highly optimizing virtual machines. This case study compares the two techniques to identify their similarities, weaknesses, and areas for further research.

Towards reducing the need for algorithmic primitives in dynamic language VMs through a tracing JIT

When implementing virtual machines, besides the interpreter and optimization facilities, we have to include a set of primitive functions that the client language can use. Some of these implement truly primitive behavior, such as arithmetic operations. Other primitive functions, which we call algorithmic primitives, are expressible in the client language, but are implemented in the vm to improve performance. However, having many primitives in the vm makes it harder to maintain them, or re-use them in alternative vm implementations for the same language. With the advent of efficient tracing just-in-time compilers we believe the need for algorithmic primitives to be much diminished, allowing more of them to be implemented in the client language. In this work, we investigate the trade-offs when creating primitives, and in particular how large a difference remains between primitive and client function run times in vms with tracing just-in-time compiler. To that end, we extended the RSqueak/VM, a vm for Squeak/Smalltalk written in RPython. We compare primitive implementations in C, RPython, and Smalltalk, showing that due to the tracing JIT the performance gap can be significantly reduced.

How to Build a High-Performance VM for Squeak/Smalltalk in Your Spare Time: An Experience Report of Using the RPython Toolchain

In this paper we present our experience in letting students develop RSqueak/VM, a fast virtual machine for executing Squeak/Smalltalk, over the course of multiple introductory VM courses and projects. Our experience indicates that the way RSqueak/VM is constructed makes it easy for developers with little or no prior exposure to VM development to construct a Squeak runtime that is very nearly competitive to the professional grade Cog VM, which is used by Squeak and other flavors of Smalltalk. In this experience report we discuss the benefits and drawbacks of RSqueak/VM as a research vehicle for developing and evaluating Smalltalk language extensions without having to learn the deep secrets of VM development.

Language-independent storage strategies for tracing-JIT-based virtual machines

Storage strategies have been proposed as a run-time optimization for the PyPy Python implementation and have shown promising results for optimizing execution speed and memory requirements. However, it remained unclear whether the approach works equally well in other dynamic languages. Furthermore, while PyPy is based on RPython, a language to write VMs with reusable components such as a tracing just-in-time compiler and garbage collection, the strategies design itself was not generalized to be reusable across languages implemented using that same toolchain. In this paper, we present a general design and implementation for storage strategies and show how they can be reused across different RPython-based languages. We evaluate the performance of our implementation for RSqueak, an RPython-based VM for Squeak/Smalltalk and show that storage strategies may indeed offer performance benefits for certain workloads in other dynamic programming languages.We furthermore evaluate the generality of our implementation by applying it to Topaz, a Ruby VM, and Pycket, a Racket implementation.

CodeTalk Conversations about Code

Contemporary development environments do not directly and explicitly support developers in having a conversation about the code they write and maintain. This problem is aggravated when geographically dispersed teams need to collaborate on development artifacts. CodeTalk allows developers to have conversations about source code elements. They can mark code sections they are concerned about and annotate them. These annotations provide entry points for an informal discourse about the strengths and weaknesses of these sections and developers can work towards a conclusion on how to proceed on the raised issues. A Squeak/Smalltalk implementation of CodeTalk was evaluated by several small development teams, indicating improvement in the informal assessment of code.

Optimizing Sideways Composition: Fast Context-oriented Programming in ContextPyPy

The prevalent way of code sharing in many current object systems is static and/or single inheritance; both are limiting in situations that call for multi-dimensional decomposition. Sideways composition provides a technique to reduce their limitations. Context-oriented programming (COP) notably applies sideways composition to achieve better modularity. However, most COP implementations have a substantial performance overhead. This is partly because weaving and execution of layered methods violate assumptions that common language implementations hold about lookup. Meta-tracing just-in-time (JIT) compilers have unique characteristics that can alleviate the performance overhead, as they can treat lookup differently. We show that meta-tracing JIT compilers are good at optimizing sideways composition and give initial, supporting results. Furthermore, we suggest that explicit communication with the JIT compiler in a COP implementation can improve performance further.

Adaptive just-in-time value class optimization: transparent data structure inlining for fast execution

The performance of value classes is highly dependent on how they are represented in the virtual machine. Value class instances are immutable, have no identity, and can only refer to other value classes or primitives and since they should be very lightweight and fast, it is important to optimize them well. In this paper we present a technique to detect and compress commonly occurring patterns of value class usage to improve memory usage and performance. microbenchmarks show two to ten-fold speedup of a small prototypical implementation over the implementation of value classes in other object-oriented language implementations.