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

【问题标题】：How to instruct compiler to generate unaligned loads for __m128如何指示编译器为 __m128 生成未对齐的负载
【发布时间】：2016-02-26 15:24:11
【问题描述】：

我有一些适用于__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 字节为代价）；但我也知道现在未对齐的负载并没有那么昂贵，我想先尝试一下。

更新以回答以下一些 cmets：

我的实际代码更接近这个：

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;
}

我担心的是，当上述实用程序函数组合使用时，生成的代码可能具有冗余的加载/存储指令。事实证明这不是问题。我测试了我的编译器（clang），它已将它们全部删除。我会接受 Z Bozon 的回答。

【问题讨论】：

不要在你的结构中使用__m128。使用例如 float a[4] 并使用 _mm_loadu_ps 和 _mm_storeu_ps 显式执行加载和存储。
听起来 OP 不仅使用显式内在函数，而且在某些情况下由于自动矢量化而获得由 clang 生成的 SIMD 代码？
@PaulR，如果是这种情况，那么 OP 应该将该信息添加到他的问题中。
是的，很难说，但这是我对 OP 第一段的解释。希望他稍后会过来澄清一下。
我认为大多数编译器会为获取__m128 变量生成对齐的负载，因为这种数据类型在 C 语言中定义了 16 字节对齐。这意味着除非您专门模拟您的编译器，否则它将确保 __m128 类型的值正确对齐。您强制编译器使其未对齐，这可能违反规则。我相信像 Z boson 所建议的那样使用_mm_storeu_ps 是在这种情况下唯一可靠的解决方案。

标签： c++ x86-64 sse simd intrinsics

【解决方案1】：

在我看来，您应该使用标准 C++ 结构（__m128i 不是）来编写数据结构。当您想使用非标准 C++ 的内在函数时，您可以通过 _mm_loadu_ps 等内在函数“进入 SSE 世界”，然后使用 _mm_storeu_ps 等内在函数“离开 SSE 世界”回到标准 C++。不要依赖隐式 SSE 加载和存储。我在 SO 上看到了太多错误。

在这种情况下你应该使用

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个数组的原始struct做

Foobar foo[4];

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

如果您想要作用于 SSE 寄存器的实用程序函数，则不要在实用程序函数中使用显式或隐式加载/存储。如果需要，将 const 引用传递给 __m128 并返回 __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 引用，你会得到一个错误

错误 C2719：带有 __declspec(align('16')) 的形参不会对齐。

__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 可能不必加载联合。

根据 OPs 的最新代码更新，这是我的建议

#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 的想法。

【讨论】：

感谢您写得很好的回复。这可能是我在上面评论中提出的问题的重复，但我想澄清一点。如果我使用你建议的方法，并且有几个实用功能，每个都以这种方式“进入”和“离开”SSE 世界。当我链接这些函数（并假设它们被内联）时，编译器通常会足够聪明以删除冗余的 storeu/loadu 操作吗？或者，我是否会发现自己必须编写“预先组合”的实用函数来连续执行几件事，同时只进出 SSE 世界一次？
@pauldoo，你能添加一个例子来说明你的问题吗？
@pauldoo，一旦你用数据填充了 SSE 寄存器，你就可以将它传递给一个函数，例如__m128 foo(__m128 const &a)。使用 const 引用让 MSVC 满意。
@pauldoo，我在答案中添加了一些文本，希望能解决您的评论。
我已对我的原始问题进行了澄清，并接受了您的回答。

【解决方案2】：

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

【讨论】：

【解决方案3】：

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

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

当然，这将具有相同的大小，并且理论上应该强制 clang 生成未对齐的加载/存储。

或者，您可以使用显式未对齐的加载/存储，例如改变：

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);

【讨论】：

对于您的替代建议，OP 不妨使用float a[4]。
是的 - 我只是为当前的结构定义添加了一个插图，但切换到浮点数组会更有意义，这样也可以摆脱丑陋的演员表。

【解决方案4】：

如果您使用自动矢量化或显式 OpenMP4/Cilk/pragmas 驱动的矢量化，则可以强制编译器使用未对齐的负载进行矢量化循环：

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

CDEC$ vector unaligned ; for Fortran

这主要是为了控制“对齐但剥离”与“未剥离但未对齐”之间的权衡。阅读更多详情https://software.intel.com/en-us/articles/utilizing-full-vectors

据我所知，这只适用于英特尔编译器。英特尔编译器还具有内部编译开关 -mP2OPT_vec_alignment=6 以对整个编译单元执行相同的操作。

我没有检查它是否可以有效地应用于内在函数/程序集与 OpenMP/Cilk 一起使用的实现。

【讨论】：