AVX-512 vpmovd2m: _mm256_movepi32_mask(), _mm512_movepi32_mask()

[twest820]

Hi, I'm updating some code from AVX/AVX2/FMA to AVX10/256 and AVX10/512. There's cases where vmovmskps is called (_mm256_movemask_ps()) to pack a mask but I'm not finding an equivalent in .NET 8's AVX-512 support even though the vpmovd2m instruction for this is part of AVX512DQ.

So I have a couple questions.

1. Am I missing an AVX-512 pathway? If not, will these intrinsics be supported in .NET 9? The mask packing here doesn't align with a Vector512.ConditionalSelect() branchless scenario.
2. Absent an AVX-512 solution in .NET 8, is there a better way to pack the mask besides upper and lower vmovmskpss, shifting the upper result, and oring the upper and lower bytes of the mask together?

[tannergooding]

vector.ExtractMostSignificantBits() will do the equivalent of movmsk* for 128/256-bit scenarios and vpmov*2m + kmov* for 512-bit (only emitting kmov for scenarios where the vector is determined to already be in a mask register, such as after a comparison operation)

[twest820]

Thank you once again, Tanner!

A follow on question, if I may: is there documentation I should consult that would be helpful to predicting which instructions are provided by Avx512* versus codegen around Vector512<T>? As I'm sure we're both painfully aware, the AVX-512 surface is vast. I'm finding it's frequently necessary to search in the System.Runtime.Intrinsics.X64 source code as https://learn.microsoft.com/en-us/dotnet/api/ and issues in this repo don't always yield hits (or can miss important information). However, if there's no hits anywhere it can be tricky to tell if something's been implemented. For example, in this case I'd checked Vector512<T>'s API before posting but failed to construct a search query that picked up ExtractMostSignificantBits() as an extension method.

As context, the optimized codegen from methods on VectorNNN<T> is neat but I'm increasingly thinking it'd be nice to be able to more easily differentiate among

1. There's an implemented intrinsic that does foo, use the intrinsic.
2. There's an implemented intrinsic that does foo but VectorNNN<T>.Bar() yields more efficient code.
3. The intrinsic for foo isn't implemented but VectorNNN<T>.Baz() does foo.
4. foo isn't supported yet but is planned for .NET 9/10/later.
5. Avx512NN.VL.Foo() is AVX/AVX2/FMA but will be EVEX encoded.
6. Avx512NN.VL.Foo() is SSE/AVX/AVX2/FMA and will stay VEX encoded, inserting a ymm restriction amid surrounding zmm capable code.
7. There's no intrinsic for Avx512??.Foo() but Foo() is provided as a convenience (this is in hovertext but it'd be nice, for example, to be able to turn on a rule or such that'd flag such use).

when writing System.Runtime.Intrinsics.X86 code. Not entirely sure all of these cases are possible—would have to check the hardware manuals and disassembly in places—and there's probably some I haven't encountered yet.

[tannergooding]

is there documentation I should consult that would be helpful to predicting which instructions are provided by Avx512* versus codegen around Vector512

Not really. A lot of this is implementation detail.

1. There's an implemented intrinsic that does foo, use the intrinsic.
2. There's an implemented intrinsic that does foo but VectorNNN.Bar() yields more efficient code.

In general, using the xplat API surface available on Vector128/256/512 is recommended over using the platform specific APIs where it is feasible to do so. That is, using vector + vector is preferred over Avx512F.Add(vector, vector). For the most part, the xplat API surface is 1-to-1 with the underlying instructions where feasible and aims to generate the most efficient pattern otherwise. There are of course some places this doesn't achieve the goal, but those are few and far between, so it shouldn't be a problem for most users/scenarios.

3. The intrinsic for foo isn't implemented but VectorNNN.Baz() does foo.
4. foo isn't supported yet but is planned for .NET 9/10/later.

In general we try to expose intrinsic APIs for most of the functionality. There are some cases, like movepi32_mask() where we didn't get the manual intrinsic exposed for .NET 8 and which we may expose in a future version of .NET. API proposals for such missing functionality is welcome.

Avx512NN.VL.Foo() is AVX/AVX2/FMA but will be EVEX encoded.

What encoding is used isn't really "guaranteed". Some instructions require the VEX or EVEX encoding, other instructions can use either the VEX or EVEX encoding depending on what other features are used or registers are allocated.

[KirkDybvik]

I am considering a SIMD enabled project in the latest C# rather than C++, and am looking for any suggestion on where to find any of the trig functions, such as _mm256_sincos_pd or the like. Are the there vectorized trig functions available in such a manner? Any docs, links, examples, advice would be appreciated.

[twest820]

So far as I know .NET doesn't have anything in SVML. My usual pathway's to port an open source (scalar) implementation from a C++ std implementation or a similar library. But not every project has licensing compatible with that approach.

[tannergooding]

Are the there vectorized trig functions available in such a manner?

No, these don't actually exist in hardware and are not universally available to compilers either. They are instead select functions provided by select compilers often using proprietary algorithms that can't be copied.

You'd need to roll your own, as indicated above.

---

We notably have approved and will end up implementing some cross platform versions of these APIs: #93513

This work will likely happen in the .NET 9 timeframe.