未知的 SSE 瓶颈

Question

我有一个通用代码，我正试图将其移至 SSE 以加快它的速度，因为它经常被调用。有问题的代码基本上是这样的：

for (int i = 1; i < mysize; ++i)
{
    buf[i] = myMin(buf[i], buf[i - 1] + offset);
}

myMin 是你的简单 min 函数 (a

我的 SSE 代码（我已经经历了几次迭代以加快速度）现在是这种形式：

float tmpf = *(tmp - 1);
__m128 off = _mm_set_ss(offset);
for (int l = 0; l < mysize; l += 4)
{
    __m128 post = _mm_load_ps(tmp);
    __m128 pre = _mm_move_ss(post, _mm_set_ss(tmpf));
    pre = _mm_shuffle_ps(pre, pre, _MM_SHUFFLE(0, 3, 2, 1));
    pre = _mm_add_ss(pre, off);
    post = _mm_min_ss(post, pre);

    // reversed
    pre = _mm_shuffle_ps(post, post, _MM_SHUFFLE(2, 1, 0, 3));
    post = _mm_add_ss(post, off );
    pre = _mm_min_ss(pre, post);

    post = _mm_shuffle_ps(pre, pre, _MM_SHUFFLE(2, 1, 0, 3));
    pre = _mm_add_ss(pre, off);
    post = _mm_min_ss(post, pre);

    // reversed
    pre = _mm_shuffle_ps(post, post, _MM_SHUFFLE(2, 1, 0, 3));
    post = _mm_add_ss(post, off);
    pre = _mm_min_ss(pre, post);

    post = _mm_shuffle_ps(pre, pre, _MM_SHUFFLE(2, 1, 0, 3));
    _mm_store_ps(tmp, post);
    tmpf = tmp[3];
    tmp += 4;
}

忽略任何边缘情况，我已经处理得很好，并且由于 buf/tmp 的大小，这些情况的开销可以忽略不计，谁能解释为什么 SSE 版本慢 2 倍？ VTune 一直将其归因于 L1 未命中，但正如我所见，它应该减少 4 倍的 L1 行程并且没有分支/跳转，所以它应该更快，但事实并非如此。我在这里误会了什么？

谢谢

编辑： 所以我确实在一个单独的测试用例中找到了其他东西。我不认为这会很重要，但很遗憾。所以上面的 mysize 实际上并没有那么大（大约 30-50），但是其中有很多，而且它们都是连续完成的。在这种情况下，三元表达式比 SSE 更快。但是，如果将其反转为 mysize 以百万为单位并且只有 30-50 次迭代，则 SSE 版本更快。知道为什么吗？我认为两者的内存交互是相同的，包括先发制人的预取等......

Answer 1

如果此代码对性能至关重要，则必须查看获得的数据。杀死你的是串行依赖，你需要摆脱它。

一个非常小的值 buf [i] 会影响很多以下值。例如，如果 offset = 1，buf [0] = 0，并且所有其他值 > 100 万，则该值将影响下一个 100 万。另一方面，这种事情可能很少发生。

如果很少见，他们检查是否完全矢量化了 buf [i] > buf [i] + 偏移量，如果是则替换它，并跟踪更改的位置，而不考虑 buf [i] 值可能会涓涓细流向上。然后检查更改的位置，然后重新检查它们。

在极端情况下，假设 buf [i] 始终介于 0 和 1 之间，并且 offset > 0.5，你知道 buf [i] 根本无法影响 buf [i + 2]，所以你只需忽略串行依赖和并行执行所有操作，完全矢量化。

另一方面，如果缓冲区中有一些影响大量连续值的微小值，则从第一个值 buf [0] 开始并完全矢量化检查是否 buf [i]

你说“值可以是任何东西”。如果是这种情况，例如，如果 buf [i] 是在 0 到 1,000,000 之间的任意位置随机选择的，并且偏移量不是很大，那么您将拥有 buf [i] 元素，它会强制许多以下元素成为 buf [i] + (k - i) * 偏移量。例如，如果 offset = 1，并且您发现 buf [i] 约为 10,000，那么它将强制平均约 100 个值等于 buf [i] + (k - i) * offset。

Answer 2

这是一个你可以尝试的无分支解决方案

for (int i = 1; i < mysize; i++) {
    float a = buf[i];
    float b = buf[i-1] + offset;
    buf[i] = b + (a<b)*(a-b);
}

这是程序集：

.L6:
addss   xmm0, xmm4
movss   xmm1, DWORD PTR [rax]
movaps  xmm2, xmm1
add rax, 4
movaps  xmm3, xmm6
cmpltss xmm2, xmm0
subss   xmm1, xmm0
andps   xmm3, xmm2
andnps  xmm2, xmm5
orps    xmm2, xmm3
mulss   xmm1, xmm2
addss   xmm0, xmm1
movss   DWORD PTR [rax-4], xmm0
cmp rax, rdx
jne .L6

但是有分支的版本可能已经更好了

for (int i = 1; i < mysize; i++) {
     float a = buf[i];
     float b = buf[i-1] + offset;
     buf[i] = a<b ? a : b;
}

这是程序集

.L15:
addss   xmm0, xmm2
movss   xmm1, DWORD PTR [rax]
add rax, 4
minss   xmm1, xmm0
movss   DWORD PTR [rax-4], xmm1
cmp rax, rdx
movaps  xmm0, xmm1
jne .L15

这使用minss（cmp rax, rdx 适用于循环迭代器）生成无论如何都是无分支的代码。

最后，这里是您可以与 MSVC 一起使用的代码，它生成与无分支的 GCC 相同的程序集

__m128 offset4 = _mm_set1_ps(offset);
for (int i = 1; i < mysize; i++) {
    __m128 a = _mm_load_ss(&buf[i]);
    __m128 b = _mm_load_ss(&buf[i-1]);
    b = _mm_add_ss(b, offset4);
    a = _mm_min_ss(a,b);
    _mm_store_ss(&buf[i], a);
}

这是您可以尝试使用分支的另一种形式

__m128 offset4 = _mm_set1_ps(offset);
for (int i = 1; i < mysize; i++) {
    __m128 a = _mm_load_ss(&buf[i]);
    __m128 b = _mm_load_ss(&buf[i-1]);
    b = _mm_add_ss(b, offset4);
    if(_mm_comige_ss(b,a))
        _mm_store_ss(&buf[i], b);
}