如何指示编译器为__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;
}

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

Answer 1

在我看来，您应该使用标准 C++ 结构（实际上__m128i不是）来编写数据结构。当您想要使用非标准 C++ 的内在函数时，您可以通过诸如 之类的内在函数“进入 SSE 世界”，_mm_loadu_ps并且可以使用诸如 之类的内在函数“离开 SSE 世界”回到标准 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 寄存器的实用程序函数，则不要在实用程序函数中使用显式或隐式加载/存储。如果需要，传递 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 不必加载联合。

根据 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 的矢量类库的想法。