在 C++ 中使用 SSE2 SIMD 对两个数组求和的正确方法

Question

让我们首先包括以下内容：

#include <vector>
#include <random>
using namespace std;

现在，假设一个人有以下三个std:vector<float>：

N = 1048576;
vector<float> a(N);
vector<float> b(N);
vector<float> c(N);

default_random_engine randomGenerator(time(0));
uniform_real_distribution<float> diceroll(0.0f, 1.0f);
for(int i-0; i<N; i++)
{
    a[i] = diceroll(randomGenerator);
    b[i] = diceroll(randomGenerator);
}

现在，假设需要按a元素b求和并将结果存储在 中c，其标量形式如下所示：

for(int i=0; i<N; i++)
{
    c[i] = a[i] + b[i];
}

上述代码的 SSE2 矢量化版本是什么，请记住输入是a和b如上面定义的（即作为 的集合float）并且输出是c（也是 的集合float）？

经过大量研究后，我得出以下结论：

for(int i=0; i<N; i+=4)
{
    float a_toload[4] = { a[i], a[i + 1], a[i + 2], a[i + 3] };
    float b_toload[4] = { b[i], b[i + 1], b[i + 2], b[i + 3] };
    __m128 loaded_a = _mm_loadu_ps(a_toload);
    __m128 loaded_b = _mm_loadu_ps(b_toload);

    float result[4] = { 0, 0, 0, 0 };
    _mm_storeu_ps(result, _mm_add_ps(loaded_a , loaded_b));
    c[i] = result[0];
    c[i + 1] = result[1];
    c[i + 2] = result[2];
    c[i + 3] = result[3];
}

然而，这似乎真的很麻烦，而且效率肯定很低：上面的 SIMD 版本实际上比初始标量版本慢三倍（当然，是在 Microsoft VS15 的发布模式下，在优化后，经过 100 万次迭代后测量的） ，不仅仅是 12)。

Answer 1

你的 for 循环可以简化为

const int aligendN = N - N % 4;
for (int i = 0; i < alignedN; i+=4) {
    _mm_storeu_ps(&c[i], 
                  _mm_add_ps(_mm_loadu_ps(&a[i]), 
                  _mm_loadu_ps(&b[i])));
}
for (int i = alignedN; i < N; ++i) {
    c[i] = a[i] + b[i];
}

一些补充说明：

1. 处理最后几个浮点的小循环是很常见的，并且当N%4 != 0或 N 在编译时未知时，它是强制性的。
2. 我注意到您选择未对齐的版本加载/存储，与对齐的版本相比，有很小的损失。我在 stackoverflow 上找到了这个链接： Is the SSE unaligned loadtrinsic any Slower than thealigned loadtrinsic on x64_64 Intel CPUs?