Wasm Research Day 2024

Join us June 4 to peer into the future of WebAssembly!

A Day to discuss research and long-term topics

Wasm Research Day brings together researchers from academia and industry, as well as participants in the CG standards body, to discuss research and long-term topics related to WebAssembly. Co-located with the June 5-6 Wasm Community Group Meeting, it allows a unique opportunity for participants to discuss ongoing standardization work as well as strategic directions for WebAssembly.

When / Where

When: Tuesday, June 4, 2024, 9:30AM - 5:30PM CEST
Where: Gates Building 6115, Carnegie Mellon University, Pittsburgh PA.
Signup: here.

Talks

Talks will include a wide variety of subjects on Wasm.

Time Speaker Affiliation Title Abstract
9:30-9:45
(15 mins) Ben L. Titzer Carnegie Mellon University Research Day Introductions
9:45 - 10:20
(35 mins) Andreas Rossberg Independent Engineering a Formal Language Spec The official specification for Wasm includes an end-to-end formal semantics, and every new feature must be specified in this formal semantics, in prose, and in the official reference interpreter before it can be standardised. This manual process with its redundancies is laborious and error-prone. We present SpecTec, a DSL and toolchain that facilitates both the Wasm specification and the generation of artefacts necessary for standardisation. A definition of the Wasm semantics in SpecTec serves as a single source of truth, from which we can generate a typeset specification, including formal definitions and prose pseudocode descriptions, and a meta-level interpreter. Further backends for test generation and meta-theory in theorem provers are work in progress.
10:20 - 10:55
(35 mins) Elizabeth Gilbert Carnegie Mellon University whamm! A WebAssembly Bytecode Instrumentation DSL Debugging and profiling programs are an integral part of engineering software. This is done through instrumenting the program under observation (inserting instructions that provide insight into dynamic execution). The most-common instrumentation techniques, such as bytecode rewriting, inject instructions directly into the application code. While this method enables instrumentation to support any application domain, it intrudes on the program state space (possibly introducing bugs), complicates the implementation, limits the scope of observation, and cannot dynamically adapt to program behavior. Instead, one can remedy these bytecode rewriting issues by interfacing with a runtime engine that directly supports instrumentation. This technique can bring powerful capabilities into play as demonstrated by the Wizard research engine, in a recent ASPLOS paper. This paper demonstrated how to build instrumentation support that protects the application-under-observation, provides consistency guarantees to enable composable tooling, applies JIT optimizations specific to instrumentation that make some tools run even faster than bytecode rewriting, and more. However, this technique is not as widely-used as bytecode rewriting since it limits a tool’s scope to applications that can run on such engines. This talk presents the design of a new instrumentation DSL for WebAssembly that abstracts above the instrumentation technique to enable developer tooling to support a broad domain of applications while leveraging runtime capabilities as-available without reimplementation.
10:55 - 11:10
(15 mins) Break
11:10 - 11:45
(35 mins) Doehyun Baek KAIST Wasm-R3: Record-Reduce-Replay for Realistic and Standalone WebAssembly Benchmarks WebAssembly (Wasm) is gaining importance across the web, edge, IoT, and embedded systems. However, existing Wasm benchmark suites are unrepresentative of real-world applications. To address this, we introduce Wasm-R3, the first record and replay technique for Wasm. Wasm-R3 transparently records execution traces from real-world web applications, optimizes the traces, and produces standalone replay modules executable on any Wasm engine without a host environment. Key benefits of Wasm-R3 benchmarks: Realistic: Recorded from real web applications, Faithful: Include original unmodified code Standalone: Run on any engine without host. Our optimizations reduce trace size by 99.53% and replay module size by 9.98%. We release Wasm-R3-Bench, a suite of 27 realistic and standalone Wasm benchmarks.
11:45 - 1:00
(1 hour 15 mins) Lunch (provided)
1:00 - 1:35
(35 mins) Arjun Ramesh Carnegie Mellon University Leveraging Wasm as a Debugging Platform for Resource-Constrained Systems Wasm, as a virtual ISA, transcends simple virtualization by offering a platform-agnostic and easily analyzable program representation that can operate even on very resource-constrained devices. In this talk, we present a new perspective on Wasm as a powerful platform for debugging and fuzzing. Specifically, we demonstrate how leveraging Wasm's platform-agnostic format can enable minimal overhead debugging on resource-constrained on-board devices by utilizing the power of high-performance off-board devices.
1:35 - 2:10
(35 mins) Mats Brorsson University of Luxembourg A Cross-Architecture View of Distributed Applications Using WebAssembly The infrastructure for distributed applications is no longer homogeneous. With the edge-cloud-compute continuum there will be many different platforms and architectures with and without accelerators. In this talk I will present some preliminary results of running microservices as OCI-compliant Wasm modules and how it compares with the traditional native Docker container approach. We look at compatibility issues, performance, accessibility to accelerators etc across three different platforms/architectures (x86_64, aarch64 with CUDA accelerators and riscv64).
2:10 - 2:25
(15 mins) Break
2:25 - 3:00
(35 mins) Adam Bratschi-Kaye DFINITY Foundation Niche Properties of Wasm Execution on the Internet Computer Blockchain The Internet Computer blockchain implements a replicated state machine and uses WebAssembly to encode the state transition function and represent the smart contract programs. WebAssembly is especially fitting for this use case and the execution should satisfy a number of additional properties which are not commonly required in other contexts where WebAssembly is being used. This talk will give an overview of those properties, with the goals being to both raise awareness of these niche use cases and also find commonalities with other projects which may have similar constraints. In particular, some topics to be covered would be (i) determinism of execution, (ii) deterministically aborting long running functions, (iii) persistence of state with atomic updates (memory, globals, etc.), (iv) efficient compilation, (v) maintaining state across updates of Wasm code.
3:00 - 3:35
(35 mins) Chris Fallin Fastly wevaling the wasms: AOT JS Compilation to WebAssembly Dynamically-typed languages are, at first glance, a poor fit for compilation to WebAssembly: the techniques that make their execution fast in modern contexts, such as JIT compilation and inline caches, are not available or easy to implement in Wasm's static Harvard architecture. The state of the art today is to bundle such languages with their interpreter in a Wasm module. However, it is possible to do better. First, with careful thought, a JIT compiler can sometimes be reframed in a mostly-AOT way, by being explicit about phasing (e.g., collection of common inline-cache snippets ahead of time). Hybrid design points can be achieved where some dynamism -- late-binding via indirection -- can coexist with compiled code bodies. Finally, we can make it easier to turn an existing interpreter into a compiler with partial evaluation. This talk introduces weval, the Wasm partial evaluator, and its use to compile JavaScript ahead-of-time with the SpiderMonkey engine, showing good speedups.
3:35 - 4:00 (35 mins) Wrap-up and open discussion
4:00 - 5:30 (1 hour, 30 mins) Poster session (with refreshments)

