Intel SSE: Why does `_mm_extract_ps` return `int` instead of `float`?

by

None of the answers appear to actually answer the question, why does it return int.

The reason is, the extractps instruction actually copies a component of the vector to a general register. It does seem pretty silly for it to return an int but that’s what’s actually happening – the raw floating point value ends up in a general register (which hold integers).

If your compiler is configured to generate SSE for all floating point operations, then the closest thing to “extracting” a value to a register would be to shuffle the value into the low component of the vector, then cast it to a scalar float. This should cause that component of the vector to remain in an SSE register:

/* returns the second component of the vector */
float foo(__m128 b)
{
    return _mm_cvtss_f32(_mm_shuffle_ps(b, b, _MM_SHUFFLE(0, 0, 0, 2)));
}

The _mm_cvtss_f32 intrinsic is free, it does not generate instructions, it only makes the compiler reinterpret the xmm register as a float so it can be returned as such.

The _mm_shuffle_ps gets the desired value into the lowest component. The _MM_SHUFFLE macro generates an immediate operand for the resulting shufps instruction.

The 2 in the example gets the float from bit 95:64 of the 127:0 register (the 3rd 32 bit component from the beginning, in memory order) and places it in the 31:0 component of the register (the beginning, in memory order).

The resulting generated code will most likely return the value naturally in a register, like any other floating point value return, with no inefficient writing out to memory and reading it back.

If you’re generating code that uses the x87 FPU for floating point (for normal C code that isn’t SSE optimized), this would probably result in inefficient code being generated – the compiler would probably store out the component of the SSE vector then use fld to read it back into the x87 register stack. In general 64-bit platforms don’t use x87 (they use SSE for all floating point, mostly scalar instructions unless the compiler is vectorizing).

I should add that I always use C++, so I’m not sure whether it is more efficient to pass __m128 by value or by pointer in C. In C++ I would use a const __m128 & and this kind of code would be in a header, so the compiler can inline.

More Related Contents:

  1. print a __m128i variable
  2. What’s the difference between logical SSE intrinsics?
  3. Fastest Implementation of the Natural Exponential Function Using SSE
  4. Fast counting the number of set bits in __m128i register
  5. Do I get a performance penalty when mixing SSE integer/float SIMD instructions
  6. How to determine if memory is aligned?
  7. Getting started with Intel x86 SSE SIMD instructions
  8. Compare 16 byte strings with SSE
  9. inlining failed in call to always_inline ‘_mm_mullo_epi32’: target specific option mismatch
  10. Why does mulss take only 3 cycles on Haswell, different from Agner’s instruction tables? (Unrolling FP loops with multiple accumulators)
  11. AVX2 what is the most efficient way to pack left based on a mask?
  12. How to solve the 32-byte-alignment issue for AVX load/store operations?
  13. How to efficiently perform double/int64 conversions with SSE/AVX?
  14. How to count character occurrences using SIMD
  15. SIMD prefix sum on Intel cpu
  16. Why vectorizing the loop does not have performance improvement
  17. What’s missing/sub-optimal in this memcpy implementation?
  18. Loading 8 chars from memory into an __m256 variable as packed single precision floats
  19. Simd matmul program gives different numerical results
  20. Efficient 4×4 matrix vector multiplication with SSE: horizontal add and dot product – what’s the point?
  21. In GNU C inline asm, what are the size-override modifiers for xmm/ymm/zmm for a single operand?
  22. Getting max value in a __m128i vector with SSE?
  23. How to use Fused Multiply-Add (FMA) instructions with SSE/AVX
  24. C++ error: ‘_mm_sin_ps’ was not declared in this scope
  25. Count each bit-position separately over many 64-bit bitmasks, with AVX but not AVX2
  26. SSE reduction of float vector
  27. Most efficient way to check if all __m128i components are 0 [using
  28. How to convert 32-bit float to 8-bit signed char? (4:1 packing of int32 to int8 __m256i)
  29. Where can I find an official reference listing the operation of SSE intrinsic functions?
  30. Efficient 4×4 matrix multiplication (C vs assembly)

Leave a Comment