How is this enabled during compilation?

[sparker-arm]

Hi!

I was expecting to see a target feature in LLVM to enable the use of this feature but, AFAICT, there isn't one. So, how can I enable the use of this?

Thanks.

[yuri91]

Upstream LLVM does not support this yet as far as I know.

The Cheerp C++ compiler has support (under flag -cheerp-wasm-enable=branchhinting).
Binaryen also recently added support for this, but I don't know if it is exposed to users, or only propagated from input to output.

[sparker-arm]

Okay, thanks!

@sunfishcode Are there any current plans to have this enabled in LLVM?

[sunfishcode]

I'm not aware of anyone working on it yet.

[kripken]

Binaryen can now roundtrip branch hints, but does not generate them. I did experiment with that,

WebAssembly/binaryen#7625

That copies the main parts of LLVM's analysis (the highest-probability stuff), so I would guess that LLVM would have the same outcome (unless I have a bug). @yuri91 Does Cheerp infer branch hints differently than LLVM perhaps? How much benefit do you see?

[yuri91]

@kripken I think that LLVM can do a bit better, because an important source of branch probabilities is manual annotations with [[likely]] and __builtin_expect(), and you cannot recover those in Binaryen.

Even so, I did tests similar to yours starting from C++ (with Cheerp), with similar underwhelming results.

It's possible that on a real-world codebase that uses source-level hints (say, Cpython) the difference would be measurable, but I have not tested that.

On the other hand, benchmarks on webvm.io show clear improvements. But there the Wasm modules (jit-compiled) have conditions for slow paths all over the place.

I think that to get a noticeable benefit, one needs a lot of code, and a good amount of almost certain branch conditions.
In that scenario, outlining the slow paths will noticeably decrease instruction cache misses.

[kripken]

Thanks @yuri91 , that makes sense.

One thing I noticed about LLVM output is that it already emits calls to noreturn functions like this:

(call $does-not-return)
(unreachable)

So it already puts an unreachable after calls it knows will trap or throw, which makes it simple for VMs to infer that path does not need to be in hot loops. (Perhaps if LLVM did not do that, then a toolchain analysis would help more.)

[kripken]

Some updates here, branch hinting support in LLVM may land soon: llvm/llvm-project#146230

Separately, I spent a bunch of time investigating benchmarks, starting from code annotations in the source (using this). I was unable to find any real-world code that benefits, though making an artificial benchmark is not hard (30% faster).

[sparker-arm]

So, are the improvements in your artificial benchmark coming from LLVM using the hints, or your runtime of choice? I certainly haven't looked into how much V8 uses their hints, which I believe existed before wasm hints.

[kripken]

I tested that benchmark in wasm on V8 and also compiled natively to x64 with clang, and saw similar speedups.

For wasm, most of the benefit happens on V8: while LLVM does emit different code with hints, stripping the hint removes most of the benefits (it is 10% faster rather than 30%). I also tested a flipped hint, that is, a wrong hint, where the wasm is identical except for the hint, and V8 runs it 73% slower (slower than with no hint).