Подтвердить что ты не робот

Упаковка и деперемежение двух регистров __m256

У меня есть массив массивов с плавающей точкой (~ 20 cols x ~ 1M строк), из которых мне нужно извлечь два столбца за раз в два регистра __m256.

...a0.........b0......
...a1.........b1......
// ...
...a7.........b7......
// end first __m256

Наивный способ сделать это -

__m256i vindex = _mm256_setr_epi32(
    0,
    1 * stride,
    2 * stride,
    // ...
    7 * stride);
__m256 colA = _mm256_i32gather_ps(baseAddrColA, vindex, sizeof(float));
__m256 colB = _mm256_i32gather_ps(baseAddrColB, vindex, sizeof(float));

Однако мне было интересно узнать, могу ли я получить более высокую производительность, извлекая a0, b0, a1, b1, a2, b2, a3, b3 в один gather и a4, b4, ... a7, b7 в другой, потому что они ближе в памяти, а затем де-чередуют их. То есть:

// __m256   lo = a0 b0 a1 b1 a2 b2 a3 b3 // load proximal elements
// __m256   hi = a4 b4 a5 b5 a6 b6 a7 b7
// __m256 colA = a0 a1 a2 a3 a4 a5 a6 a7 // goal
// __m256 colB = b0 b1 b2 b3 b4 b5 b6 b7

Я не могу понять, как красиво перемежать lo и hi. Мне в основном нужна противоположность _mm256_unpacklo_ps. Самое лучшее, что я придумал, это что-то вроде:

__m256i idxA = _mm256_setr_epi32(0, 2, 4, 6, 1, 3, 5, 7);
__m256i idxB = _mm256_setr_epi32(1, 3, 5, 7, 0, 2, 4, 6);

__m256 permLA = _mm256_permutevar8x32_ps(lo, idxA);        // a0 a1 a2 a3 b0 b1 b2 b3
__m256 permHB = _mm256_permutevar8x32_ps(hi, idxB);        // b4 b5 b6 b7 a4 a5 a6 a7
__m256 colA = _mm256_blend_ps(permLA, permHB, 0b11110000); // a0 a1 a2 a3 a4 a5 a6 a7
__m256 colB = _mm256_setr_m128(
                          _mm256_extractf128_ps(permLA, 1), 
                          _mm256_castps256_ps128(permHB)); // b0 b1 b2 b3 b4 b5 b6 b7

Это 13 циклов. Есть ли лучший способ?

(Насколько мне известно, prefetch уже оптимизирует наивный подход как можно лучше, но, не имея этих знаний, я надеялся сравнить второй подход. Если кто-то уже знает, каков будет результат этого, пожалуйста, разделите. С помощью вышеупомянутого метода деинтерлейсинга он примерно на 8% медленнее, чем наивный подход.)

Изменить Даже без деинтерлейсинга метод "проксимального" сбора примерно на 6% медленнее, чем метод наивного метода постоянной шага. Я полагаю, что это означает, что этот шаблон доступа слишком сильно запутывает предварительную выборку оборудования, чтобы быть полезной оптимизацией.

4b9b3361

Ответ 1

// __m256   lo = a0 b0 a1 b1 a2 b2 a3 b3 // load proximal elements
// __m256   hi = a4 b4 a5 b5 a6 b6 a7 b7
// __m256 colA = a0 a1 a2 a3 a4 a5 a6 a7 // goal
// __m256 colB = b0 b1 b2 b3 b4 b5 b6 b7

Кажется, мы можем сделать эту перетасовку даже быстрее, чем мой оригинальный ответ:

void unpack_cols(__m256i lo, __m256i hi, __m256i& colA, __m256i& colB) {
    const __m256i mask = _mm256_setr_epi32(0, 2, 4, 6, 1, 3, 5, 7);
    // group cols crossing lanes: 
    // a0 a1 a2 a3 b0 b1 b2 b3
    // a4 a5 a6 a7 b4 b5 b6 b7
    auto lo_grouped = _mm256_permutevar8x32_epi32(lo, mask);
    auto hi_grouped = _mm256_permutevar8x32_epi32(hi, mask);

    // swap lanes: 
    // a0 a1 a2 a3 a4 a5 a6 a7
    // b0 b1 b2 b3 b4 b5 b6 b7
    colA = _mm256_permute2x128_si256(lo_grouped, hi_grouped, 0 | (2 << 4));
    colB = _mm256_permute2x128_si256(lo_grouped, hi_grouped, 1 | (3 << 4));
}

