如何指示编译器为 __m128 生成未对齐的加载

Question

我有一些代码可以使用 __m128 值。我在这些值上使用 x86-64 SSE 内在函数，我发现如果这些值在内存中未对齐，我会崩溃。这是由于我的编译器（在本例中为 clang）仅生成对齐的加载指令。

我能否指示我的编译器生成未对齐的加载，无论是全局加载还是针对某些值（可能带有某种注释）？

首先我有未对齐值的原因是我想节省内存。我有一个struct大致如下：

#pragma pack(push, 4)
struct Foobar {
    __m128 a;
    __m128 b;
    int c;
};
#pragma pack(pop)

然后我正在创建这些结构的数组。数组中的第二个元素从 36 字节开始，不是 16 的倍数。

我知道我可以切换到数组表示的结构，或者删除打包编译指示（代价是将结构的大小从 36 字节增加到 48 字节）；但我也知道现在未对齐的负载并不那么昂贵，我想先尝试一下。

更新以回答下面的一些评论：

我的实际代码更接近于此：

struct Vector4 {
    __m128 data;
    Vector4(__m128 v) : data(v) {}
};
struct Foobar {
    Vector4 a;
    Vector4 b;
    int c;
}

然后我有一些实用功能，例如：

inline Vector4 add( const Vector4& a, const Vector4 &b ) {
    return Vector4(_mm_add_ps(a.data, b.data));
}

inline Vector4 subtract( const Vector4& a, const Vector4& b ) {
    return Vector4(_mm_sub_ps(a.data, b.data));
}

// etc..

我经常结合使用这些实用程序。假例子：

Foobar myArray[1000];
myArray[i+1].b = sub(add(myArray[i].a, myArray[i].b), myArray[i+1].a);

在查看 "Z Bozon" 的回答时，我的代码实际上变成了：

struct Vector4 {
    float data[4];
};

inline Vector4 add( const Vector4& a, const Vector4 &b ) {
    Vector4 result;
    _mm_storeu_ps(result.data, _mm_add_ps(_mm_loadu_ps(a.data), _mm_loadu_ps(b.data)));
    return result;
}

我担心的是，当像上面那样组合使用实用函数时，生成的代码可能有冗余的 load/store 指令。事实证明这不是问题。我测试了我的编译器 (clang)，它已将它们全部删除。我会接受 Z Bozon 的回答。

Answer 1

您可以尝试将结构更改为：

#pragma pack(push, 4)
struct Foobar {
    int c;
    __m128 a;
    __m128 b;
};
#pragma pack(pop)

当然会有相同的大小，理论上应该强制 clang 生成未对齐的 loads/stores。

或者您可以使用显式未对齐 loads/stores，例如变化：

v = _mm_max_ps(myArray[300].a, myArray[301].a)

至：

__m128i v1 = _mm_loadu_ps((float *)&myArray[300].a);
__m128i v2 = _mm_loadu_ps((float *)&myArray[301].a);
v = _mm_max_ps(v1, v2);

Answer 2

如果您使用自动向量化或显式 OpenMP4/Cilk/pragmas-driven 向量化，则可以强制编译器对向量化循环使用未对齐加载，方法是：

#pragma vector unaligned //for C/C++ 

CDEC$ vector unaligned ; for Fortran

这主要是为了控制 "aligned but peeled" 与 "not peeled, but unaligned" 之间的权衡。在 https://software.intel.com/en-us/articles/utilizing-full-vectors

阅读更多详细信息

据我所知，这仅适用于英特尔编译器。英特尔编译器也有内部编译开关 -mP2OPT_vec_alignment=6 对整个编译单元做同样的事情。

我没有检查它是否可以有效地应用于 intrinsics/assembly 与 OpenMP/Cilk 一起使用的实现。

Answer 3

在我看来，您应该使用标准 C++ 结构（__m128i 不是）来编写数据结构。当你想使用不是标准 C++ 的内在函数时，你 "enter SSE world" 通过 _mm_loadu_ps 等内在函数，你 "leave SSE world" 回到标准 C++ 和 _mm_storeu_ps 等内在函数。不要依赖隐式 SSE 加载和存储。我在这样做时看到了太多错误。

