SIMD Made Easy with Intel Implicit SPMD Program Compiler

The hand-coded AVX2 procedure is far from optimal form, they waste time on horizontal addition in each iteration.

The First Rule of SIMD-ization says: keep all the intermediate results in vector(s), do horizontal reduction at the end.

Conversion from comparison result into vector of integers can be done a bit simpler: just one bit-and is needed and then cast to __m256i (casting doesn't emit any code as SIMD registers are untyped).

If someone is seeking more insight into it, follow this link:

https://www.slideshare.net/IntelSoftware/simple-single-instr...

> if you want to target multiple ISAs, you need to write multiple algorithms

In my experience, these algorithms are similar to each other. More often than not don't require too much extra time: a few macros here and there, a few templates, couple version of a small low-level function, etc.

> _mm256_hadd_epi32

That instruction is slow, e.g. on Ryzen it has latency 7. _mm256_slli_si256 and bitwise ops have latency 1, often can do same faster.

> readability is reduced when compared to the original scalar implementation

Solvable with a library, example: https://github.com/Const-me/IntelIntrinsics

Very interesting and I can't wait to try it out.

It's a pity though, based on what I understood from the website, that it's only producing binaries which can be linked to other than actually generating C / C++ code. That would be great for LTO, but also allow for better inspection of the generated SIMD code prior to compilation to ensure that all code is compiled by the same compiler. I guess the best way to inspect the artefacts prior to assembly is via LLVM IR.

I'm pretty happy that Intel chose to implement this based on LLVM. I'd have expected this to be sitting on top of icc.