Хотя обе инструкции имеют задержку в 3 цикла на Haswell (см. Agner Fog), они имеют пропускную способность одного цикла. Это означает, что он имеет пропускную способность в 4 цикла и задержку в 8 циклов. Если у вас есть запасной регистр, который может содержать маску, это должно быть лучше. Выполнение только двух из них параллельно позволяет полностью скрыть свою задержку. См. godbolt и rextester.


Старый ответ, сохраненный для справки:

Самый быстрый способ для этого тасования:

void unpack_cols(__m256i lo, __m256i hi, __m256i& colA, __m256i& colB) {
    // group cols within lanes: 
    // a0 a1 b0 b1 a2 a3 b2 b3
    // a4 a5 b4 b5 a6 a7 b6 b7
    auto lo_shuffled = _mm256_shuffle_epi32(lo, _MM_SHUFFLE(3, 1, 2, 0));
    auto hi_shuffled = _mm256_shuffle_epi32(hi, _MM_SHUFFLE(3, 1, 2, 0));

    // unpack lo + hi a 64 bit
    // a0 a1 a4 a5 a2 a3 a6 a7
    // b0 b1 b4 b5 b2 b3 b6 b7
    auto colA_shuffled = _mm256_unpacklo_epi64(lo_shuffled, hi_shuffled);
    auto colB_shuffled = _mm256_unpackhi_epi64(lo_shuffled, hi_shuffled);

    // swap crossing lanes: 
    // a0 a1 a2 a3 a4 a5 a6 a7
    // b0 b1 b2 b3 b4 b5 b6 b7
    colA = _mm256_permute4x64_epi64(colA_shuffled, _MM_SHUFFLE(3, 1, 2, 0));
    colB = _mm256_permute4x64_epi64(colB_shuffled, _MM_SHUFFLE(3, 1, 2, 0));
}

Начиная с Haswell, это пропускная способность 6 циклов (к сожалению, шесть инструкций на порту 5). Согласно Agner Fog _mm256_permute4x64_epi64 имеет задержку в 3 цикла. Это означает, что unpack_cols имеет задержку 11 8 циклов.

Вы можете проверить код godbolt.org или проверить его на rextester, у которого есть поддержка AVX2, но, к сожалению, нет permalinks как godbolt.


Обратите внимание, что это также очень близко к проблеме, с которой я столкнулся, где я собрал 64-битные ints и нуждался в 32-разрядных и высоких 32-разрядных файлах.


Обратите внимание, что сборка производительности очень плоха в Хасуэлле, но в соответствии с Agner Fog Skylake значительно улучшила ее (~ 12 циклов до ~ 5). Тем не менее, перемещение вокруг таких простых шаблонов должно быть намного быстрее, чем сбор.

Ответ 2

Чтобы загрузить столбцы с 32-битным типом float, вы можете использовать intrinsics _mm256_setr_pd и _mm256_shuffle_ps (требуется 10 циклов):

#include <iostream>
#include <immintrin.h>

inline void Print(const __m256 & v)
{
    float b[8];
    _mm256_storeu_ps(b, v);
    for (int i = 0; i < 8; i++)
        std::cout << b[i] << " ";
    std::cout << std::endl;
}

int main()
{
    const size_t stride = 100;
    float m[stride * 8];
    for (size_t i = 0; i < stride*8; ++i)
        m[i] = (float)i;

    const size_t stride2 = stride / 2;
    double * p = (double*)m;

    __m256 ab0145 = _mm256_castpd_ps(_mm256_setr_pd(p[0 * stride2], p[1 * stride2], p[4 * stride2], p[5 * stride2]));
    __m256 ab2367 = _mm256_castpd_ps(_mm256_setr_pd(p[2 * stride2], p[3 * stride2], p[6 * stride2], p[7 * stride2]));

    __m256 a = _mm256_shuffle_ps(ab0145, ab2367, 0x88);
    __m256 b = _mm256_shuffle_ps(ab0145, ab2367, 0xDD);

    Print(a);
    Print(b);

    return 0;
}

Вывод:

0 100 200 300 400 500 600 700
1 101 201 301 401 501 601 701

