Оптимизация кода SSSS GCC

Эта почта тесно связана с другой, которую я опубликовал несколько дней назад. На этот раз я написал простой код, который просто добавляет пару массивов элементов, умножает результат на значения в другом массиве и сохраняет его в четвертом массиве, причем все переменные с двойной точностью с плавающей запятой печатаются.

Я сделал две версии этого кода: один с инструкциями SSE, используя вызовы и другой без них, а затем скомпилировал их с уровнем оптимизации gcc и -O0. Я пишу их ниже:

// SSE VERSION

#define N 10000
#define NTIMES 100000
#include <time.h>
#include <stdio.h>
#include <xmmintrin.h>
#include <pmmintrin.h>

double a[N] __attribute__((aligned(16)));
double b[N] __attribute__((aligned(16)));
double c[N] __attribute__((aligned(16)));
double r[N] __attribute__((aligned(16)));

int main(void){
  int i, times;
  for( times = 0; times < NTIMES; times++ ){
     for( i = 0; i <N; i+= 2){ 
        __m128d mm_a = _mm_load_pd( &a[i] );  
        _mm_prefetch( &a[i+4], _MM_HINT_T0 );
        __m128d mm_b = _mm_load_pd( &b[i] );  
        _mm_prefetch( &b[i+4] , _MM_HINT_T0 );
        __m128d mm_c = _mm_load_pd( &c[i] );
        _mm_prefetch( &c[i+4] , _MM_HINT_T0 );
        __m128d mm_r;
        mm_r = _mm_add_pd( mm_a, mm_b );
        mm_a = _mm_mul_pd( mm_r , mm_c );
        _mm_store_pd( &r[i], mm_a );
      }   
   }
 }

//NO SSE VERSION
//same definitions as before
int main(void){
  int i, times;
   for( times = 0; times < NTIMES; times++ ){
     for( i = 0; i < N; i++ ){
      r[i] = (a[i]+b[i])*c[i];
    }   
  }
}

При компиляции с помощью -O0 gcc использует регистры XMM/MMX и SSE, если не заданы параметры -mno-sse (и другие). Я проверил код сборки, сгенерированный для второго кода, и заметил, что он использует команды movsd, addd и mulsd. Поэтому он использует инструкции SSE, но только те, которые используют самую низкую часть регистров, если я не ошибаюсь. Код сборки, сгенерированный для первого кода C, использовал, как и ожидалось, инструкции addp и mulpd, хотя был создан довольно большой код сборки.

В любом случае, первый код должен получить, насколько мне известно, лучшую прибыль от SIMD-парадигмы, поскольку каждая итерация вычисляется двумя значениями результата. Тем не менее, второй код выполняет что-то вроде 25-процентного ускорения, чем первое. Я также сделал тест с единственными значениями точности и получал аналогичные результаты. Какая причина для этого?

Ответ 1

Вложение в GCC включено в -O3. Поэтому при -O0 вы видите только обычные скалярные инструкции SSE2 (movsd, addsd и т.д.). Используя GCC 4.6.1 и ваш второй пример:

#define N 10000
#define NTIMES 100000

double a[N] __attribute__ ((aligned (16)));
double b[N] __attribute__ ((aligned (16)));
double c[N] __attribute__ ((aligned (16)));
double r[N] __attribute__ ((aligned (16)));

int
main (void)
{
  int i, times;
  for (times = 0; times < NTIMES; times++)
    {
      for (i = 0; i < N; ++i)
        r[i] = (a[i] + b[i]) * c[i];
    }

  return 0;
}

и компиляция с помощью gcc -S -O3 -msse2 sse.c создает для внутреннего цикла следующие инструкции, что довольно хорошо:

.L3:
    movapd  a(%eax), %xmm0
    addpd   b(%eax), %xmm0
    mulpd   c(%eax), %xmm0
    movapd  %xmm0, r(%eax)
    addl    $16, %eax
    cmpl    $80000, %eax
    jne .L3

Как вы можете видеть, с включенной векторизацией GCC испускает код для выполнения параллельных итераций цикла два. Его можно улучшить, хотя - этот код использует более низкие 128 бит регистров SSE, но он может использовать полные 256-битные регистры YMM, включив кодировку AVX инструкций SSE (если они доступны на машине). Итак, компиляция той же программы с помощью gcc -S -O3 -msse2 -mavx sse.c дает для внутреннего цикла:

.L3:
    vmovapd a(%eax), %ymm0
    vaddpd  b(%eax), %ymm0, %ymm0
    vmulpd  c(%eax), %ymm0, %ymm0
    vmovapd %ymm0, r(%eax)
    addl    $32, %eax
    cmpl    $80000, %eax
    jne .L3

Обратите внимание, что v перед каждой инструкцией и что инструкции используют 256-битные регистры YMM, итерации исходных циклов четыре выполняются параллельно.

Ответ 2

Я хотел бы продлить chill answer и обратить ваше внимание на то, что GCC, похоже, не может делать то же самое умное использование инструкций AVX при итерации в обратном направлении.

Просто замените внутренний цикл в примере кода охлаждения следующим образом:

for (i = N-1; i >= 0; --i)
    r[i] = (a[i] + b[i]) * c[i];

GCC (4.8.4) с опциями -S -O3 -mavx производит:

.L5:
    vmovsd  a+79992(%rax), %xmm0
    subq    $8, %rax
    vaddsd  b+80000(%rax), %xmm0, %xmm0
    vmulsd  c+80000(%rax), %xmm0, %xmm0
    vmovsd  %xmm0, r+80000(%rax)
    cmpq    $-80000, %rax
    jne     .L5