Time	Speaker	Affiliation	Title	Abstract
9:30-9:45 (15 mins)	Ben L. Titzer	Carnegie Mellon University	Research Day Introductions
9:45 - 10:20 (35 mins)	Andreas Rossberg	Independent	Engineering a Formal Language Spec	The official specification for Wasm includes an end-to-end formal semantics, and every new feature must be specified in this formal semantics, in prose, and in the official reference interpreter before it can be standardised. This manual process with its redundancies is laborious and error-prone. We present SpecTec, a DSL and toolchain that facilitates both the Wasm specification and the generation of artefacts necessary for standardisation. A definition of the Wasm semantics in SpecTec serves as a single source of truth, from which we can generate a typeset specification, including formal definitions and prose pseudocode descriptions, and a meta-level interpreter. Further backends for test generation and meta-theory in theorem provers are work in progress.
10:20 - 10:55 (35 mins)	Elizabeth Gilbert	Carnegie Mellon University	whamm! A WebAssembly Bytecode Instrumentation DSL	Debugging and profiling programs are an integral part of engineering software. This is done through instrumenting the program under observation (inserting instructions that provide insight into dynamic execution). The most-common instrumentation techniques, such as bytecode rewriting, inject instructions directly into the application code. While this method enables instrumentation to support any application domain, it intrudes on the program state space (possibly introducing bugs), complicates the implementation, limits the scope of observation, and cannot dynamically adapt to program behavior. Instead, one can remedy these bytecode rewriting issues by interfacing with a runtime engine that directly supports instrumentation. This technique can bring powerful capabilities into play as demonstrated by the Wizard research engine, in a recent ASPLOS paper. This paper demonstrated how to build instrumentation support that protects the application-under-observation, provides consistency guarantees to enable composable tooling, applies JIT optimizations specific to instrumentation that make some tools run even faster than bytecode rewriting, and more. However, this technique is not as widely-used as bytecode rewriting since it limits a tool’s scope to applications that can run on such engines. This talk presents the design of a new instrumentation DSL for WebAssembly that abstracts above the instrumentation technique to enable developer tooling to support a broad domain of applications while leveraging runtime capabilities as-available without reimplementation.
10:55 - 11:10 (15 mins)			Break
11:10 - 11:45 (35 mins)	Doehyun Baek	KAIST	Wasm-R3: Record-Reduce-Replay for Realistic and Standalone WebAssembly Benchmarks	WebAssembly (Wasm) is gaining importance across the web, edge, IoT, and embedded systems. However, existing Wasm benchmark suites are unrepresentative of real-world applications. To address this, we introduce Wasm-R3, the first record and replay technique for Wasm. Wasm-R3 transparently records execution traces from real-world web applications, optimizes the traces, and produces standalone replay modules executable on any Wasm engine without a host environment. Key benefits of Wasm-R3 benchmarks: Realistic: Recorded from real web applications, Faithful: Include original unmodified code Standalone: Run on any engine without host. Our optimizations reduce trace size by 99.53% and replay module size by 9.98%. We release Wasm-R3-Bench, a suite of 27 realistic and standalone Wasm benchmarks.
11:45 - 1:00 (1 hour 15 mins)			Lunch (provided)
1:00 - 1:35 (35 mins)	Arjun Ramesh	Carnegie Mellon University	Leveraging Wasm as a Debugging Platform for Resource-Constrained Systems	Wasm, as a virtual ISA, transcends simple virtualization by offering a platform-agnostic and easily analyzable program representation that can operate even on very resource-constrained devices. In this talk, we present a new perspective on Wasm as a powerful platform for debugging and fuzzing. Specifically, we demonstrate how leveraging Wasm's platform-agnostic format can enable minimal overhead debugging on resource-constrained on-board devices by utilizing the power of high-performance off-board devices.
1:35 - 2:10 (35 mins)	Mats Brorsson	University of Luxembourg	A Cross-Architecture View of Distributed Applications Using WebAssembly	The infrastructure for distributed applications is no longer homogeneous. With the edge-cloud-compute continuum there will be many different platforms and architectures with and without accelerators. In this talk I will present some preliminary results of running microservices as OCI-compliant Wasm modules and how it compares with the traditional native Docker container approach. We look at compatibility issues, performance, accessibility to accelerators etc across three different platforms/architectures (x86_64, aarch64 with CUDA accelerators and riscv64).
2:10 - 2:25 (15 mins)			Break
2:25 - 3:00 (35 mins)	Adam Bratschi-Kaye	DFINITY Foundation	Niche Properties of Wasm Execution on the Internet Computer Blockchain	The Internet Computer blockchain implements a replicated state machine and uses WebAssembly to encode the state transition function and represent the smart contract programs. WebAssembly is especially fitting for this use case and the execution should satisfy a number of additional properties which are not commonly required in other contexts where WebAssembly is being used. This talk will give an overview of those properties, with the goals being to both raise awareness of these niche use cases and also find commonalities with other projects which may have similar constraints. In particular, some topics to be covered would be (i) determinism of execution, (ii) deterministically aborting long running functions, (iii) persistence of state with atomic updates (memory, globals, etc.), (iv) efficient compilation, (v) maintaining state across updates of Wasm code.
3:00 - 3:35 (35 mins)	Chris Fallin	Fastly	wevaling the wasms: AOT JS Compilation to WebAssembly	Dynamically-typed languages are, at first glance, a poor fit for compilation to WebAssembly: the techniques that make their execution fast in modern contexts, such as JIT compilation and inline caches, are not available or easy to implement in Wasm's static Harvard architecture. The state of the art today is to bundle such languages with their interpreter in a Wasm module. However, it is possible to do better. First, with careful thought, a JIT compiler can sometimes be reframed in a mostly-AOT way, by being explicit about phasing (e.g., collection of common inline-cache snippets ahead of time). Hybrid design points can be achieved where some dynamism -- late-binding via indirection -- can coexist with compiled code bodies. Finally, we can make it easier to turn an existing interpreter into a compiler with partial evaluation. This talk introduces weval, the Wasm partial evaluator, and its use to compile JavaScript ahead-of-time with the SpiderMonkey engine, showing good speedups.
3:35 - 4:00 (35 mins)			Wrap-up and open discussion
4:00 - 5:30 (1 hour, 30 mins)			Poster session (with refreshments)

Poster Session

In addition to the research talks listed above, we'll include a poster session.

Organization and Support

The WebAssembly Research Day is organized by Ben L. Titzer and partially supported by grants #2229731 and the WebAssembly Research Center at CMU, as well as a gift from Mozilla Corporation.