Whose baseline compiler is it anyway?

TL;DR

This paper analyzes WebAssembly baseline compilers, explaining their algorithms, tradeoffs, and empirical performance, and introduces a new single-pass compiler that minimizes runtime overhead and supports flexible instrumentation.

Contribution

It provides a detailed explanation of single-pass WebAssembly compilers, introduces a new efficient compiler design, and empirically evaluates various baseline compilers' performance and tradeoffs.

Findings

Runtime overhead of value tags can be nearly zero.

Baseline compilers vary in speed and quality, fitting different tradeoff points.

The new compiler design improves startup time and supports instrumentation.

Abstract

Compilers face an intrinsic tradeoff between compilation speed and code quality. The tradeoff is particularly stark in a dynamic setting where JIT compilation time contributes to application runtime. Many systems now employ multiple compilation tiers, where one tier offers fast compile speed while another has much slower compile speed but produces higher quality code. With proper heuristics on when to use each, the overall performance is better than using either compiler in isolation. At the introduction of WebAssembly into the Web platform in 2017, most engines employed optimizing compilers and pre-compiled entire modules before execution. Yet since that time, all Web engines have introduced new "baseline" compiler tiers for Wasm to improve startup time. Further, many new non-web engines have appeared, some of which also employ simple compilers. In this paper, we demystify single-pass compilers for Wasm, explaining their internal algorithms and tradeoffs, as well as providing a detailed empirical study of those employed in production. We show the design of a new single-pass compiler for a research Wasm engine that integrates with an in-place interpreter and host garbage collector using value tags, while also supporting flexible instrumentation. In experiments, we measure the effectiveness of optimizations targeting value tags and find, somewhat surprisingly, that the runtime overhead can be reduced to near zero. We also assess the relative compile speed and execution time of six baseline compilers and place these baseline compilers in a two-dimensional tradeoff space with other execution tiers for Wasm.