Visual Studio 2017: _mm_load_ps often compiled to movups

by

On recent versions of Visual Studio and the Intel Compiler (recent as post-2013?), the compiler rarely ever generates aligned SIMD load/stores anymore.

When compiling for AVX or higher:

  • The Microsoft compiler (>VS2013?) doesn’t generate aligned loads. But it still generates aligned stores.
  • The Intel compiler (> Parallel Studio 2012?) doesn’t do it at all anymore. But you’ll still see them in ICC-compiled binaries inside their hand-optimized libraries like memset().
  • As of GCC 6.1, it still generates aligned load/stores when you use the aligned intrinsics.

The compiler is allowed to do this because it’s not a loss of functionality when the code is written correctly. All processors starting from Nehalem have no penalty for unaligned load/stores when the address is aligned.

Microsoft’s stance on this issue is that it “helps the programmer by not crashing”. Unfortunately, I can’t find the original source for this statement from Microsoft anymore. In my opinion, this achieves the exact opposite of that because it hides misalignment penalties. From the correctness standpoint, it also hides incorrect code.

Whatever the case is, unconditionally using unaligned load/stores does simplify the compiler a bit.

New Relevations:

  • Starting Parallel Studio 2018, the Intel Compiler no longer generates aligned moves at all – even for pre-Nehalem targets.
  • Starting from Visual Studio 2017, the Microsoft Compiler also no longer generates aligned moves at all – even when targeting pre-AVX hardware.

Both cases result in inevitable performance degradation on older processors. But it seems that this is intentional as both Intel and Microsoft no longer care about old processors.

The only load/store intrinsics that are immune to this are the non-temporal load/stores. There is no unaligned equivalent of them, so the compiler has no choice.

So if you want to just test for correctness of your code, you can substitute in the load/store intrinsics for non-temporal ones. But be careful not to let something like this slip into production code since NT load/stores (NT-stores in particular) are a double-edged sword that can hurt you if you don’t know what you’re doing.

More Related Contents:

  1. print a __m128i variable
  2. SSE, intrinsics, and alignment
  3. Do I get a performance penalty when mixing SSE integer/float SIMD instructions
  4. C++ error: ‘_mm_sin_ps’ was not declared in this scope
  5. Get member of __m128 by index?
  6. Most insanely fast way to convert 9 char digits into an int or unsigned int
  7. How to implement “_mm_storeu_epi64” without aliasing problems?
  8. Most efficient way to check if all __m128i components are 0 [using
  9. Why does mulss take only 3 cycles on Haswell, different from Agner’s instruction tables? (Unrolling FP loops with multiple accumulators)
  10. AVX2 what is the most efficient way to pack left based on a mask?
  11. Is `reinterpret_cast`ing between hardware SIMD vector pointer and the corresponding type an undefined behavior?
  12. How to solve the 32-byte-alignment issue for AVX load/store operations?
  13. Atomic double floating point or SSE/AVX vector load/store on x86_64
  14. What C/C++ compiler can use push pop instructions for creating local variables, instead of just increasing esp once?
  15. Is right shift undefined behavior if the count is larger than the width of the type?
  16. Algorithm for finding the smallest power of two that’s greater or equal to a given value [duplicate]
  17. Loading 8 chars from memory into an __m256 variable as packed single precision floats
  18. Using AVX CPU instructions: Poor performance without “/arch:AVX”
  19. How is a vector’s data aligned?
  20. Difference in performance between MSVC and GCC for highly optimized matrix multplication code
  21. Intrinsics for CPUID like informations?
  22. Loop unrolling to achieve maximum throughput with Ivy Bridge and Haswell
  23. Why does a std::atomic store with sequential consistency use XCHG?
  24. Unoptimized clang++ code generates unneeded “movl $0, -4(%rbp)” in a trivial main()
  25. Assembly ADC (Add with carry) to C++
  26. Getting max value in a __m128i vector with SSE?
  27. Can PTEST be used to test if two registers are both zero or some other condition?
  28. What are these seemingly-useless callq instructions in my x86 object files for?
  29. SSE reduction of float vector
  30. Why is this SIMD multiplication not faster than non-SIMD multiplication?

Leave a Comment