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世界＆＃34;通过_mm_loadu_ps这样的内在函数，你和＃34;离开SSE世界＆＃34;回到标准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];
};

然后获取原始struct的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的正式参数（对齐（＆＃39; 16＆＃39;））不会被对齐。

无论如何，

__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 2

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

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

Answer 4

如果使用自动向量化或显式OpenMP4 / Cilk / pragma驱动的向量化，则可以使用以下命令强制编译器对矢量化循环使用未对齐的加载：

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

CDEC$ vector unaligned ; for Fortran

这主要是为了控制＆＃34;对齐但去皮＆＃34;之间的权衡。 vs.＆＃34;没有去皮，但未对齐＆＃34;。请在https://software.intel.com/en-us/articles/utilizing-full-vectors

了解详情

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

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

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

4 个答案: