Wizer pre-initialization

[alexcasalboni]

Would it be possible to implement the same Wizer pre-initialization for componentize-py, similar to ComponentizeJS?

Loading a Python-based Wasm component into memory (using wasmtime) takes many seconds and it would be great if we could find a way to reduce that to hundreds of milliseconds as for the other supported languages.

For comparison, here are the load times for different languages on my MacBook Pro (pretty much an empty component):

• Rust: 50ms
• Go: 60ms
• JS: 800ms
• Python: 2 seconds

[benbrandt]

@dicej can correct me if I'm wrong, but there is already something similar happening.
In my experience, the first load is really slow because of the wasm -> machine code compilation because the python interpreter is quite large. Subsequent calls are very fast.

[alexcasalboni]

Thanks for jumping in @benbrandt 🙏

I looked deeper into the codebase and found that in fact you are using component-init (rather than Wizer).

componentize-py/src/lib.rs

Line 506 in c50822c

let component = component_init::initialize_staged(

Is there anything else that can be done to speed up the init/compilation time?

I am asking because in production environments the init time is actually much higher, in the range of 10+ seconds (compared to the 2 seconds on my local machine). So that becomes problematic in some scenarios where you need to hot-load a component to serve a request or two, and then shutdown.

[alexcasalboni]

Also, I wonder why not using Wizer directly since ComponentizeJS showed that it can be used also for Wasm components (not just modules).

Based on their docs:

Wizer Pre-Initialization
Adaption follows the standard Wizer technique in pre-initializing a snapshot of the runtime against the source and bindings.
The snapshotting process executes the JS engine initialization, globals and parsing and compiling of the source code. Currently we also evaluate the top-level of the source so that the executed exports of the top-level ES module are provided already initialized.

So it seems that Wizer could speed up the compilation time too? Or that is completely different for the Python interpreter?

[dicej]

Is there anything else that can be done to speed up the init/compilation time?

You've got two options:

1. Enable caching so the compiled .cwasm is generated once and reused (and if you're planning to do multiple instantiations in the same host program, use InstancePre).
2. Use Winch, which will compile faster, but produce slower code.

See this thread for more details. Also see these benchmarks to get a sense of how different instantiation options affect performance.

Feel free to do your own benchmarks using your own program to get a sense of what the bottlenecks are; I expect @benbrandt is correct that almost all the time is spent compiling. I'd expect instantiating from an InstancePre and calling an export entails less than a millisecond on modern hardware for a componentize-py-generated component which has been pre-initialized using component-init.

Also, I wonder why not using Wizer directly since ComponentizeJS showed that it can be used also for Wasm components (not just modules).

ComponentizeJS does not use Wizer for components; it generates a module, runs Wizer on it, and then converts the output to a component. componentize-py does not do that because it's fundamentally incompatible with Python native extensions, which are packaged as .so shared libraries. Since the pre-init function can run arbitrary code, including code in native extensions, we need to generate the component which contains all the modules, including the .so libraries before pre-initing. Wizer supports neither multiple linked modules nor components, so it's not an option.

BTW, I've spoken at length about this with the ComponentizeJS maintainers, and they're planning to move to the same model as componentize-py eventually.

So it seems that Wizer could speed up the compilation time too? Or that is completely different for the Python interpreter?

Neither Wizer nor component-init touch the Wasm code at all (except for removing any start functions, but that's typically a negligible portion of the overall code). All they do is run a pre-init function, capture a snapshot of linear memory and any mutable globals, then generate a new module with all the original code (omitting any start functions and data segments) plus the snapshot. Neither will have any measurable affect on compilation time.

[alexcasalboni]

Thank you, @dicej this is very useful 🙏

I agree that Winch might become a good option for this use case, once it's marked as ready for production applications 👌

I've started looking into this to evaluate how much faster it would be. Other than selecting Strategy::Winch for my wasmtime::Config and setting the correct feature in my Cargo.toml (wasmtime = { version = "29.0.1", features = ["winch"] }), is there anything else I need to do in componentize-py to make Winch work? 🤔

I am getting a weird error when pre-instantiating the component:

let mut linker = Linker::new(engine);
wasmtime_wasi::add_to_linker_async(&mut linker)?;
let component = Component::from_file(engine, &file_path)?;
let instance_pre = linker.instantiate_pre(&component)?;

The error is:

Compilation error: zero byte expected (at offset 0xb92042)

Should I not pre-instantiate at all when using Winch? I couldn't find much documentation about this.

[dicej]

I haven't tried Winch yet myself, mostly because I have a Linux/ARM64 machine which wasn't supported by Winch last time I checked. Also, it didn't support certain Wasm features like funcrefs, which componentize-py makes use of. So you're in uncharted territory; sounds like it's still not yet ready for this purpose.