与 SSE 的性能相同

Question

我对以下循环进行了矢量化，该循环出现在我正在开发的应用程序中：

void vecScl(Node** A, Node* B, long val){

    int fact = round( dot / const);

    for(i=0; i<SIZE ;i++)
        (*A)->vector[i] -= fact * B->vector[i];

}

这是 SSE 代码：

void vecSclSSE(Node** A, Node* B, long val){

    int fact = round( dot / const);

    __m128i vecPi, vecQi, vecCi, vecQCi, vecResi;

    int sseBound = SIZE/4;

    for(i=0,j=0;  j<sseBound  ; i+=4,j++){

        vecPi = _mm_loadu_si128((__m128i *)&((*A)->vector)[i] );
        vecQi = _mm_set_epi32(fact,fact,fact,fact);
        vecCi = _mm_loadu_si128((__m128i *)&((B)->vector)[i] );
        vecQCi = _mm_mullo_epi32(vecQi,vecCi);
        vecResi = _mm_sub_epi32(vecPi,vecQCi);               
        _mm_storeu_si128((__m128i *) (((*A)->vector) + i), vecResi );

    }

    //Compute remaining positions if SIZE % 4 != 0 
    for(; i<SIZE ;i++)
        (*A)->vector[i] -= q * B->vector[i];

}

虽然这在正确性方面有效，但使用和不使用 SSE 的性能完全相同。我正在编译代码：

 g++ *.cpp *.h -msse4.1 -march=corei7-avx -mtune=corei7-avx -mno-avx -mno-aes -Warray-bounds -O2

这是因为我没有分配（并相应地使用 SSE 函数）对齐的内存吗？代码更改起来非常复杂，所以我暂时避免这样做。

顺便说一句，在进一步改进方面，考虑到我受限于 Sandy Bridge 架构，我能做的最好的事情是什么？

编辑：编译器尚未对代码进行矢量化。首先，我将向量的数据类型更改为shorts，这不会改变性能。然后，我用-fno-tree-vectorize编译，性能是一样的。

非常感谢

Answer 1

我想说的是，对于相同的 SIZE，我能够对发生在第一篇文章之前的内核进行矢量化处理。这一次，我有很大的加速（我不会说这个因素，因为它是无关紧要的，除非我量化整个应用程序中内核花费的时间）。内核计算两个向量的点积，即：

for(i=0;i<SIZE;i++)
    dot += A->vector[i] * B->vector[i];

由此我可以得出结论，SIZE 小不是问题。反过来，这表明我在第一个内核中可能做错了。有人可以为第一个内核建议一组不同的 SSE 操作吗？我认为值得一试。下一步是分配对齐的内存，但如前所述，这在 Sandy Bridge 和其他新架构中并不重要。

这再次证明编译器没有对代码进行向量化。

谢谢

Answer 2

如果您的数据很大，那么您可能只是受内存限制，因为每次加载/存储只执行很少的 ALU 操作。

不过，您可以尝试一些小的改进：

inline void vecSclSSE(Node** A, Node* B, long val){
                                            // make function inline, for cases where `val` is small

    const int fact = (dot + const / 2 - 1) / const;
                                            // use integer arithmetic here if possible

    const __m128i vecQi = _mm_set1_epi32(fact);
                                            // hoist constant initialisation out of loop

    int32_t * const pA = (*A)->vector;      // hoist invariant de-references out of loop
    int32_t * const pB = B->vector;

    __m128i vecPi, vecCi, vecQCi, vecResi;

    for(int i = 0; i < SIZE - 3; i += 4) {   // use one loop variable
        vecPi = _mm_loadu_si128((__m128i *)&(pA[i]));
        vecCi = _mm_loadu_si128((__m128i *)&(pB[i]));
        vecQCi = _mm_mullo_epi32(vecQi,vecCi);
        vecResi = _mm_sub_epi32(vecPi,vecQCi);
        _mm_storeu_si128((__m128i *)&(pA[i]), vecResi);
    }

    //Compute remaining positions if SIZE % 4 != 0
    for(; i<SIZE ;i++)
        pA[i] -= q * pB[i];

}

Answer 3

正如 Paul 所说，每次数据访问的计算量相对较少，而且您的代码可能受 IO 限制。由于未对齐的存储/加载比对齐的存储/加载慢，因此您确实应该对齐数据。

您应该将 16 个字节与 SSE 对齐，这也是一个高速缓存行，（我认为）32 个字节与 AVX 对齐。如果您自己分配数据，只需使用_aligned_alloc。如果您使用std::vector，最简单的对齐方式是使用自定义分配器而不是std::allocator。这个分配器会调用_aligned_alloc 或类似的东西，而不是malloc/new。另见this question。

然后您可以切换到加载/存储的对齐指令。

另外，我不确定&((*A)->vector)[i]生成的代码是什么，最好使用本地指针来存储数据，但一定要注解__restrict

但在进行所有这些操作之前，请确保值得您花时间和承担维护负担。您可以使用oprofile for linux 或AMD's code analyst for windows 进行配置。