Когда компилятор переупорядочивает инструкции AVX на Sandy, влияет ли это на производительность?

Пожалуйста, не говорите, что это преждевременная микрооптимизация. Я хочу понять, насколько это возможно, учитывая мои ограниченные знания, как работает описанная функция и сборка SB, и убедиться, что мой код использует эту архитектурную особенность. Спасибо за понимание.

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

Мне нужно оптимизировать некоторый код для процессора Sandy Bridge (это требование). Теперь я знаю, что он может выполнять одно умножение AVX и одно сложение AVX за цикл, и прочитал эту статью:

http://research.colfaxinternational.com/file.axd?file=2012%2F7%2FColfax_CPI.pdf

который показывает, как это можно сделать на C++. Итак, проблема в том, что мой код не будет автоматически векторизован с помощью компилятора Intel (что является еще одним требованием для задачи), поэтому я решил реализовать его вручную, используя такие встроенные функции:

__sum1 = _mm256_setzero_pd();
__sum2 = _mm256_setzero_pd();
__sum3 = _mm256_setzero_pd();
sum = 0;
for(kk = k; kk < k + BS && kk < aW; kk+=12)
{
    const double *a_addr = &A[i * aW + kk];
    const double *b_addr = &newB[jj * aW + kk];
    __aa1 = _mm256_load_pd((a_addr));
    __bb1 = _mm256_load_pd((b_addr));
    __sum1 = _mm256_add_pd(__sum1, _mm256_mul_pd(__aa1, __bb1));

    __aa2 = _mm256_load_pd((a_addr + 4));
    __bb2 = _mm256_load_pd((b_addr + 4));
    __sum2 = _mm256_add_pd(__sum2, _mm256_mul_pd(__aa2, __bb2));

    __aa3 = _mm256_load_pd((a_addr + 8));
    __bb3 = _mm256_load_pd((b_addr + 8));
    __sum3 = _mm256_add_pd(__sum3, _mm256_mul_pd(__aa3, __bb3));
}
__sum1 = _mm256_add_pd(__sum1, _mm256_add_pd(__sum2, __sum3));
_mm256_store_pd(&vsum[0], __sum1);

Причина, по которой я вручную разворачиваю цикл, объясняется здесь:

Развертывание цикла для достижения максимальной пропускной способности с Ivy Bridge и Haswell

Говорят, вам нужно развернуться в 3 раза, чтобы добиться наилучшей производительности на Сэнди. Мое наивное тестирование подтверждает, что это действительно работает лучше, чем без развертывания или 4-кратного развертывания.

Итак, вот в чем проблема. Компилятор icl из Intel Parallel Studio 15 генерирует это:

    $LN149:
            movsxd    r14, r14d                                     ;78.49
    $LN150:
            vmovupd   ymm3, YMMWORD PTR [r11+r14*8]                 ;80.48
    $LN151:
            vmovupd   ymm5, YMMWORD PTR [32+r11+r14*8]              ;84.49
    $LN152:
            vmulpd    ymm4, ymm3, YMMWORD PTR [r8+r14*8]            ;82.56
    $LN153:
            vmovupd   ymm3, YMMWORD PTR [64+r11+r14*8]              ;88.49
    $LN154:
            vmulpd    ymm15, ymm5, YMMWORD PTR [32+r8+r14*8]        ;86.56
    $LN155:
            vaddpd    ymm2, ymm2, ymm4                              ;82.34
    $LN156:
            vmulpd    ymm4, ymm3, YMMWORD PTR [64+r8+r14*8]         ;90.56
    $LN157:
            vaddpd    ymm0, ymm0, ymm15                             ;86.34
    $LN158:
            vaddpd    ymm1, ymm1, ymm4                              ;90.34
    $LN159:
            add       r14d, 12                                      ;76.57
    $LN160:
            cmp       r14d, ebx                                     ;76.42
    $LN161:
            jb        .B1.19        ; Prob 82%                      ;76.42

Для меня это выглядит как беспорядок, где нарушен правильный порядок (добавьте рядом с умножением, необходимым для использования удобной функции SB).

Вопрос:

• Будет ли этот ассемблерный код использовать функцию Sandy Bridge, о которой я говорю?

• Если нет, что мне нужно сделать, чтобы использовать эту функцию и предотвратить такое «запутывание» кода?

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