Can multiple Wasm modules interact with each other and share memory directly via functions?

Question

Is there a way to instantiate two Wasm modules, a and b such that a can call functions from b and also access the distinct memory from b? For example, let's say that a gets memory by calling an implementation of malloc in b that is exposed to a. This way, all useful memory comes from b. If so, how can it be done? More specifically, can this be done without additional overhead, and without interacting with JavaScript in-between these operations (except for the initialization step when instantiating the modules and setting imports/exports)? What are the performance characteristics of this sort of indirection and memory access, or is there no issue at all? In this case, I want to micro-optimize.

(I've read several pieces of documentation, but I can't find a clear answer. I think that in future versions of Wasm, there are plans for standardized dynamic linking that would help, but we're not there yet.)

Answer 1

Is there a way to instantiate two WASM modules, a and b such that a can call functions from b

Yes, you can instantiate module b exporting one of its functions, then instantiate a importing that function so that the two can interact. However, this is not going to be as fast as one WebAssembly function calling another as the call is going via the host environment.

and also access the distinct memory from b

Yes, once again, this is possible. Linear memory can be shared between a WebAssembly module and its host, and can also be shared between two modules.

can this be done without additional overhead, and without interacting with JavaScript in-between these operations

As iterates above, no, it cannot currently be done without additional overhead.

This will change in the future as the WebAssembly specification is enhanced and matures. One challenge involved in usefully communicating directly between two WebAssembly modules is understanding the API each exposes. WebAssembly is a compilation target, and different source languages (C++, Rust) encode types in different ways — this significantly limits inter-module communication.

An important stepping stone towards this is Interface Types, which encodes the API specification for a module / function. Once this has been implemented, direct communication between WebAssembly modules should be quite possible.