I’ve been reading up on the x86 instruction set extensions, and they only seem useful in some quite specific circumstances (eg HADDPD – (Horizontal-Add-Packed-Double) in SSE3). These require a certain register layout that needs to be either deliberately set up, or occur from the series of instructions before it. How often do general-purpose compilers like gcc actually use these instructions (or a subset thereof), or are they mainly to be used in hand-coded assembler? How does the compiler detect where it is appropriate to use SIMD instructions?
Share
Generally, few compilers use them. GCC and Visual Studio arn’t usually able to use the SIMD instructions. If you enable SSE as a compiler flag, it will use the scalar SSE instructions for regular floating-point operations, but generally, don’t expect the vectorized ones to be used automatically. Recent versions of GCC might be able to use them in some cases, but didn’t work last I tried. Intel’s C++ compiler is the only big compiler I know of that is able to auto-vectorize some loops.
In general though, you’ll have to use them yourself. Either in raw assembler, or by using compiler intrinsics. In general, I’d say intrinsics are the better approach, since they better allow the compiler to understand the code, and so schedule and optimize, but in practice, I know MSVC at least doesn’t always generate very efficient code from intrinsics, so plain asm may be the best solution there. Experiment, see what works. But don’t expect the compiler to use these instructions for you, unless you 1) use the right compiler, and 2) write fairly simple loops that can be trivially vectorized.
Update 2012
Ok, so three years have passed since I wrote this answer. GCC has been able to auto-vectorize (simple) code for a couple of years now, and in VS2012, MSVC finally gains the same capability. Of course, the main part of my answer still applies: compilers can still only vectorize fairly trivial code. For anything more complex, you’re stuck fiddling with intrinsics or inline asm.