Rozwijanie pętli w celu osiągnięcia maksymalnej przepustowości dzięki Ivy Bridge i Haswell

Obliczam osiem produktów dot na raz z AVX. W moim obecnym kodzie robię coś takiego (przed rozwinięciem):

Ivy-Bridge / Sandy-Bridge

__m256 areg0 = _mm256_set1_ps(a[m]);
for(int i=0; i<n; i++) {        
    __m256 breg0 = _mm256_load_ps(&b[8*i]);
    tmp0 = _mm256_add_ps(_mm256_mul_ps(arge0,breg0), tmp0); 
}

Haswell

__m256 areg0 = _mm256_set1_ps(a[m]);
for(int i=0; i<n; i++) {      
    __m256 breg0 = _mm256_load_ps(&b[8*i]);
    tmp0 = _mm256_fmadd_ps(arge0, breg0, tmp0);
}

Ile razy muszę rozwinąć pętlę dla każdego przypadku, aby zapewnić maksymalną przepustowość?

Dla Haswella używającego FMA3 myślę, że odpowiedź jest tutaj FLOPS na cykl dla sandy-bridge i haswell SSE2/AVX / AVX2. Muszę rozwinąć pętlę 10 razy.

Dla Ivy Mostek jest chyba 8. Oto moja logika. Dodanie AVX ma opóźnienie 3, a mnożenie opóźnienie 5. Ivy Bridge może wykonywać jedno mnożenie AVX i jedno dodawanie AVX w tym samym czasie przy użyciu różnych portów. Używając notacji m do mnożenia, a do dodawania i x do braku operacji, a także liczby do wskazania sumy częściowej (np. m5 oznacza mnożenie z 5. sumą częściową) mogę napisać:

port0:  m1  m2  m3  m4  m5  m6  m7  m8  m1  m2  m3  m4  m5  ... 
port1:   x   x   x   x   x  a1  a2  a3  a4  a5  a6  a7  a8  ...

Więc używając 8 sum częściowych po dziewięciu cyklach zegara (cztery z obciążenia i pięć z mnożenia) mogę złożyć jedno obciążenie AVX, jedno dodanie AVX i jedno mnożenie AVX w każdym cyklu zegara.

Myślę, że to oznacza, że niemożliwe jest osiągnięcie maksymalnej przepustowości dla tych zadań w trybie 32-bitowym w Ivy Bridge i Haswell, ponieważ tryb 32-bitowy ma tylko osiem rejestrów AVX?

Edit: w odniesieniu do bounty. Moje główne pytania nadal są aktualne. Chcę uzyskać maksymalną przepustowość Ivy Bridge lub Funkcje haswella powyżej, n mogą mieć dowolną wartość większą lub równą 64. Myślę, że można to zrobić tylko za pomocą rozwijania (osiem razy dla Ivy Bridge i 10 razy dla Haswell). Jeśli uważasz, że można to zrobić za pomocą innej metody, zobaczmy to. W pewnym sensie jest to odmiana Jak osiągnąć teoretyczne maksimum 4 flopów na cykl?. Ale zamiast tylko mnożenia i dodawania Szukam jednego obciążenia 256-bitowego (lub dwóch obciążeń 128-bitowych), jednego mnożenia AVX i jeden dodatek AVX w każdym cyklu zegara z Ivy Bridge lub dwoma ładunkami 256-bitowymi i dwiema instrukcjami FMA3 na cykl zegara.

Powinienem zwrócić uwagę, że kompilator może dać mylące wyniki różnica w wydajności między MSVC i GCC dla wysoce zoptymalizowanego kodu multplikacji macierzy

Obecna funkcja, której używam dla Ivy Bridge jest poniżej. To w zasadzie mnoży jeden rząd macierzy 64x64 {[5] } ze wszystkimi macierzami 64x64 b (uruchamiam tę funkcję 64 razy w każdym rzędzie a, aby uzyskać pełną macierz mnożyć w macierzy c).

#include <immintrin.h>
extern "C" void row_m64x64(const float *a, const float *b, float *c) {      
    const int vec_size = 8;
    const int n = 64;
    __m256 tmp0, tmp1, tmp2, tmp3, tmp4, tmp5, tmp6, tmp7;
    tmp0 = _mm256_loadu_ps(&c[0*vec_size]);
    tmp1 = _mm256_loadu_ps(&c[1*vec_size]);
    tmp2 = _mm256_loadu_ps(&c[2*vec_size]);
    tmp3 = _mm256_loadu_ps(&c[3*vec_size]);
    tmp4 = _mm256_loadu_ps(&c[4*vec_size]);
    tmp5 = _mm256_loadu_ps(&c[5*vec_size]);
    tmp6 = _mm256_loadu_ps(&c[6*vec_size]);
    tmp7 = _mm256_loadu_ps(&c[7*vec_size]);

    for(int i=0; i<n; i++) {
        __m256 areg0 = _mm256_set1_ps(a[i]);

        __m256 breg0 = _mm256_loadu_ps(&b[vec_size*(8*i + 0)]);
        tmp0 = _mm256_add_ps(_mm256_mul_ps(areg0,breg0), tmp0);    
        __m256 breg1 = _mm256_loadu_ps(&b[vec_size*(8*i + 1)]);
        tmp1 = _mm256_add_ps(_mm256_mul_ps(areg0,breg1), tmp1);
        __m256 breg2 = _mm256_loadu_ps(&b[vec_size*(8*i + 2)]);
        tmp2 = _mm256_add_ps(_mm256_mul_ps(areg0,breg2), tmp2);    
        __m256 breg3 = _mm256_loadu_ps(&b[vec_size*(8*i + 3)]);
        tmp3 = _mm256_add_ps(_mm256_mul_ps(areg0,breg3), tmp3);   
        __m256 breg4 = _mm256_loadu_ps(&b[vec_size*(8*i + 4)]);
        tmp4 = _mm256_add_ps(_mm256_mul_ps(areg0,breg4), tmp4);    
        __m256 breg5 = _mm256_loadu_ps(&b[vec_size*(8*i + 5)]);
        tmp5 = _mm256_add_ps(_mm256_mul_ps(areg0,breg5), tmp5);    
        __m256 breg6 = _mm256_loadu_ps(&b[vec_size*(8*i + 6)]);
        tmp6 = _mm256_add_ps(_mm256_mul_ps(areg0,breg6), tmp6);    
        __m256 breg7 = _mm256_loadu_ps(&b[vec_size*(8*i + 7)]);
        tmp7 = _mm256_add_ps(_mm256_mul_ps(areg0,breg7), tmp7);    
    }
    _mm256_storeu_ps(&c[0*vec_size], tmp0);
    _mm256_storeu_ps(&c[1*vec_size], tmp1);
    _mm256_storeu_ps(&c[2*vec_size], tmp2);
    _mm256_storeu_ps(&c[3*vec_size], tmp3);
    _mm256_storeu_ps(&c[4*vec_size], tmp4);
    _mm256_storeu_ps(&c[5*vec_size], tmp5);
    _mm256_storeu_ps(&c[6*vec_size], tmp6);
    _mm256_storeu_ps(&c[7*vec_size], tmp7);
}