Sync initialization

[tndrle]

Hi,

the default way of loading a module is using a factory that returns a Promise, e.g.

const init = require("module.js");
init().then((module) => {
  module.foo();
});

Is it possible to load a module synchronously and without factory in Node.js?

const module = require("module.js");
module.foo();

The only thing I found is WASM_ASYNC_COMPILATION=0.
However, I still have to call the factory first.

const init = require("module.js");
const module = init();
module.foo();

Thanks a lot.

[sbc100]

There is no way to do this today. I agree that this would be much more ergonomic way do doing things.. however even if we expose foo directly from module.js you would not, in the general case, be able to call it without first await something since there are several things, no just wasm instantiation, which might need be async and therefore prevent the module from being available syncronously.

Can I ask you can't do .then() or await on the module? Don't most node application involve async await these days? or is it just aesthetics?

[sbc100]

BTW, we used to have an option call MODULARIZE_INSTANCE which is more like what you want I think.. and actually is probably what most folks want. We should try to bring it back.. but even with that I think you would still need to await for the module to be ready before calling into it.

[tndrle]

Thanks for your prompt answer.

Can I ask you can't do .then() or await on the module? Don't most node application involve async await these days? or is it just aesthetics?

It's only for convenience. Technically, it would be fine to await it.

MODULARIZE_INSTANCE is a good hint. The change log says

Remove MODULARIZE_INSTANCE build option (#11037). This was a seldom used option that was complicating the logic for MODULARIZE. Module instances can be created by using MODULARIZE and calling the factory function explicitly. See the new --extern-post-js option added in this release, which can help code that used MODULARIZE_INSTANCE (you can add an extern post js which does Module = Module(); for example).

So would it be possible to build with MODULARIZE (I do that already) and WASM_ASYNC_COMPILATION=0 and then in the resulting JS file
add Module = Module(); like in the following?

var Module = (() => {
  // ...
})();
Module = Module(); // <--------- ADDED
if (typeof exports === 'object' && typeof module === 'object')
  module.exports = Module;
else if (typeof define === 'function' && define['amd'])
  define([], function() { return Module; });
else if (typeof exports === 'object')
  exports["Module"] = Module;

I only target Node.js

[sbc100]

I think it would not be easy, because there are other async things that might need to happen before the module is ready. Compiling wasm is just one of them. Another on would be populating the thread pool.

Having Module() sometime return a promise and sometime return a module could, I think, lead to more confusion. But if we can find a way to do it without adding too much complexity of magic, or different "modes", then maybe?

[iliakan]

There's a way with post.js return Module and using custom instantiateWasm that does sync calls to new WebAssembly.Instance.

[sbc100]

I think we used to have an option call MODULARIZE_INSTANCE that did something like that. See #11037. We should look into finding a way to restore this functionality perhaps?

[iliakan]

Right now, it can be implemented with about 10-20 lines of code, within the current framework.
Or so it seems.

I actually tried to do that, and was close to success. For me it didn't work out, because I'm using Emscripten in browser main thread. And new WebAssembly.Instance can't instantiate WASM>4k in sync fasion. Browser limitation. Does not exist in Node.JS.

P.S. @sbc100 , could you take a look into #emscripten on discord for a quick FS question, please?

[iliakan]

Actually, there may be a need for such option...

With the current framework with -sMODULARIZE, is there a way to create a new instance without recompiling?

E.g. I need to call createMyModule() multiple times - now it recompiles every time, it's very slow.

Guess, need to use the custom instantiateWasm for that?