Реализация AVX mat4 inv медленнее, чем SSE

Question

Я реализовал обратную матрицу 4x4 в SSE2 и AVX. Оба быстрее, чем простая реализация. Но если включен AVX (-mavx), то реализация SSE2 выполняется быстрее, чем реализация AVX вручную. Кажется, компилятор делает мою реализацию SSE2 более дружественной к AVX: (

В моей реализации AVX меньше умножений, меньше сложений ... Поэтому я ожидаю, что AVX может быть быстрее SSE. Может быть, некоторые вторжения, такие как _mm256_permute2f128_ps, _mm256_permutevar_ps/_mm256_permute_ps, замедляют AVX? Я не пытаюсь загрузить регистр SSE / XMM в регистр AVX / YMM.

Как я могу сделать мою реализацию AVX быстрее, чем SSE?

Мой ЦП: Процессор Intel® Core ™ TM i7-3615QM @ 2,30 ГГц (Ivy Bridge)

Plain with -O3      : 0.045853 secs
SSE2  with -O3      : 0.026021 secs
SSE2  with -O3 -mavx: 0.024336 secs
AVX1  with -O3 -mavx: 0.031798 secs

Updated (See bottom of question) all have -O3 -mavx flags:
AVX1 (reduced div)  : 0.027666 secs
AVX1 (using rcp_ps) : 0.023205 secs
SSE2 (using rcp_ps) : 0.021969 secs

Исходная матрица:

Matrix (float4x4):
    |0.0714    -0.6589  0.7488  2.0000|
    |0.9446     0.2857  0.1613  4.0000|
    |-0.3202    0.6958  0.6429  6.0000|
    |0.0000     0.0000  0.0000  1.0000|

Тестовые коды:

start = clock();

for (int i = 0; i < 1000000; i++) {
  glm_mat4_inv_sse2(m, m);

  // glm_mat4_inv_avx(m, m);
  // glm_mat4_inv(m, m)
}

end   = clock();
total = (float)(end - start) / CLOCKS_PER_SEC;
printf("%f secs\n\n", total);

Реализация:

Библиотека: http://github.com/recp/cglm

SSE Impl: https://gist.github.com/recp/690025c955c2e69a91e3a60a13768dee

AVX Impl: https://gist.github.com/recp/8ccc5ad0d19f5516de55f9bf7b5045b2

Вывод реализации SSE2 (с использованием godbolt; опции -O3):

glm_mat4_inv_sse2:
        movaps  xmm8, XMMWORD PTR [rdi+32]
        movaps  xmm2, XMMWORD PTR [rdi+16]
        movaps  xmm5, XMMWORD PTR [rdi+48]
        movaps  xmm6, XMMWORD PTR [rdi]
        movaps  xmm4, xmm8
        movaps  xmm13, xmm8
        movaps  xmm11, xmm8
        shufps  xmm11, xmm2, 170
        shufps  xmm4, xmm5, 238
        movaps  xmm3, xmm11
        movaps  xmm1, xmm8
        pshufd  xmm12, xmm4, 127
        shufps  xmm13, xmm2, 255
        movaps  xmm0, xmm13
        movaps  xmm9, xmm8
        pshufd  xmm4, xmm4, 42
        shufps  xmm9, xmm2, 85
        shufps  xmm1, xmm5, 153
        movaps  xmm7, xmm9
        mulps   xmm0, xmm4
        pshufd  xmm10, xmm1, 42
        movaps  xmm1, xmm11
        shufps  xmm5, xmm8, 0
        mulps   xmm3, xmm12
        pshufd  xmm5, xmm5, 128
        mulps   xmm7, xmm12
        mulps   xmm1, xmm10
        subps   xmm3, xmm0
        movaps  xmm0, xmm13
        mulps   xmm0, xmm10
        mulps   xmm13, xmm5
        subps   xmm7, xmm0
        movaps  xmm0, xmm9
        mulps   xmm0, xmm4
        subps   xmm0, xmm1
        movaps  xmm1, xmm8
        movaps  xmm8, xmm11
        shufps  xmm1, xmm2, 0
        mulps   xmm8, xmm5
        movaps  xmm11, xmm7
        mulps   xmm4, xmm1
        mulps   xmm5, xmm9
        movaps  xmm9, xmm2
        mulps   xmm12, xmm1
        shufps  xmm9, xmm6, 85
        pshufd  xmm9, xmm9, 168
        mulps   xmm1, xmm10
        movaps  xmm10, xmm2
        shufps  xmm10, xmm6, 0
        pshufd  xmm10, xmm10, 168
        subps   xmm4, xmm8
        mulps   xmm7, xmm10
        movaps  xmm8, xmm2
        shufps  xmm2, xmm6, 255
        shufps  xmm8, xmm6, 170
        pshufd  xmm8, xmm8, 168
        pshufd  xmm2, xmm2, 168
        mulps   xmm11, xmm8
        subps   xmm12, xmm13
        movaps  xmm13, XMMWORD PTR .LC0[rip]
        subps   xmm1, xmm5
        movaps  xmm5, xmm3
        mulps   xmm5, xmm9
        mulps   xmm3, xmm10
        subps   xmm5, xmm11
        movaps  xmm11, xmm0
        mulps   xmm11, xmm2
        mulps   xmm0, xmm10
        addps   xmm5, xmm11
        movaps  xmm11, xmm12
        mulps   xmm11, xmm8
        mulps   xmm12, xmm9
        xorps   xmm5, xmm13
        subps   xmm3, xmm11
        movaps  xmm11, xmm4
        mulps   xmm4, xmm9
        subps   xmm7, xmm12
        mulps   xmm11, xmm2
        mulps   xmm2, xmm1
        mulps   xmm1, xmm8
        subps   xmm0, xmm4
        addps   xmm3, xmm11
        movaps  xmm11, XMMWORD PTR .LC1[rip]
        addps   xmm2, xmm7
        addps   xmm0, xmm1
        movaps  xmm1, xmm5
        xorps   xmm3, xmm11
        xorps   xmm2, xmm13
        shufps  xmm1, xmm3, 0
        xorps   xmm0, xmm11
        movaps  xmm4, xmm2
        shufps  xmm4, xmm0, 0
        shufps  xmm1, xmm4, 136
        mulps   xmm1, xmm6
        pshufd  xmm4, xmm1, 27
        addps   xmm1, xmm4
        pshufd  xmm4, xmm1, 65
        addps   xmm1, xmm4
        movaps  xmm4, XMMWORD PTR .LC2[rip]
        divps   xmm4, xmm1
        mulps   xmm5, xmm4
        mulps   xmm3, xmm4
        mulps   xmm2, xmm4
        mulps   xmm0, xmm4
        movaps  XMMWORD PTR [rsi], xmm5
        movaps  XMMWORD PTR [rsi+16], xmm3
        movaps  XMMWORD PTR [rsi+32], xmm2
        movaps  XMMWORD PTR [rsi+48], xmm0
        ret
.LC0:
        .long   0
        .long   2147483648
        .long   0
        .long   2147483648
.LC1:
        .long   2147483648
        .long   0
        .long   2147483648
        .long   0
.LC2:
        .long   1065353216
        .long   1065353216
        .long   1065353216
        .long   1065353216

Вывод реализации SSE2 (с поддержкой AVX) (с использованием godbolt; опции -O3 -mavx):

glm_mat4_inv_sse2:
        vmovaps xmm9, XMMWORD PTR [rdi+32]
        vmovaps xmm6, XMMWORD PTR [rdi+48]
        vmovaps xmm2, XMMWORD PTR [rdi+16]
        vmovaps xmm7, XMMWORD PTR [rdi]
        vshufps xmm5, xmm9, xmm6, 238
        vpshufd xmm13, xmm5, 127
        vpshufd xmm5, xmm5, 42
        vshufps xmm1, xmm9, xmm6, 153
        vshufps xmm11, xmm9, xmm2, 170
        vshufps xmm12, xmm9, xmm2, 255
        vmulps  xmm3, xmm11, xmm13
        vpshufd xmm1, xmm1, 42
        vmulps  xmm0, xmm12, xmm5
        vshufps xmm10, xmm9, xmm2, 85
        vshufps xmm6, xmm6, xmm9, 0
        vpshufd xmm6, xmm6, 128
        vmulps  xmm8, xmm10, xmm13
        vmulps  xmm4, xmm10, xmm5
        vsubps  xmm3, xmm3, xmm0
        vmulps  xmm0, xmm12, xmm1
        vsubps  xmm8, xmm8, xmm0
        vmulps  xmm0, xmm11, xmm1
        vsubps  xmm4, xmm4, xmm0
        vshufps xmm0, xmm9, xmm2, 0
        vmulps  xmm9, xmm12, xmm6
        vmulps  xmm13, xmm0, xmm13
        vmulps  xmm5, xmm0, xmm5
        vmulps  xmm0, xmm0, xmm1
        vsubps  xmm12, xmm13, xmm9
        vmulps  xmm9, xmm11, xmm6
        vmovaps xmm13, XMMWORD PTR .LC0[rip]
        vmulps  xmm6, xmm10, xmm6
        vshufps xmm10, xmm2, xmm7, 85
        vpshufd xmm10, xmm10, 168
        vsubps  xmm5, xmm5, xmm9
        vshufps xmm9, xmm2, xmm7, 170
        vpshufd xmm9, xmm9, 168
        vsubps  xmm1, xmm0, xmm6
        vmulps  xmm11, xmm8, xmm9
        vshufps xmm0, xmm2, xmm7, 0
        vshufps xmm2, xmm2, xmm7, 255
        vmulps  xmm6, xmm3, xmm10
        vpshufd xmm2, xmm2, 168
        vpshufd xmm0, xmm0, 168
        vmulps  xmm3, xmm3, xmm0
        vmulps  xmm8, xmm8, xmm0
        vmulps  xmm0, xmm4, xmm0
        vsubps  xmm6, xmm6, xmm11
        vmulps  xmm11, xmm4, xmm2
        vaddps  xmm6, xmm6, xmm11
        vmulps  xmm11, xmm12, xmm9
        vmulps  xmm12, xmm12, xmm10
        vxorps  xmm6, xmm6, xmm13
        vsubps  xmm3, xmm3, xmm11
        vmulps  xmm11, xmm5, xmm2
        vmulps  xmm5, xmm5, xmm10
        vsubps  xmm8, xmm8, xmm12
        vmulps  xmm2, xmm1, xmm2
        vmulps  xmm1, xmm1, xmm9
        vaddps  xmm3, xmm3, xmm11
        vmovaps xmm11, XMMWORD PTR .LC1[rip]
        vsubps  xmm0, xmm0, xmm5
        vaddps  xmm2, xmm8, xmm2
        vxorps  xmm3, xmm3, xmm11
        vaddps  xmm0, xmm0, xmm1
        vshufps xmm1, xmm6, xmm3, 0
        vxorps  xmm2, xmm2, xmm13
        vxorps  xmm0, xmm0, xmm11
        vshufps xmm4, xmm2, xmm0, 0
        vshufps xmm1, xmm1, xmm4, 136
        vmulps  xmm1, xmm1, xmm7
        vpshufd xmm4, xmm1, 27
        vaddps  xmm1, xmm1, xmm4
        vpshufd xmm4, xmm1, 65
        vaddps  xmm1, xmm1, xmm4
        vmovaps xmm4, XMMWORD PTR .LC2[rip]
        vdivps  xmm1, xmm4, xmm1
        vmulps  xmm6, xmm6, xmm1
        vmulps  xmm3, xmm3, xmm1
        vmulps  xmm2, xmm2, xmm1
        vmulps  xmm1, xmm0, xmm1
        vmovaps XMMWORD PTR [rsi], xmm6
        vmovaps XMMWORD PTR [rsi+16], xmm3
        vmovaps XMMWORD PTR [rsi+32], xmm2
        vmovaps XMMWORD PTR [rsi+48], xmm1
        ret
.LC0:
        .long   0
        .long   2147483648
        .long   0
        .long   2147483648
.LC1:
        .long   2147483648
        .long   0
        .long   2147483648
        .long   0
.LC2:
        .long   1065353216
        .long   1065353216
        .long   1065353216
        .long   1065353216

Вывод реализации AVX (с использованием godbolt; опции -O3 -mavx):

glm_mat4_inv_avx:
        vmovaps ymm3, YMMWORD PTR [rdi]
        vmovaps ymm1, YMMWORD PTR [rdi+32]
        vmovdqa ymm2, YMMWORD PTR .LC1[rip]
        vmovdqa ymm0, YMMWORD PTR .LC0[rip]
        vperm2f128      ymm6, ymm3, ymm3, 3
        vperm2f128      ymm5, ymm1, ymm1, 0
        vperm2f128      ymm1, ymm1, ymm1, 17
        vmovdqa ymm10, YMMWORD PTR .LC4[rip]
        vpermilps       ymm9, ymm5, ymm0
        vpermilps       ymm7, ymm1, ymm2
        vperm2f128      ymm8, ymm6, ymm6, 0
        vpermilps       ymm1, ymm1, ymm0
        vpermilps       ymm5, ymm5, ymm2
        vpermilps       ymm0, ymm8, ymm0
        vmulps  ymm4, ymm7, ymm9
        vpermilps       ymm8, ymm8, ymm2
        vpermilps       ymm11, ymm6, 1
        vmulps  ymm2, ymm5, ymm1
        vmulps  ymm7, ymm0, ymm7
        vmulps  ymm1, ymm8, ymm1
        vmulps  ymm0, ymm0, ymm5
        vmulps  ymm5, ymm8, ymm9
        vmovdqa ymm9, YMMWORD PTR .LC3[rip]
        vmovdqa ymm8, YMMWORD PTR .LC2[rip]
        vsubps  ymm4, ymm4, ymm2
        vsubps  ymm7, ymm7, ymm1
        vperm2f128      ymm2, ymm4, ymm4, 0
        vperm2f128      ymm4, ymm4, ymm4, 17
        vshufps ymm1, ymm2, ymm4, 77
        vpermilps       ymm1, ymm1, ymm9
        vsubps  ymm5, ymm0, ymm5
        vpermilps       ymm0, ymm2, ymm8
        vmulps  ymm0, ymm0, ymm11
        vperm2f128      ymm1, ymm1, ymm2, 0
        vshufps ymm2, ymm2, ymm4, 74
        vpermilps       ymm4, ymm6, 90
        vmulps  ymm1, ymm1, ymm4
        vpermilps       ymm2, ymm2, ymm10
        vpermilps       ymm6, ymm6, 191
        vmovaps ymm11, YMMWORD PTR .LC5[rip]
        vperm2f128      ymm2, ymm2, ymm2, 0
        vperm2f128      ymm4, ymm3, ymm3, 0
        vpermilps       ymm12, ymm4, YMMWORD PTR .LC7[rip]
        vmulps  ymm2, ymm2, ymm6
        vinsertf128     ymm6, ymm7, xmm5, 1
        vperm2f128      ymm5, ymm7, ymm5, 49
        vshufps ymm7, ymm6, ymm5, 77
        vpermilps       ymm9, ymm7, ymm9
        vsubps  ymm0, ymm0, ymm1
        vpermilps       ymm1, ymm4, YMMWORD PTR .LC6[rip]
        vpermilps       ymm4, ymm4, YMMWORD PTR .LC8[rip]
        vaddps  ymm2, ymm0, ymm2
        vpermilps       ymm0, ymm6, ymm8
        vshufps ymm6, ymm6, ymm5, 74
        vpermilps       ymm6, ymm6, ymm10
        vmulps  ymm1, ymm1, ymm0
        vmulps  ymm0, ymm12, ymm9
        vmulps  ymm6, ymm4, ymm6
        vxorps  ymm2, ymm2, ymm11
        vdpps   ymm3, ymm3, ymm2, 255
        vsubps  ymm0, ymm1, ymm0
        vdivps  ymm2, ymm2, ymm3
        vaddps  ymm0, ymm0, ymm6
        vxorps  ymm0, ymm0, ymm11
        vdivps  ymm0, ymm0, ymm3
        vperm2f128      ymm5, ymm2, ymm2, 3
        vshufps ymm1, ymm2, ymm5, 68
        vshufps ymm2, ymm2, ymm5, 238
        vperm2f128      ymm4, ymm0, ymm0, 3
        vshufps ymm6, ymm0, ymm4, 68
        vshufps ymm0, ymm0, ymm4, 238
        vshufps ymm3, ymm1, ymm6, 136
        vshufps ymm1, ymm1, ymm6, 221
        vinsertf128     ymm1, ymm3, xmm1, 1
        vshufps ymm3, ymm2, ymm0, 136
        vshufps ymm0, ymm2, ymm0, 221
        vinsertf128     ymm0, ymm3, xmm0, 1
        vmovaps YMMWORD PTR [rsi], ymm1
        vmovaps YMMWORD PTR [rsi+32], ymm0
        vzeroupper
        ret
.LC0:
        .long   2
        .long   1
        .long   1
        .long   0
        .long   0
        .long   0
        .long   0
        .long   0
.LC1:
        .long   3
        .long   3
        .long   2
        .long   3
        .long   2
        .long   1
        .long   1
        .long   1
.LC2:
        .long   0
        .long   0
        .long   1
        .long   2
        .long   0
        .long   0
        .long   1
        .long   2
.LC3:
        .long   0
        .long   1
        .long   1
        .long   2
        .long   0
        .long   1
        .long   1
        .long   2
.LC4:
        .long   0
        .long   2
        .long   3
        .long   3
        .long   0
        .long   2
        .long   3
        .long   3
.LC5:
        .long   0
        .long   2147483648
        .long   0
        .long   2147483648
        .long   2147483648
        .long   0
        .long   2147483648
        .long   0
.LC6:
        .long   1
        .long   0
        .long   0
        .long   0
        .long   1
        .long   0
        .long   0
        .long   0
.LC7:
        .long   2
        .long   2
        .long   1
        .long   1
        .long   2
        .long   2
        .long   1
        .long   1
.LC8:
        .long   3
        .long   3
        .long   3
        .long   2
        .long   3
        .long   3
        .long   3
        .long   2

EDIT

Я использую Xcode (Версия 10.0 (10A255)) на macOS (на MacBook Pro (Retina, середина 2012 г.) 15 ') для создания и запуска тестов с опцией оптимизации -O3. Он компилирует тестовые коды с помощью clang. Я использовал GCC 8.2 в Godbolt для просмотра ASM (извините за это), но вывод сборки кажется похожим.

Я был включен shuffd, включив опцию cglm: CGLM_USE_INT_DOMAIN. Я забыл отключить его при просмотре asm.

#ifdef CGLM_USE_INT_DOMAIN
#  define glmm_shuff1(xmm, z, y, x, w)                                        \
     _mm_castsi128_ps(_mm_shuffle_epi32(_mm_castps_si128(xmm),                \
                                        _MM_SHUFFLE(z, y, x, w)))
#else
#  define glmm_shuff1(xmm, z, y, x, w)                                        \
     _mm_shuffle_ps(xmm, xmm, _MM_SHUFFLE(z, y, x, w))
#endif

Всего тестовых кодов (кроме заголовков):

#include <cglm/cglm.h>

#include <sys/time.h>
#include <time.h>

int
main(int argc, const char * argv[]) {
  CGLM_ALIGN(32) mat4 m = GLM_MAT4_IDENTITY_INIT;

  double start, end, total;

  /* generate invertible matrix */
  glm_translate(m, (vec3){1,2,3});
  glm_rotate(m, M_PI_2, (vec3){1,2,3});
  glm_translate(m, (vec3){1,2,3});

  glm_mat4_print(m, stderr);

  start = clock();

  for (int i = 0; i < 1000000; i++) {
    glm_mat4_inv_sse2(m, m);

    // glm_mat4_inv_avx(m, m);
    // glm_mat4_inv(m, m);
  }

  end   = clock();
  total = (float)(end - start) / CLOCKS_PER_SEC;

  printf("%f secs\n\n", total);

  glm_mat4_print(m, stderr);
}

РЕДАКТИРОВАТЬ 2:

Я уменьшил одно деление с помощью умножения ( 1 set_ps + 1 div_ps + 2 mul_ps кажется лучше, чем 2 div_ps ):

Старая версия:

r1 = _mm256_div_ps(r1, y4);
r2 = _mm256_div_ps(r2, y4);

Новая версия (версия SSE2 использовалась следующим образом):

y5 = _mm256_div_ps(_mm256_set1_ps(1.0f), y4);
r1 = _mm256_mul_ps(r1, y5);
r2 = _mm256_mul_ps(r2, y5);

Новая версия (Быстрая версия):

y5 = _mm256_rcp_ps(y4);
r1 = _mm256_mul_ps(r1, y5);
r2 = _mm256_mul_ps(r2, y5);

Теперь это лучше, чем раньше, но все же не быстрее, чем SSE на процессоре Ivy Bridge. Я обновил результаты теста.

Answer 1

Ваш процессор - Intel IvyBridge.

Sandybridge / IvyBridge имеет мультивыноску по часам и увеличивает пропускную способность на разных портах, чтобы они не конкурировали друг с другом.

Но это только 1 пропускная способность на тактовую частоту для 256-битных тасов и всех тасов FP (даже 128-битных shufps). Однако он имеет пропускную способность 2 на такт для целочисленных перемешиваний, и я замечаю, что ваш компилятор использует pshufd как копирование и перемешивание между инструкциями FP. Это хороший результат при компиляции для SSE2 особенно в тех случаях, когда кодировка VEX недоступна (поэтому она сохраняет movaps путем замены movaps xmm0, xmm1 / shufps xmm0, xmm0, 65 или чего-либо еще.) Ваш компилятор делает это, даже когда AVX доступен, поэтому он может использовали vshufps xmm0, xmm1,xmm1, 65, но он либо умно выбрал vpshufd по микроархитектурным причинам, либо ему повезло, либо его модель эвристики / стоимости обучения была разработана с учетом этого. (Я подозреваю, что это был лязг, но вы не сказали в вопросе и не показали источник C, с которого вы собрали).

В Haswell и более поздних версиях (которые поддерживают AVX2 и, следовательно, 256-битные версии каждого целочисленного перемешивания), все перемешивания могут выполняться только на порту 5. Но в IvB, где поддерживается только AVX1, только FP-перемешивания, которые достигают 256 биты. Целочисленные тасовки всегда только 128 бит и могут работать на порте 1 или 5, потому что на обоих этих портах имеются 128-битные исполнительные блоки тасования. (https://agner.org/optimize/)

---

Я не смотрел на asm в мельчайших деталях, потому что он длинный, но если вам потребуется больше тасовок для экономии при сложении / умножении с использованием более широких векторов, это будет медленнее.

Кроме того, поскольку все ваши тасовки становятся тасованиями FP, поэтому они работают только на 5-м порту, не используя преимущества порта 1. Я подозреваю, что тасуется так много, что это узкое место по сравнению с портом 0 (умножение FP) или портом 1 ( FP добавить).

Кстати, Haswell и более поздние имеют два блока FMA, по одному на p0 и p1, поэтому умножение имеет удвоенную пропускную способность. Skylake и более поздние версии FP также добавляют эти модули FMA, так что они имеют по 2 на тактовую пропускную способность. (И если вы можете с пользой использовать настоящие инструкции FMA, вы можете выполнить вдвое больше работы.)

Кроме того, ваш бенчмарк тестирует задержку, а не пропускную способность, потому что один и тот же m является входом и выходом. Однако может быть достаточно параллелизма на уровне команд, чтобы просто ограничить пропускную способность при перемешивании.

Перекрестные перестановки, такие как vperm2f128 и vinsertf128, имеют задержку в 2 цикла на IvB по сравнению с перестановками в дорожке (включая все 128-битовые перемешивания), которые имеют задержку только в один цикл. В руководствах Intel указано другое число, IIRC, но 2 цикла - это то, что фактические измерения Agner Fog нашли на практике в цепочке зависимостей. (Это, вероятно, 1 цикл + какая-то задержка обхода). На Haswell и позже перестановки переулка пересекаются с 3 циклами. Почему некоторые задержки Haswell AVX объявлены Intel в 3 раза медленнее, чем Sandy Bridge?

Также связано с этим: Дают ли 128-битные операции перекрестных линий в AVX512 более высокую производительность? Вы можете иногда уменьшить количество перетасовок с невыровненной нагрузкой, которая разрезает на 128-битные половины в полезной точке, а затем используйте в переулках переулок. Это потенциально полезно для AVX1, поскольку в нем отсутствуют vpermps или другие тасовки, пересекающие полосу, с зернистостью менее 128 бит.