Por que meu benchmark usando __mm_prefetch é mais lento?

Primeiro, seu código está introduzindo uma ramificação desnecessária, o que muito provavelmente torna as coisas mais lentas e pode ser evitado:

/* Original */
for (int i = 0; i < data.size(); i++) {
    if (i + prefetch_distance < data.size()) {
        PREFETCH(&data[i + prefetch_distance], 3);
    }
    sum += data[i];
}

/* Updated code */
int i;
for (i = 0; i < data.size() - prefetch_distance; i++) {
    PREFETCH(&data[i + prefetch_distance], 3);
    sum += data[i];
}
for ( ; i < data.size(); i++)
    sum += data[i];

Agora, analisando o código sem ramificação: a causa raiz do problema parece ser a incapacidade do compilador de vetorizar corretamente o loop com instruções SIMD quando __builtin_prefetch()usado em seu corpo. O NoPrefetchcódigo é vetorizado, mas não é pré-buscado explicitamente. O WithPrefetchcódigo é pré-perfeito explicitamente, mas não vetorizado. A lentidão causada pela vetorização perdida é muito mais severa do que a aceleração causada pela pré-busca explícita.

Um relatório de bug interessante do GCC esclarece o problema: Bug 114061 - GCC falha na vetorização ao usar __builtin_prefetch . Pelo menos para o GCC, parece que o compilador assume que você __builtin_prefetch(&data[i + x])sobrecarrega a memória e faz uma chamada de função (faz sentido evitar a vetorização nesse caso), mesmo que a chamada seja para uma função interna que atua como uma operação não operacional.

O GCC 15 deveria ter uma correção para superar essa limitação e permitir o built-in sem interromper a vetorização. No entanto, pelo que vejo no Godbolt.org , embora o trunk do GCC 16 vetorize o loop, ele ignora completamente a pré-busca, deixando-a completamente fora do loop. Portanto, ainda me parece quebrado.

Então, como você pode "consertar" isso, se necessário? Bem, infelizmente você não pode confiar no compilador para vetorizar corretamente com sua pré-busca explícita. Além disso, mesmo que um compilador específico seja inteligente o suficiente para lidar com isso (parece que nenhum dos principais é), parece improvável que todos os compiladores acertem em uma compilação multiplataforma. Isso significa que, como você já notou, você terá que aplicar a vetorização manualmente e inserir uma pré-busca conforme necessário.

Sim, a pré-busca de software pode ser benéfica, mas, em geral, é uma tarefa de otimização difícil, com muita tentativa e erro empíricos, principalmente porque a pré-busca de hardware já é muito boa hoje em dia. Veja a resposta em "Posso ler um sinalizador de CPU x86 para determinar se os dados pré-buscados chegaram ao cache L1?" . Se a pré-busca de software for muito cedo (longa distância), os dados serão removidos no momento em que você quiser usá-los. Se a pré-busca de software for muito tarde (pequena distância), a operação se torna inoperante, pois a pré-busca de hardware já ocorreu.

No código de exemplo abaixo , com prefetch_disancedefinido como um valor pequeno como 8, o desempenho diminui em vez de aumentar porque você está pré-buscando dados que já estavam no cache:

PrefetchBenchmark/ManualSIMDWithPrefetch     151742 ns       151738 ns         4599
PrefetchBenchmark/ManualSIMD                 145401 ns       145401 ns         4790

Isso faz sentido, visto que uma linha de cache já cobre 64/4 = 16 intvalores contíguos (assumindo 32 bits int) e a pré-busca de hardware provavelmente já está carregando mais de uma linha de cache à frente. CPUs modernas [x86] já são muito boas em pré-busca de hardware para padrões simples de acesso à memória, como acesso sequencial.

Aumentando prefetch_disancepara um valor maior, como 64ou 128você pode começar a ver uma melhoria (já que estou no x86 Skylake):

PrefetchBenchmark/ManualSIMDWithPrefetch     137408 ns       137407 ns         5022
PrefetchBenchmark/ManualSIMD                 146430 ns       146429 ns         4803

Código de exemplo:

static inline long simd_sum8(const std::vector<int> &data, const int i) {
    __m128i vec1 = _mm_loadu_si128(reinterpret_cast<const __m128i*>(&data[i]));
    __m128i vec2 = _mm_loadu_si128(reinterpret_cast<const __m128i*>(&data[i + 4]));
    __m128i sum_vec = _mm_add_epi32(vec1, vec2);

    int temp[4];
    _mm_storeu_si128(reinterpret_cast<__m128i*>(temp), sum_vec);
    return temp[0] + temp[1] + temp[2] + temp[3];
}

BENCHMARK_F(PrefetchBenchmark, ManualSIMDWithPrefetch)(benchmark::State& state) {
    for (auto _ : state) {
        long sum = 0;
        int i = 0;
        int size = static_cast<int>(data.size());

        // TODO: benchmark and tune this!
        constexpr int prefetch_disance = 128;

        for (; i <= size - prefetch_disance; i += 8) {
            PREFETCH(&data[i + prefetch_disance], 3);
            sum += simd_sum8(data, i);
        }

        for (; i < size; ++i) {
            sum += data[i];
        }

        benchmark::DoNotOptimize(sum);
    }
}

BENCHMARK_F(PrefetchBenchmark, ManualSIMD)(benchmark::State& state) {
    for (auto _ : state) {
        long sum = 0;
        int i = 0;
        int size = static_cast<int>(data.size());

        for (; i < size; i += 8)
            sum += simd_sum8(data, i);

        benchmark::DoNotOptimize(sum);
    }
}