Asynchronous WebAssembly compilation project

Support asynchronous WebAssembly compilation

Background information: Major browsers support the WebAssembly standard which can be used to implement performance-sensitive sandboxed applications. Servo is a new, experimental browser that supports synchronously compiling and executing WebAssembly code, but does not yet support asynchronous compilation. This means that the entire WebAssembly program must be fetched before compilation can begin, which leads to longer time loading pages that run WebAssembly programs than in other web browsers. The goal of this work is to support compiling WebAssembly programs asynchronously so compilation can begin while the program is still being fetched from the network.

Tracking issue: (please ask questions in these issues)

• https://github.com/servo/servo/issues/21476

Useful references:

• Guide to getting Servo building
• Specification for compiling a streaming WebAssembly program
• Demo of an asynchronously loaded WebAssembly program
• Equivalent implementation in Firefox:
  • JS engine callback setup
  • Response promise interactions
  • Streaming handling
• Documentation for types and modules inside Servo

Initial steps:

• email the mozilla.dev.servo mailing list (be sure to subscribe to it first!) introducing your group and asking any necessary questions
• binding stream consumer
  • create rust JS::StreamConsumer wrapper that stores a pointer to the object and has methods for consumeChunk, streamEnd, streamError, and noteResponseURLs
  • create an extern "C" function in script_runtime.rs that matches ConsumeStreamCallback that initiates the streaming webassembly compilation then creates a wrapper for the stream consumer and stores it in the Response object
  • create an extern "C" function in script_runtime.rs that matches ReportStreamErrorCallback and reports an error with the error! macro
  • call InitStreamConsumerCallback in new_rt_and_cx with the two new functions as arguments

Subsequent steps:

• binding runnable dispatching:
  • pass network task source into new_rt_and_cx functions
  • create rust JS::Runnable wrapper that stores a pointer to the object and has a run method that calls the new C function passing the stored pointer
  • create an extern "C" function in script_runtime.rs that matches DispatchToEventLoopCallback that casts the closure argument to a boxed network task source, wraps the runnable pointer in the new struct, and uses the network task source to queue a task that calls the run method of the wrapper
  • call InitDispatchToEventLoop in new_rt_and_cx_with_parent passing the new function and the boxed network task source as the closure argument /blob/b2f83932fe9d361face14efd03f2465b9262e687/mozjs/js/src/jsapi.h#L2475) in new-rt_and_cx_with_parent passing the new function
• add a stream consumer wrapper field to Response, and call the streamEnd method in Response::finish
• add a stream_chunk method to Response and call it from FetchContext::process_response_chunk; this should invoke the consumeChunk method of the stream consumer wrapper if it exists.