在这种情况下你应该使用

struct Foobar {
    float a[4];
    float b[4];
    int c;
};

那你就可以了

Foobar foo[16];

在这种情况下，foo[1] 不会进行 16 字节对齐，但是当您想使用 SSE 并保留标准 C++ 时，请执行

__m128 a4 = _mm_loadu_ps(foo[1].a);
__m128 b4 = _mm_loadu_ps(foo[1].b);
__m128 max = _mm_max_ps(a4,b4);
_mm_storeu_ps(array, max);

然后回到标准 C++。

你可以考虑的另一件事是这个

struct Foobar {
    float a[16];
    float b[16];
    int c[4];
};

然后得到原始结构的 16 个数组

Foobar foo[4];

在这种情况下，只要第一个元素对齐，所有其他元素也对齐。

如果您想要作用于 SSE 寄存器的效用函数，请不要在效用函数中使用显式或隐式 load/stores。如果需要，将 const 引用传递给 __m128 和 return __m128。

//SSE utility function
static inline __m128 mulk_SSE(__m128 const &a, float k)
{
    return _mm_mul_ps(_mm_set1_ps(k),a);
}

//main function
void foo(float *x, float *y n) 
{
    for(int i=0; i<n; i+=4)
        __m128 t1 = _mm_loadu_ps(x[i]);
        __m128 t2 = mulk_SSE(x4,3.14159f);
        _mm_store_ps(&y[i], t2);
    }
}

使用 const 引用的原因是 MSVC 无法按值传递 __m128。没有 const 引用你会得到一个错误

error C2719: formal parameter with __declspec(align('16')) won't be aligned.

__m128 无论如何，MSVC 确实是一个联合。

typedef union __declspec(intrin_type) _CRT_ALIGN(16) __m128 {
     float               m128_f32[4];
     unsigned __int64    m128_u64[2];
     __int8              m128_i8[16];
     __int16             m128_i16[8];
     __int32             m128_i32[4];
     __int64             m128_i64[2];
     unsigned __int8     m128_u8[16];
     unsigned __int16    m128_u16[8];
     unsigned __int32    m128_u32[4];
 } __m128;

当 SSE 实用函数被内联时，大概 MSVC 不必加载联合。

根据 OP 的最新代码更新，我在此建议

#include <x86intrin.h>
struct Vector4 {
    __m128 data;
    Vector4() {
    }
    Vector4(__m128 const &v) {
        data = v;
    }
    Vector4 & load(float const *x) {
        data = _mm_loadu_ps(x);
        return *this;
    }
    void store(float *x) const {
        _mm_storeu_ps(x, data);
    }
    operator __m128() const {
        return data;
    }
};

static inline Vector4 operator + (Vector4 const & a, Vector4 const & b) {
    return _mm_add_ps(a, b);
}

static inline Vector4 operator - (Vector4 const & a, Vector4 const & b) {
    return _mm_sub_ps(a, b);
}

struct Foobar {
    float a[4];
    float b[4];
    int c;
};

int main(void)
{
    Foobar myArray[10];
    // note that myArray[0].a, myArray[0].b, and myArray[1].b should be      // initialized before doing the following 
    Vector4 a0 = Vector4().load(myArray[0].a);
    Vector4 b0 = Vector4().load(myArray[0].b);
    Vector4 a1 = Vector4().load(myArray[1].a);        
    (a0 + b0 - a1).store(myArray[1].b);
}

此代码基于 Agner Fog 的 Vector Class Library.

的想法

Answer 4

Clang 有 -fmax-type-align。如果设置 -fmax-type-align=8 则不会生成 16 字节对齐的指令。

如何指示编译器为 __m128 生成未对齐的加载

How to instruct compiler to generate unaligned loads for __m128

c++

sse

x86-64

simd

intrinsics