15

我试图将两个向量相乘，其中一个向量的每个元素乘以另一个向量的相同索引中的元素。然后我想对结果向量的所有元素求和以获得一个数字。例如，向量 {1,2,3,4} 和 {5,6,7,8} 的计算如下所示：

1*5 + 2*6 + 3*7 + 4*8

本质上，我正在取两个向量的点积。我知道有一个 SSE 命令可以执行此操作，但该命令没有与之关联的内在函数。此时，我不想在我的 C 代码中编写内联汇编，所以我只想使用内部函数。这似乎是一个常见的计算，所以我对自己在谷歌上找不到答案感到惊讶。

注意：我正在针对支持 SSE 4.2 的特定微架构进行优化。

4

4 回答 4

22

如果您正在做较长向量的点积，_mm_add_ps请在内部循环中使用乘法和正则（或 FMA）。 将水平总和保存到最后。

但是，如果您只对一对 SIMD 向量进行点积：

GCC（至少 4.3 版）包括<smmintrin.h>SSE4.1 级别的内在函数，包括单精度和双精度点积：

_mm_dp_ps (__m128 __X, __m128 __Y, const int __M);
_mm_dp_pd (__m128d __X, __m128d __Y, const int __M);

在 Intel 主流 CPU（不是 Atom/Silvermont）上，这些比使用多条指令手动执行要快一些。

但是在 AMD（包括 Ryzen）上，dpps速度要慢得多。（参见Agner Fog 的说明表）

作为旧处理器的后备方案，您可以使用此算法来创建向量a和的点积b：

__m128 r1 = _mm_mul_ps(a, b);

然后水平求和r1使用最快的方式在 x86 上进行水平浮点向量求和（参见那里的评论版本，以及为什么它更快。）

__m128 shuf   = _mm_shuffle_ps(r1, r1, _MM_SHUFFLE(2, 3, 0, 1));
__m128 sums   = _mm_add_ps(r1, shuf);
shuf          = _mm_movehl_ps(shuf, sums);
sums          = _mm_add_ss(sums, shuf);
float result =  _mm_cvtss_f32(sums);

一个缓慢的替代方案每 2 次 shuffle hadd，这很容易成为 shuffle 吞吐量的瓶颈，尤其是在 Intel CPU 上。

r2 = _mm_hadd_ps(r1, r1);
r3 = _mm_hadd_ps(r2, r2);
_mm_store_ss(&result, r3);
于 2010-11-08T04:33:39.390 回答
7

我想说最快的 SSE 方法是：

static inline float CalcDotProductSse(__m128 x, __m128 y) {
    __m128 mulRes, shufReg, sumsReg;
    mulRes = _mm_mul_ps(x, y);

    // Calculates the sum of SSE Register - https://stackoverflow.com/a/35270026/195787
    shufReg = _mm_movehdup_ps(mulRes);        // Broadcast elements 3,1 to 2,0
    sumsReg = _mm_add_ps(mulRes, shufReg);
    shufReg = _mm_movehl_ps(shufReg, sumsReg); // High Half -> Low Half
    sumsReg = _mm_add_ss(sumsReg, shufReg);
    return  _mm_cvtss_f32(sumsReg); // Result in the lower part of the SSE Register
}

我跟着 - Fastest Way to Do Horizo​​ntal Float Vector Sum On x86。

于 2017-03-21T10:25:08.083 回答
3

我写了这个并用gcc -O3 -S -ftree-vectorize -ftree-vectorizer-verbose=2 sse.c

void f(int * __restrict__ a, int * __restrict__ b, int * __restrict__ c, int * __restrict__ d,
       int * __restrict__ e, int * __restrict__ f, int * __restrict__ g, int * __restrict__ h,
       int * __restrict__ o)
{
    int i;

    for (i = 0; i < 8; ++i)
        o[i] = a[i]*e[i] + b[i]*f[i] + c[i]*g[i] + d[i]*h[i];
}

GCC 4.3.0 对其进行了自动矢量化：

sse.c:5: note: LOOP VECTORIZED.
sse.c:2: note: vectorized 1 loops in function.

但是，只有在我使用具有足够迭代次数的循环时才会这样做——否则详细的输出将表明矢量化无利可图或循环太小。如果没有__restrict__关键字，它必须生成单独的非矢量化版本来处理输出o可能指向输入之一的情况。

我会将这些说明粘贴为示例，但由于部分矢量化展开了循环，因此它的可读性不是很高。

于 2010-11-08T01:42:50.400 回答
3

英特尔在这里有一篇文章涉及点积实现。

于 2010-11-08T01:42:59.020 回答