Boosting WebAssembly Performance with Speculative Optimizations and Deoptimization in V8

Introduction

In the latest release of Google Chrome (M137), V8 introduced two powerful optimizations for WebAssembly: speculative call_indirect inlining and deoptimization support. Together, these techniques allow the compiler to generate faster machine code by making educated guesses based on runtime behavior. The result is a significant speed boost, especially for WasmGC programs. For instance, Dart microbenchmarks show an average improvement of over 50%, while larger applications and real-world benchmarks see gains between 1% and 8%. Deoptimization also lays the groundwork for future enhancements.

The Role of Speculative Optimizations in JavaScript

Fast JavaScript execution has long relied on speculative optimizations. Just-in-time (JIT) compilers collect feedback during earlier runs and make assumptions when generating code. For example, for the expression a + b, if past feedback shows both operands are integers, the compiler can produce streamlined integer addition code instead of handling every possible type (strings, floats, objects) generically. When those assumptions later prove wrong, V8 performs a deoptimization (or deopt) — it discards the optimized code and reverts to slower, unoptimized execution, gathering more data for a future tier-up.

Why WebAssembly Previously Didn’t Need Speculative Optimizations

WebAssembly has historically required less speculation. Its programs are statically typed — functions, instructions, and variables all have fixed types known at compile time. Moreover, WebAssembly binaries often come from C, C++, or Rust, languages that are easier to analyze statically. Ahead-of-time optimization tools like Emscripten (built on LLVM) or Binaryen already produce well-optimized binaries. For the original WebAssembly 1.0 (2017), this combination made speculative optimizations unnecessary.

The Game-Changer: WasmGC

The introduction of WasmGC (the WebAssembly Garbage Collection proposal) changes the landscape. WasmGC supports compiling managed languages — such as Java, Kotlin, or Dart — to WebAssembly. Its bytecode is more high-level than Wasm 1.0, featuring rich types like structs and arrays, subtyping, and operations on these types. This complexity means that static optimization alone is less effective; speculative techniques can make a much bigger difference in the generated machine code.

Two Key Optimizations: Speculative Inlining and Deoptimization

Speculative call_indirect Inlining

Function inlining is a classic optimization that replaces a call site with the body of the called function, saving call overhead and enabling further local optimizations. In WebAssembly, indirect calls (through function tables) are common in object-oriented and functional patterns. Speculative inlining uses runtime feedback to guess which function will be called most often, and inlines that target. If the guess is correct, execution is fast; if not, the code must fall back to the original indirect call.

Deoptimization Support

To handle mispredictions, V8 now supports deoptimization for WebAssembly. When an assumption made during speculative inlining fails, the engine can deopt: it stops executing the optimized code, reverts to unoptimized code, and continues safely. This is the same mechanism used for JavaScript, adapted for WebAssembly. Without deoptimization, speculative inlining would be too risky – any wrong guess could crash the program or produce incorrect results. With deopt, the compiler can be aggressive and still maintain correctness.

Performance Gains and Future Potential

Initial benchmarks are promising. For Dart microbenchmarks, combining both optimizations yields an average speedup of more than 50%. Larger, realistic applications see more modest but still valuable gains (1–8%). Beyond immediate performance, deoptimization is a building block for future speculative optimizations — for example, type feedback based on runtime profiles, or adaptive inlining decisions.

As WebAssembly continues to evolve, especially with WasmGC, speculative optimizations will become increasingly important. V8’s work on speculative call_indirect inlining and deoptimization marks a step toward making WebAssembly execution as fast and dynamic as JavaScript’s, while preserving the security and portability that make WebAssembly attractive. Developers can expect their WasmGC applications to run faster with Chrome M137 and to benefit from further advances in the pipeline.