处理双精度数组的未对齐部分，将其余部分矢量化

Question

我正在生成 sse/avx 指令，目前我必须使用未对齐的加载和存储。我对浮点/双精度数组进行操作，我永远不会知道它是否会对齐。因此，在对其进行矢量化之前，我希望有一个前循环和可能的后循环，它负责处理未对齐的部分。然后主矢量化循环在对齐的部分上运行。

但是我如何确定数组何时对齐？我可以检查指针值吗？前循环应该什么时候停止，后循环应该什么时候开始？

这是我的简单代码示例：

void func(double * in, double * out, unsigned int size){
    for( as long as in unaligned part ){
        out[i] = do_something_with_array(in[i])
    }
    for( as long as aligned ){
        awesome avx code that loads operates and stores 4 doubles
    }
    for( remaining part of array ){
        out[i] = do_something_with_array(in[i])
    }
 }

编辑： 我一直在考虑。从理论上讲，指向第 i 个元素的指针应该可以被 2、4、16、32 整除（类似于 &a[i]%16==0）（取决于它是否为 double 以及它是 sse 还是 avx）。所以第一个循环应该覆盖不可分割的元素。

实际上我会尝试编译器编译指示和标志，看看编译器会产生什么。如果没有人给出好的答案，我会在周末发布我的解决方案（如果有的话）。

Answer 1

这里有一些示例 C 代码，可以满足您的需求

#include <stdio.h>
#include <x86intrin.h>
#include <inttypes.h>

#define ALIGN 32
#define SIMD_WIDTH (ALIGN/sizeof(double))

int main(void) {
    int n = 17;
    int c = 1;
    double* p = _mm_malloc((n+c) * sizeof *p, ALIGN);
    double* p1 = p+c;
    for(int i=0; i<n; i++) p1[i] = 1.0*i;
    double* p2 = (double*)((uintptr_t)(p1+SIMD_WIDTH-1)&-ALIGN);
    double* p3 = (double*)((uintptr_t)(p1+n)&-ALIGN);
    if(p2>p3) p2 = p3;

    printf("%p %p %p %p\n", p1, p2, p3, p1+n);
    double *t;
    for(t=p1; t<p2; t+=1) {
        printf("a %p %f\n", t, *t);
    }
    puts("");
    for(;t<p3; t+=SIMD_WIDTH) {
        printf("b %p ", t);
        for(int i=0; i<SIMD_WIDTH; i++) printf("%f ", *(t+i));
        puts("");
    }
    puts("");
    for(;t<p1+n; t+=1) {
        printf("c %p %f\n", t, *t);
    }  
}

这会生成一个 32 字节对齐的缓冲区，然后将其大小偏移一倍，因此它不再是 32 字节对齐的。它循环标量值直到达到 32 字节对齐，循环遍历 32 字节对齐的值，然后最后以另一个标量循环结束任何不是 SIMD 宽度倍数的剩余值。

---

我认为这种优化只对 Nehalem 之前的 Intel x86 处理器真正有意义。由于 Nehalem，未对齐的加载和存储的延迟和吞吐量与对齐的加载和存储相同。此外，由于 Nehalem，高速缓存行拆分的成本很小。

SSE 有一个微妙的点，因为 Nehalem 在未对齐的加载和存储中不能与其他操作折叠。因此，自 Nehalem 以来，对齐的加载和存储并没有被 SSE 淘汰。因此，原则上，即使使用 Nehalem，这种优化也会产生影响，但在实践中，我认为很少有这种情况会发生。

但是，对于 AVX，未对齐的加载和存储可以折叠，因此对齐的加载和存储指令已过时。

---

I looked into this with GCC, MSVC, and Clang。 GCC如果它不能假设一个指针是对齐的，例如16 字节的 SSE 然后它将生成类似于上述代码的代码以达到 16 字节对齐以避免向量化时缓存行拆分。

Clang 和 MSVC 不这样做，因此它们会受到缓存行拆分的影响。但是，执行此操作的额外代码成本弥补了缓存行拆分的成本，这可能解释了为什么 Clang 和 MSVC 不担心它。

唯一的例外是在 Nahalem 之前。在这种情况下，当指针未对齐时，GCC 比 Clang 和 MSVC 快得多。如果指针是对齐的并且 Clang 知道它，那么它将使用对齐的加载和存储，并且像 GCC 一样快速。 MSVC 向量化仍然使用未对齐的存储和加载，因此即使指针是 16 字节对齐的，在 Nahalem 之前也很慢。

---

这是一个我认为使用指针差异更清晰的版本

#include <stdio.h>
#include <x86intrin.h>
#include <inttypes.h>

#define ALIGN 32
#define SIMD_WIDTH (ALIGN/sizeof(double))

int main(void) {
    int n = 17, c =1;

    double* p = _mm_malloc((n+c) * sizeof *p, ALIGN);
    double* p1 = p+c;
    for(int i=0; i<n; i++) p1[i] = 1.0*i;
    double* p2 = (double*)((uintptr_t)(p1+SIMD_WIDTH-1)&-ALIGN);
    double* p3 = (double*)((uintptr_t)(p1+n)&-ALIGN);
    int n1 = p2-p1, n2 = p3-p2;
    if(n1>n2) n1=n2;
    printf("%d %d %d\n", n1, n2, n);

    int i;
    for(i=0; i<n1; i++) {
        printf("a %p %f\n", &p1[i], p1[i]);
    }
    puts("");
    for(;i<n2; i+=SIMD_WIDTH) {
        printf("b %p ", &p1[i]);
        for(int j=0; j<SIMD_WIDTH; j++) printf("%f ", p1[i+j]);
        puts("");
    }
    puts("");
    for(;i<n; i++) {
        printf("c %p %f\n", &p1[i], p1[i]);
    }  
}