SSE-copy, AVX-copy i std::wydajność kopiowania

To bardzo interesujące pytanie, ale uważam, że żadna z odpowiedzi do tej pory nie jest poprawna, ponieważ samo pytanie jest tak mylące.

Tytuł powinien zostać zmieniony na "Jak osiągnąć teoretyczną przepustowość We/Wy pamięci?"

Bez względu na to, jaki zestaw instrukcji jest używany, procesor jest o wiele szybszy od PAMIĘCI RAM, że czysta Kopia pamięci blokowej jest w 100% ograniczona We/Wy. I to wyjaśnia, dlaczego nie ma małej różnicy między wydajnością SSE i AVX.

Dla małych bufory gorące w pamięci podręcznej L1D, AVX może kopiować znacznie szybciej niż SSE na procesorach takich jak Haswell, gdzie ładunki/sklepy 256b naprawdę używają ścieżki danych 256b do pamięci podręcznej L1D zamiast dzielić się na dwie operacje 128b.

Jak na ironię, starożytna Instrukcja X86rep stosq działa znacznie lepiej niż SSE i AVX pod względem kopii pamięci!

Artykuł tutaj wyjaśnia, jak naprawdę dobrze nasycić przepustowość pamięci i ma bogate odniesienia do dalszych badań.

Zobacz także Enhanced REP MOVSB for memcpy tutaj NA SO, gdzie odpowiedź @ BeeOnRope omawia sklepy NT (i sklepy non-RFO wykonane przez rep stosb/stosq) vs.zwykłe sklepy, i jak przepustowość pamięci jednordzeniowej jest często ograniczona przez maksymalną współbieżność / opóźnienie, a nie przez sam kontroler pamięci.

Myślę, że to dlatego, że pomiar nie jest dokładny dla krótkich operacji.

Podczas pomiaru wydajności na procesorze Intel

1. Wyłącz "Turbo Boost" i "SpeedStep". Możesz to zrobić w systemie BIOS.

2. Zmień priorytet procesu / wątku na wysoki lub w czasie rzeczywistym. Dzięki temu Twój wątek będzie działał.

3. Ustaw maskę procesowego procesora tylko na jeden rdzeń. Maskowanie PROCESORA z wyższym priorytetem zminimalizuje przełączanie kontekstu.

4. Użyj _ _ rdtsc() funkcja wewnętrzna. Seria Intel Core zwraca wewnętrzny licznik zegara procesora za pomocą _ _ rdtsc (). Otrzymasz 3400000000 liczy / sekundę z procesora 3,4 Ghz. A _ _ rdtsc () usuwa wszystkie zaplanowane operacje w procesorze, dzięki czemu może dokładniej mierzyć czas.

To mój testowy kod startowy do testowania kodów SSE / AVX.

    int GetMSB(DWORD_PTR dwordPtr)
    {
        if(dwordPtr)
        {
            int result = 1;
    #if defined(_WIN64)
            if(dwordPtr & 0xFFFFFFFF00000000) { result += 32; dwordPtr &= 0xFFFFFFFF00000000; }
            if(dwordPtr & 0xFFFF0000FFFF0000) { result += 16; dwordPtr &= 0xFFFF0000FFFF0000; }
            if(dwordPtr & 0xFF00FF00FF00FF00) { result += 8;  dwordPtr &= 0xFF00FF00FF00FF00; }
            if(dwordPtr & 0xF0F0F0F0F0F0F0F0) { result += 4;  dwordPtr &= 0xF0F0F0F0F0F0F0F0; }
            if(dwordPtr & 0xCCCCCCCCCCCCCCCC) { result += 2;  dwordPtr &= 0xCCCCCCCCCCCCCCCC; }
            if(dwordPtr & 0xAAAAAAAAAAAAAAAA) { result += 1; }
    #else
            if(dwordPtr & 0xFFFF0000) { result += 16; dwordPtr &= 0xFFFF0000; }
            if(dwordPtr & 0xFF00FF00) { result += 8;  dwordPtr &= 0xFF00FF00; }
            if(dwordPtr & 0xF0F0F0F0) { result += 4;  dwordPtr &= 0xF0F0F0F0; }
            if(dwordPtr & 0xCCCCCCCC) { result += 2;  dwordPtr &= 0xCCCCCCCC; }
            if(dwordPtr & 0xAAAAAAAA) { result += 1; }
    #endif
            return result;
        }
        else
        {
            return 0;
        }
    }

    int _tmain(int argc, _TCHAR* argv[])
    {
        // Set Core Affinity
        DWORD_PTR processMask, systemMask;
        GetProcessAffinityMask(GetCurrentProcess(), &processMask, &systemMask);
        SetProcessAffinityMask(GetCurrentProcess(), 1 << (GetMSB(processMask) - 1) );

        // Set Process Priority. you can use REALTIME_PRIORITY_CLASS.
        SetPriorityClass(GetCurrentProcess(), HIGH_PRIORITY_CLASS);

        DWORD64 start, end;
        start = __rdtsc();
    // your code here.
        end = __rdtsc();
        printf("%I64d\n", end - start);
        return 0;
    }

Pisanie szybkiego SSE nie jest tak proste, jak Użycie operacji SSE zamiast ich nie-równoległych odpowiedników. W tym przypadku podejrzewam, że Twój kompilator nie może rozwinąć pary load/store i twój czas jest zdominowany przez przerwy spowodowane użyciem wyjścia jednej operacji o niskiej przepustowości (load) w następnej instrukcji (store).

Możesz przetestować ten pomysł ręcznie rozwijając jedno nacięcie:

//SSE-copy testing
start2 = std::chrono::system_clock::now();
for(int i=0; i<nn; ++i)
{
    auto _mas = mas;
    auto _tar = tar;
    for(; _mas!=mas+sz; _mas+=8, _tar+=8)
    {
       __m128 buffer1 = _mm_load_ps(_mas);
       __m128 buffer2 = _mm_load_ps(_mas+4);
       _mm_store_ps(_tar, buffer1);
       _mm_store_ps(_tar+4, buffer2);
    }
}

Normalnie podczas używania intrinsics demontuję wyjście i upewniam się, że nic szalonego się nie dzieje (możesz spróbować sprawdzić, czy / jak oryginalna pętla została rozwinięta). Dla bardziej złożonych pętli właściwym narzędziem jest Intel Architecture Code Analyzer (IACA) . Jest to narzędzie do analizy statycznej, które może powiedzieć ci rzeczy takie jak "masz stragany rurociągów".

Myślę,że twoim głównym problemem / wąskim gardłem jest Twój _mm_malloc.

Sugeruję użycie std::vector jako głównej struktury danych, jeśli martwisz się o lokalizację w C++.

intrinsics nie są do końca "biblioteką", są bardziej jak wbudowana funkcja dostarczana z twojego kompilatora, powinieneś zapoznać się z wewnętrznymi dokumentami kompilatora przed użyciem tej funkcji.

Należy również zauważyć, że fakt, że {[2] } są nowsze niż SSE nie czyni AVX szybszym, niezależnie od tego, co planujesz użyć, liczba cykli wykonanych przez funkcję jest prawdopodobnie ważniejsza niż argument" avx vs sse", na przykład patrz Ta odpowiedź.

Spróbuj Z POD int array[] lub std::vector.