What is the purpose of the MoveMask for SSE and AVX

Question

Questions

1. What is the purpose or intention of a MoveMask?
2. What's the best place to learn how to use x86/x86-64 assembly/SSE/AVX?
3. Could I have written my code more efficiently?

Reason for Questions

I have an function written in F# for .NET that uses SSE2. I've written the same thing using AVX2 but the underlying question is the same. What is the intended purpose of a MoveMask? I know that it works for my purposes, I want to know why.

I am iterating through two 64-bit float arrays, a and b, testing that all of their values match. I am using the CompareEqual method (which I believe is wrapping a call to __m128d _mm_cmpeq_pd) to compare several values at a time. I then compare that result with a Vector128 of 0.0 64-bit float. My reasoning is that the result of CompareEqual will give a 0.0 value in the cases where the values don't match. Up to this point, it makes sense.

I then use the Sse2.MoveMask method on the result of the comparison with the zero vector. I've previously worked on using SSE and AVX for matching and I saw examples of people using MoveMask for the purpose for testing for non-zero values. I believe this method is using the int _mm_movemask_epi8 Intel intrinsic. I have included the F# code and the assembly that is JITed.

Is this really the intention of a MoveMask or is it just a happy coincidence it works for these purposes. I know my code works, I want to know WHY it works.

F# Code

#nowarn "9" "51" "20" // Don't want warnings about pointers

open System
open FSharp.NativeInterop
open System.Runtime.Intrinsics.X86
open System.Runtime.Intrinsics
open System.Collections.Generic

let sseFloatEquals (a: array<float>) (b: array<float>) =
    if a.Length = b.Length then
        let mutable result = true
        let mutable idx = 0
        
        if a.Length > 3 then
            let lastBlockIdx = a.Length - (a.Length % Vector128<float>.Count)
            let aSpan = a.AsSpan ()
            let bSpan = b.AsSpan ()
            let aPointer = && (aSpan.GetPinnableReference ())
            let bPointer = && (bSpan.GetPinnableReference ())
            let zeroVector = Vector128.Create 0.0

            while idx < lastBlockIdx && result do
                let aVector = Sse2.LoadVector128 (NativePtr.add aPointer idx)
                let bVector = Sse2.LoadVector128 (NativePtr.add bPointer idx)
                let comparison = Sse2.CompareEqual (aVector, bVector)
                let zeroTest = Sse2.CompareEqual (comparison, zeroVector)

                // The line I want to understand
                let matches = Sse2.MoveMask (zeroTest.AsByte ())
                if matches <> 0 then
                    result <- false

                idx <- idx + Vector128.Count

        while idx < a.Length && idx < b.Length && result do
            if a.[idx] <> b.[idx] then
                result <- false

            idx <- idx + 1

        result

    else
        false

Emitted Assembly

; Core CLR 5.0.921.35908 on amd64

_.sseFloatEquals$cont@11(System.Double[], System.Double[], Microsoft.FSharp.Core.Unit)
    L0000: push rdi
    L0001: push rsi
    L0002: push rbp
    L0003: push rbx
    L0004: sub rsp, 0x28
    L0008: vzeroupper
    L000b: mov eax, 1
    L0010: xor r8d, r8d
    L0013: mov r9d, [rcx+8]
    L0017: cmp r9d, 3
    L001b: jle short L008e
    L001d: mov r10d, r9d
    L0020: and r10d, 1
    L0024: mov r11d, r9d
    L0027: sub r11d, r10d
    L002a: lea r10, [rcx+0x10]
    L002e: mov esi, r9d
    L0031: test rdx, rdx
    L0034: jne short L003c
    L0036: xor edi, edi
    L0038: xor ebx, ebx
    L003a: jmp short L0043
    L003c: lea rdi, [rdx+0x10]
    L0040: mov ebx, [rdx+8]
    L0043: xor ebp, ebp
    L0045: test esi, esi
    L0047: je short L004c
    L0049: mov rbp, r10
    L004c: xor r10d, r10d
    L004f: test ebx, ebx
    L0051: je short L0056
    L0053: mov r10, rdi
    L0056: vxorps xmm0, xmm0, xmm0
    L005a: cmp r8d, r11d
    L005d: jge short L008e
    L005f: mov esi, eax
    L0061: test esi, esi
    L0063: je short L008e
    L0065: movsxd rsi, r8d
    L0068: vmovupd xmm1, [rbp+rsi*8]
    L006e: vmovupd xmm2, [r10+rsi*8]
    L0074: vcmpeqpd xmm1, xmm1, xmm2
    L0079: vcmpeqpd xmm1, xmm1, xmm0
    L007e: vpmovmskb esi, xmm1
    L0082: test esi, esi
    L0084: je short L0088
    L0086: xor eax, eax
    L0088: add r8d, 4
    L008c: jmp short L005a
    L008e: cmp r9d, r8d
    L0091: jle short L00c8
    L0093: cmp [rdx+8], r8d
    L0097: jle short L00c8
    L0099: mov r10d, eax
    L009c: test r10d, r10d
    L009f: je short L00c8
    L00a1: cmp r8d, r9d
    L00a4: jae short L00d1
    L00a6: movsxd r10, r8d
    L00a9: vmovsd xmm0, [rcx+r10*8+0x10]
    L00b0: cmp r8d, [rdx+8]
    L00b4: jae short L00d1
    L00b6: vucomisd xmm0, [rdx+r10*8+0x10]
    L00bd: jp short L00c1
    L00bf: je short L00c3
    L00c1: xor eax, eax
    L00c3: inc r8d
    L00c6: jmp short L008e
    L00c8: add rsp, 0x28
    L00cc: pop rbx
    L00cd: pop rbp
    L00ce: pop rsi
    L00cf: pop rdi
    L00d0: ret
    L00d1: call 0x00007ffcef38a370
    L00d6: int3

