Как указать компилятору генерировать невыровненные нагрузки для __m128

На мой взгляд, вы должны писать свои структуры данных, используя стандартные конструкции C ++ (из которых __m128i нет). Если вы хотите использовать встроенные функции, которые не являются стандартными C ++, вы «входите в мир SSE» через встроенные функции, такие как _mm_loadu_ps, и вы «покидаете мир SSE» обратно в стандартный C ++ с помощью встроенного компонента, такого как _mm_storeu_ps. Не полагайтесь на неявные загрузки и сохранения 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 исходной структуры, выполните

Foobar foo[4];

В этом случае, пока первый элемент выровнен, все остальные элементы выровнены.

Если вам нужны служебные функции, которые работают с регистрами SSE, не используйте явную или неявную загрузку / сохранение в служебной функции. Передайте константные ссылки на __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);
    }
}

Причина использования константной ссылки заключается в том, что MSVC не может передавать __m128 по значению. Без константной ссылки вы получите ошибку

ошибка 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;

предположительно MSVC не должен загружать объединение, когда служебные функции SSE встроены.

Основываясь на последнем обновлении кода 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);
}

Этот код основан на идеях из библиотеки векторных классов Агнера Фога.

У Clang есть -fmax-type-align. Если вы установите -fmax-type-align=8, то выровненные по 16 байтов инструкции не будут сгенерированы.

Вы можете попробовать изменить свою структуру на:

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

to:

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

Если вы используете автоматическую векторизацию или явную векторизацию на основе OpenMP4 / Cilk / pragmas, то вы можете заставить компилятор использовать невыровненные загрузки для векторизованного цикла, используя:

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

CDEC$ vector unaligned ; for Fortran

Это в первую очередь предназначено для контроля компромиссов между «выровненными, но очищенными» и «не очищенными, но невыровненными». Дополнительные сведения см. На странице https://software.intel.com/en-us/articles/utilizing-full-vectors

Насколько мне известно, это работает только для компиляторов Intel. Компиляторы Intel также имеют внутренний переключатель компиляции -mP2OPT_vec_alignment = 6, чтобы сделать то же самое для всего модуля компиляции.

Я не проверял, можно ли его эффективно применить к реализациям, в которых встроенные функции / сборки используются вместе с OpenMP / Cilk.