Что касается производительности встроенного _mm256_i32gather_ps, я бы рекомендовал увидеть здесь.

Ответ 3

Я предполагаю, что a и b помещены в 0,10, затем от 1,11 до 9,19, если не chnge vindexm[], как вы хотите; Если вы хотите использовать команду на сборку:

//#includes
#define Distance 20 // number of columns.
float a[32][20]__attribute__(( aligned(32)))=                          {{1.01,1.02,1.03,1.04,1.05,1.06,1.07,1.08,1.09,1.10,1.11,1.12,1.13,1.14,1.15,1.16},
                                                                        {2.01,2.02,2.03,2.04,2.05,2.06,2.07,2.08,2.09,2.10,2.11,2.12,2.13,2.14,2.15,2.16},
                                                                        {3.01,3.02,3.03,3.04,3.05,3.06,3.07,3.08,3.09,3.10,3.11,3.12,3.13,3.14,3.15,3.16},
                                                                        {4.01,4.02,4.03,4.04,4.05,4.06,4.07,4.08,4.09,4.10,4.11,4.12,4.13,4.14,4.15,4.16},
                                                                        {5.01,5.02,5.03,5.04,5.05,5.06,5.07,5.08,5.09,5.10,5.11,5.12,5.13,5.14,5.15,5.16},
                                                                        {6.01,6.02,6.03,6.04,6.05,6.06,6.07,6.08,6.09,6.10,6.11,6.12,6.13,6.14,6.15,6.16},
                                                                        {7.01,7.02,7.03,7.04,7.05,7.06,7.07,7.08,7.09,7.10,7.11,7.12,7.13,7.14,7.15,7.16},
                                                                        {8.01,8.02,8.03,8.04,8.05,8.06,8.07,8.08,8.09,8.10,8.11,8.12,8.13,8.14,8.15,8.16},
                                                                        {9.01,9.02,9.03,9.04,9.05,9.06,9.07,9.08,9.09,9.10,9.11,9.12,9.13,7.14,9.15,9.16},
                                                                        {10.1,10.2,10.3,10.4,10.5,10.6,10.7,10.8,10.9,10.10,10.11,10.12,10.13,10.14,10.15,10.16},
                                                                        {11.1,11.2,11.3,11.4,11.5,11.6,11.7,11.8,11.9,11.10,11.11,11.12,11.13,11.14,11.15,11.16},
                                                                        {12.1,12.2,12.3,12.4,12.5,12.6,12.7,12.8,12.9,12.10,12.11,12.12,12.13,12.14,12.15,12.16},
                                                                        {13.1,13.2,13.3,13.4,13.5,13.6,13.7,13.8,13.9,13.10,13.11,13.12,13.13,13.14,13.15,13.16},
                                                                        {14.1,14.2,14.3,14.4,14.5,14.6,14.7,14.8,14.9,14.10,14.11,14.12,14.13,14.14,14.15,14.16},
                                                                        {15.1,15.2,15.3,15.4,15.5,15.6,15.7,15.8,15.9,15.10,15.11,15.12,15.13,15.14,15.15,15.16},
                                                                        {16.1,16.2,16.3,16.4,16.5,16.6,16.7,16.8,16.9,16.10,16.11,16.12,16.13,16.14,16.15,16.16}};
float tempps[8];
void printVecps(__m256 vec)
{
    _mm256_store_ps(&tempps[0], vec);
    printf(", [0]=%3.2f, [1]=%3.2f, [2]=%3.2f, [3]=%3.2f, [4]=%3.2f, [5]=%3.2f, [6]=%3.2f, [7]=%3.2f \n",
    tempps[0],tempps[1],tempps[2],tempps[3],tempps[4],tempps[5],tempps[6],tempps[7]) ;

}
int main() {

    __m256 vec1;
    int vindexm [8]={0, Distance/2, Distance, Distance + Distance/2, Distance*2, Distance*2 +Distance/2,  Distance*3, Distance*3 + Distance/2};
    __m256i vindex = _mm256_load_si256((__m256i *) &vindexm[0]);
    //loops
    vec1 = _mm256_i32gather_ps (&a[0][0],vindex, 4);//place it in your loop as you want
    printVecps(vec1);

    return 0;
}

out put is

[0]=1.01, [1]=1.11, [2]=2.01, [3]=2.11, [4]=3.01, [5]=3.11, [6]=4.01, [7]=4.11