_.sseFloatEquals(System.Double[], System.Double[])
    L0000: mov r8d, [rcx+8]
    L0004: cmp r8d, [rdx+8]
    L0008: jne short L0012
    L000a: xor r8d, r8d
    L000d: jmp 0x00007ffc99000480
    L0012: xor eax, eax
    L0014: ret

Answer 1

MoveMask just extracts the high bit of each element into an integer bitmap. You have 3 element-size options: movmskpd (64-bit), movmskps (32-bit), and pmovmskb (8-bit).

This works well with SIMD compares, which produce an output that has all-zero when the predicate is false, all-one bits in elements where the predicate is true. All-ones is a bit-pattern for -QNaN if interpreted as an IEEE-FP floating-point value, but normally you don't do that. Instead movemask, or AND, (or AND / ANDN / OR or _mm_blend_pd) or things like that with a compare result.

---

movemask(v) != 0, movemask(v) == 0x3, or movemask(v) == 0 is how you check conditions like at least one element in a compare matched, or all matched, or none matched, respectively, where v is the result of _mm_cmpeq_pd or whatever. (Or just to extract signs directly without a compare).

For other element sizes, 0xf or 0xffff to match all four or all 16 bits. Or for AVX 256-bit vectors, twice as many bits, up to filling a whole 32-bit integer with vpmovmskb eax, ymm0.

---

What you're doing is really weird, using a 0.0 / NaN compare result as the input to another compare with vcmpeqpd xmm1, xmm1, xmm2 / vcmpeqpd xmm1, xmm1, xmm0. For the 2nd comparison, that can only be true for elements that are == 0.0 (i.e. +-0.0), because x == NaN is false for every x.

If the second vector is a constant zero (let zeroTest = Sse2.CompareEqual (comparison, zeroVector), that's pointless, you're just inverting the compare result which you could have done by checking a different integer condition or against a different constant, not doing runtime comparisons. (0.0 == 0.0 is true, producing an all-ones output, 0.0 == -NaN is false, producing an all-zero output.)

---

To learn more about intrinsics and SIMD, see for example Agner Fog's optimization guide; his asm guide has a chapter on SIMD. Also, his VectorClass library for C++ has some useful wrappers, and for learning purposes seeing how those wrapper functions implement some basic things could be useful.

To learn what things actually do, see Intel's intrinsics guide. You can search by asm instruction or C++ intrinsic name.

I think MS has docs for their C# System.Runtime.Intrinsics.X86, and I assume F# uses the same intrinsics, but I don't use either language myself.

---

Related re: comparisons:

• Check that at least 1 element is true in each of multiple vectors of compare results - horizontal OR then AND

• Get the last line separator - pcmpeqb -> pmovmskb -> bsr to find the position of the last match element in a vector of compare results. Bit-scan reverse on the compare mask. Often you want to scan forward to find the first match (or invert and find first mismatch, like for memcmp). e.g. Compare 16 byte strings with SSE
  Or popcount them if you're counting occurrences by matching against a loop-invariant vector of a broadcasted character: How can I count the occurrence of a byte in array using SIMD? - instead of movemask, use the compare result as integer 0 / -1. SIMD subtract from a vector accumulator in the inner loop, then horizontal sum of integer elements in an outer loop.

• SIMD instructions for floating point equality comparison (with NaN == NaN) - useful exercise in understanding how NaNs work.

Answer 2

In addition to what Peter pointed out already.

Yes, MoveMask (movmskp) works well with comparisons, if you need indices as general-purpose integer bask, to do like bsf or popcnt or whatever.

As you are determining just the fact of nonzero, Sse41.TestZ (or Avx.TestZ for AVX) which compiles to ptest could be better, as it makes the result to a flag directly, without populating a general purpose register.