How to make VC compiler optimize my code with SIMD better? - visual-c++

Question

I'm now learning SIMD and thinking about how to let compiler optimize my code better. Now I'm playing with Visual C++ 2013 x86.
I have an array, I have another array, and I want to compute like this:
void computeSum(float* __restrict arr, float* __restrict inp1, float* __restrict inp2, int count)
{
__declspec(align(16)) float* p1 = inp1;
__declspec(align(16)) float* p2 = inp2;
__declspec(align(16)) float* ret = arr;
while (count > 0)
{
ret[0] = p1[0] + p2[0];
ret[1] = p1[1] + p2[1];
ret[2] = p1[2] + p2[2];
ret[3] = p1[3] + p2[3];
p1 += 4;
p2 += 4;
ret += 4;
count -= 4;
}
}
I want to tell the compiler that the arrays are aligned to 16-byte boundary and anyone is not overlay on another, and one loop will compute 4 continuous float number's summation.
But in generated code, VC prefer MOVSS/ADDSS and not use ADDPS which I hope it to.
If I configure the project to use LLVM-vs2013 tool chain, it use ADDPS to compute the summation.
I know how to use compiler intrinsics to write SIMD code, but that's not what I want.
Are there any more hints that VC needs to use ADDPS instruction?
This is the full piece of code.
#include <stdio.h>
#include <stdlib.h>
void computeSum(float* __restrict arr, float* __restrict inp1, float* __restrict inp2, int count)
{
__declspec(align(16)) float* p1 = inp1;
__declspec(align(16)) float* p2 = inp2;
__declspec(align(16)) float* ret = arr;
while (count > 0)
{
ret[0] = p1[0] + p2[0];
ret[1] = p1[1] + p2[1];
ret[2] = p1[2] + p2[2];
ret[3] = p1[3] + p2[3];
p1 += 4;
p2 += 4;
ret += 4;
count -= 4;
}
}
int main()
{
float* inp1 = (float*)_aligned_malloc(sizeof(float) * 128, 16);
float* inp2 = (float*)_aligned_malloc(sizeof(float) * 128, 16);
float* result = (float*)_aligned_malloc(sizeof(float) * 128, 16);
for (int i = 0; i < 128; ++i)
{
inp1[i] = inp2[i] = i;
}
computeSum(result, inp1, inp2, 128);
for (int i = 0; i < 128; ++i)
{
printf("%f\t", result[i]);
}
return 0;
}

Answer 1

Visual C++ 2013 or later will default to use /arch:SSE2 for x86, but you should still check the settings in your Visual Studio project to make sure it hasn't explicitly been set to something else. For x64, /arch:SSE2 is implicit.
The only time that Visual C++ automatically generates multi-lane (like ADDPS) rather than single-lane (ADDSS) instructions is due to the auto-vectorizer. See MSDN for details and pay particular attention to the /Qvec-report:2 switch--and note that this will not happen with optimizations disabled as is common in Debug configurations.
Most SIMD (multi-lane) codegen is better accomplished with explicit intrinsics usage. For a lot of examples of this style of coding, see DirectXMath.