Of interest, I've written my own core::simd mimic so I don't have to make all my libs and programs use nightly. It started as me just making my Quaternion and Vec lib (lin-alg) have their own SoA SIMD variants (Vec3x16 etc), but I ended up implementing and publicly exposing f32x16 etc. Will remove those once core::simd is stable. Downside: These are x86 only; no ARM support.

I also added packing and unpacking helpers that assist with handling final lane 0 values etc. But there is still some subtly, as the article pointed out, compared to using Rayon or non-SIMD CPU code related to packing and unpacking. E.g. you should try to keep things in their SIMD form throughout the whole pipeline, how you pair them with non-SIMD values (Like you might pair [T; 8] with f32x8 etc) etc.

▲

____tom____ 13 hours ago | parent [-]

I'm not a rust programmer.

Can't you just make a local copy of the existing package and use that? Did you need to re-implement?

▲

dzaima 12 hours ago | parent | next [-]

The nightly built-in core::simd makes use of a bunch of intrinsics to "implement" the SIMD ops (or, rather, directly delegate the implementation to LLVM which you otherwise cannot do from plain Rust), which are as much if not more volatile than core::simd itself (and also nightly-only).

▲

vlovich123 12 hours ago | parent [-]

> or, rather, directly delegate the implementation to LLVM which you otherwise cannot do from plain Rust

I thought the intrinsic specifically were available in plain safe rust and the alignment required intrinsics were allowed in unsafe rust. I’m not sure I understand this “direct to llvm dispatch” argument or how that isn’t accessible to stable Rust today.

▲

dzaima 12 hours ago | parent [-]

You can indeed use intrinsics to make a SIMD library in plain safe stable rust today to some extent; that just isn't what core::simd does; rather, on the Rust-side it's all target-agnostic and LLVM (or whatever other backend) handles deciding how to lower any given op to the target architecture.

e.g. all core::simd addition ends up invoking the single function [1] which is then directly handled by rustc. But these architecture-agnostic intrinsics are unstable[2] (as they're only there as a building block for core::simd), and you can't manually use "#[rustc_intrinsic]" & co in stable rust either.

[1]: https://github.com/rust-lang/rust/blob/b01cc1cf01ed12adb2595...

[2]: https://github.com/rust-lang/rust/blob/b01cc1cf01ed12adb2595...

	▲	the__alchemist 11 hours ago \| parent [-]
		This is what I ended up doing as a stopgap.

▲

13 hours ago | parent | prev | next [-]

[deleted]

▲

the__alchemist 13 hours ago | parent | prev [-]

Good question. Probably, but I don't know how and haven't tried.