C++: tajemniczo ogromne przyspieszenie od posiadania jednego operanda w rejestrze

Próbowałem uzyskać wyobrażenie o wpływie posiadania tablicy w pamięci podręcznej L1 W porównaniu z pamięcią, synchronizując procedurę, która skaluje i sumuje elementy tablicy za pomocą następującego kodu (jestem świadomy, że powinienem po prostu skalować wynik przez 'a' na końcu; chodzi o to, aby zarówno mnożenie, jak i dodawanie w pętli - jak dotąd kompilator nie domyślił się, aby uwzględnić 'a'): {]}

double sum(double a,double* X,int size)
{
    double total = 0.0;
    for(int i = 0;  i < size; ++i)
    {
        total += a*X[i];
    }
    return total;
}

#define KB 1024
int main()
{
    //Approximately half the L1 cache size of my machine
    int operand_size = (32*KB)/(sizeof(double)*2);
    printf("Operand size: %d\n", operand_size);
    double* X = new double[operand_size];
    fill(X,operand_size);

    double seconds = timer();
    double result;
    int n_iterations = 100000;
    for(int i = 0; i < n_iterations; ++i)
    {
        result = sum(3.5,X,operand_size);
        //result += rand();  
    }
    seconds = timer() - seconds; 

    double mflops = 2e-6*double(n_iterations*operand_size)/seconds;
    printf("Vector size %d: mflops=%.1f, result=%.1f\n",operand_size,mflops,result);
    return 0;
}

Zauważ, że procedury timer() i fill() nie są uwzględniane dla zwięzłości; ich pełne źródło może znajdziesz tutaj, jeśli chcesz uruchomić kod:

Http://codepad.org/agPWItZS

Operand size: 2048
Vector size 2048: mflops=588.8, result=-67.8

Jest to wydajność całkowicie niebuforowana, pomimo faktu, że wszystkie elementy x powinny być przechowywane w pamięci podręcznej między iteracjami pętli. Patrząc na kod assembly wygenerowany przez:

g++ -O3 -S -fno-asynchronous-unwind-tables register_opt_example.cpp

Zauważam jedną dziwność w pętli funkcji sum:

L55:
    movsd   (%r12,%rax,8), %xmm0
    mulsd   %xmm1, %xmm0
    addsd   -72(%rbp), %xmm0
    movsd   %xmm0, -72(%rbp)
    incq    %rax
    cmpq    $2048, %rax
    jne L55

Instrukcja:

    addsd   -72(%rbp), %xmm0
    movsd   %xmm0, -72(%rbp)

Wskaż, że jest zapisanie wartości "total" w sum () na stosie oraz odczyt i zapis przy każdej iteracji pętli. Zmodyfikowałem zespół tak, aby ten operand był przechowywany w rejestrze a:

...
addsd   %xmm0, %xmm3
...

Ta mała zmiana tworzy ogromny wzrost wydajności:

Operand size: 2048
Vector size 2048: mflops=1958.9, result=-67.8

Tl; dr Moje pytanie brzmi: dlaczego zastąpienie dostępu do pojedynczej lokalizacji pamięci rejestrem przyspiesza kod tak bardzo, biorąc pod uwagę, że pojedyncza lokalizacja powinna być przechowywana w pamięci podręcznej L1? Jakie czynniki architektoniczne to możliwe? Wydaje się bardzo dziwne, że wielokrotne pisanie jednej lokalizacji stosu całkowicie zniszczyłoby skuteczność pamięci podręcznej.

Dodatek

Moja wersja gcc to:

Target: i686-apple-darwin10
Configured with: /var/tmp/gcc/gcc-5646.1~2/src/configure --disable-checking --enable-werror --prefix=/usr --mandir=/share/man --enable-languages=c,objc,c++,obj-c++ --program-transform-name=/^[cg][^.-]*$/s/$/-4.2/ --with-slibdir=/usr/lib --build=i686-apple-darwin10 --with-gxx-include-dir=/include/c++/4.2.1 --program-prefix=i686-apple-darwin10- --host=x86_64-apple-darwin10 --target=i686-apple-darwin10
Thread model: posix
gcc version 4.2.1 (Apple Inc. build 5646) (dot 1)

Mój procesor to:

Intel Xeon X5650