c++ - 如何指示编译器为 __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 的倍数。

我知道我可以切换到数组表示的结构，或者删除 packing pragma(代价是将结构的大小从 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;
}

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

Answer 1

在我看来，您应该使用标准的 C++ 结构(__m128i 不是)来编写您的数据结构。当您想使用不是标准 C++ 的内部函数时，您可以通过 _mm_loadu_ps 等内部函数“进入 SSE 世界”，然后使用 _mm_storeu_ps 等内部函数“离开 SSE 世界”回到标准 C++ 。不要依赖隐式 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 寄存器的效用函数，则不要在效用函数中使用显式或隐式加载/存储。将 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 引用你会得到一个错误

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

__m128 无论如何，MSVC 确实是一个 union 体。

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 不必加载 union 。

---

根据 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 的想法.