simdeez

Highway looks nice. I'm in Rust these days, and SIMD support there is remarkably terrible in comparison. And I'm not nearly close enough to being an expert on the subject to contribute anything upstream to improve that. AVX512 is available only if you compile against nightly still. https://github.com/arduano/simdeez looks like it's trying to fit into this space, fairly promising.

A similar library in Rust: https://github.com/jackmott/simdeez

This is possible (for example): https://github.com/jackmott/simdeez The thing is that is not yet in-build in the lang. Let the crates sort some problems before commit it in the lang is like part of the philosophy of rust. For example, rust change the hash implementation after certain crate prove it worthy.

I have an 'art/game' project in Rust that uses vectorized expression evaluation to draw random images. It turns the expression tree into a stack machine then evaluates the stack machine with SIMD instructions: https://github.com/jackmott/evolution/blob/master/src/stack_... The speedup is really big for this case sometimes because not only do you do math 4x/8x/16x faster (depending on instruction set) but you also traverse the stack machine (or tree if you are pure interpreting) 4x/8x/16x less often. The improvement when traversing a tree is extra extra big because of reduced memory hops. I used a SIMD library I made in Rust, which lets me write the stack machine once, and then run it in SSE2/SSE41 or AVX2 mode. You can select either at runtime or compile time: https://github.com/jackmott/simdeez

There are libraries abstracting the SIMD calls if that's what you want, e.g. faster (https://github.com/AdamNiederer/faster) or simdeez (https://github.com/jackmott/simdeez), but these have to use basic operations at the end of the day too and this post shows how to do that. I'm not sure renaming the primitive operations provided by intel/amd to something "nicer" would help much here. Using plain SIMD will always be ugly and at least you can Google the names and get back the Intel documentation without first translating from a different name.

Since I wrote this, Rust did stabilize SIMD intrinsics, and using crates like https://github.com/AdamNiederer/faster or https://github.com/jackmott/simdeez you can write pretty idiomatic code to leverage them too. Also I believe the browsers have sped up some of the Javascript cases shown there substantially.

Leveraging auto vectorization can be nice, as you can compile for different targets with one set of code, and not have to write out intrinsics for SSE2, AVX2, AVX512 etc. But yeah it is tricky, you might get it all sorted and a compiler upgrade ruins it, or it won't work on another compiler, or someone updates your function later not realizing you carefully tuned it to get vectorized and it ruins it. Also there are some clever hacks you can do with intrinsics that compilers won't figure out sometimes. I made a library in Rust that will let you write a single function using abstracted intrinsics, that can produce SSE2/SSE41/AVX2 versions at compile time: https://github.com/jackmott/simdeez

Another Rust project with similar goals, different approach: https://github.com/jackmott/simdeez full disclosure, that's mine.

The compiler would need to know what other programs are running on the core, or the computer (depending on CPU/instructions). It has no hope! This is why it is advisable for SIMD libraries or libraries that use SIMD to always offer some levers for this kind of thing. This makes it a pain as you may have to write the same function 2 or 3 times in different SIMD instruction sets, or use a library to do that for you: https://github.com/jackmott/simdeez