Wasm3 for smart pallet-contracts?

[nazar-pc]

I was reading https://arxiv.org/abs/2012.01032 and got curious why there are no discussions on wasm3 in this repo.

Wasm3 claims and according to benchmarks in ^ is the fastest WebAssembly interpreter. I understand that it may have different design considerations than wasmi or wasmer (not to mention the fact that it is written in C), but it might be an interesting potential option nevertheless.

Performance comparison: https://github.com/wasm3/wasm3/blob/main/docs/Performance.md

There is a Rust wrapper (somewhat experimental): https://github.com/wasm3/wasm3-rs

[bkchr]

The linked performance comparison shows that it is slower than wasmer?

[nazar-pc]

The first benchmark there is inverse. Wasm3 is 1.0x and everything is slower than that.

Wasm3 is interesting because it should be faster for simple contracts because of fast cold start and might be slower for more complex code.

I thought about that after reading #10298 where wasmer single-pass turns out slower than wasmi end-to-end.

[ggwpez]

GCC is most certainly the fastest and node the slowest, so wasm3 is only better than wac, wasm-micro-runtime and node but slower than everything else.

[nazar-pc]

Actually native is not always the fastest unless it is compiled with -march native.

But the primary point here is that wasm3 is at least potentially worth looking into, at least for some use cases it is very competitive.

See linked arxiv for more impressive charts, but everything needs to be re-benchmarked for a particular use case.

[bkchr]

The first benchmark there is inverse. Wasm3 is 1.0x and everything is slower than that.

Wasm3 is interesting because it should be faster for simple contracts because of fast cold start and might be slower for more complex code.

I thought about that after reading #10298 where wasmer single-pass turns out slower than wasmi end-to-end.

Node v13.0.1 (interpreter)       28.544923     57.0x
wac (wax)                       101.864113     16.0x
wasm-micro-runtime              201.612903      8.1x ▲ slower

Only these are slower.

[nazar-pc]

Hm, you're right, I read it incorrectly 🤔

[pepyakin]

wasm3 indeed provides good performance numbers and even though there is not much discussion around our repos, we do keep an eye on it.

I can talk only about the wasm for the Runtime execution. There we are not really interested in wasm3 because we are fully satisfied with our choice of wasmtime. Though impressive performance for an interpreter, compiling engine could yield even more performance.

When it comes to the wasm virtualization (fka sandboxing, i.e. wasm smart-contracts) then it is more interesting. However, there are a different set of problems there. I think @athei can talk about this more.

[athei]

Yeah I looked into it and talked about it a bit with @pepyakin and other people. For contracts it would indeed be a good solution to have a very fast interpreter. Reason is that we cannot really cache the compiled and optimized code like it is possible for runtimes. So the compilation step eats away what we gain in execution speed. And we also cannot use wasmtime because it isn't resilient against compiler bombs. So we are reliant on single pass compiler which generate even slower code.

That said, there are some reasons why we didn't use wasm3, yet:

• It is written in C and has no particular focus on determinism and security. So there are some concerns to use it for contracts.
• Rust bindings are kind of experimental and unmaintained.
• Currently, the code that deals with execution engines for contracts is a mess. It would need some cleanup (we are working on this).