为什么与 gcc -O3 相比，在没有优化的情况下，数组上的循环运行得更快？数组是用 malloc + zeroing 循环初始化的

如何解决为什么与 gcc -O3 相比，在没有优化的情况下，数组上的循环运行得更快？数组是用 malloc + zeroing 循环初始化的

很抱歉再次发布此问题并进行了一些更新。 previous one 已关闭。我正在尝试查看 AVX 指令的性能加速。下面是我正在运行的示例代码：

#include <iostream>
#include <stdio.h>
#include <string.h>
#include <cstdlib>
#include <algorithm>
#include <immintrin.h>
#include <chrono>
#include <complex>
//using Type = std::complex<double>;
using Type = double;

int main()
{
        size_t b_size  =  1;
        b_size = (1ul << 30) * b_size;
    Type *d_ptr = (Type*)malloc(sizeof(Type)*b_size);
    for(int i = 0; i < b_size; i++)
    {
        d_ptr[i] = 0;
    }
    std::cout <<"malloc finishes!" << std::endl;
    #ifndef AVX512
            auto a = std::chrono::high_resolution_clock::Now();
        for (int i = 0; i < b_size; i ++)
        {
             d_ptr[i] = i*0.1;
        }
        std::cout << d_ptr[b_size-1] << std::endl;
            auto b = std::chrono::high_resolution_clock::Now();
            long long diff = std::chrono::duration_cast<std::chrono::microseconds>(b-a).count();
        std::cout << "No avx takes " << diff << std::endl;  
    #else
            auto a = std::chrono::high_resolution_clock::Now();
        for (int i = 0; i < b_size; i += 4)
        {
            /* __m128d tmp1 = _mm_load_pd(reinterpret_cast<double*>(&d_ptr[i]));
             __m128d tmp2 = _mm_set_pd((i+1)*0.1,0.1*i);
             __m128d tmp3 = _mm_add_pd(tmp1,tmp2);
             _mm_store_pd(reinterpret_cast<double*>(&d_ptr[i]),tmp3);*/
            __m256d tmp1 = _mm256_loadu_pd(reinterpret_cast<double*>(&d_ptr[i]));
             __m256d tmp2 = _mm256_set_pd(0.1*(i+3),0.1*(i+2),0.1*(i+1),0.1*i);
             __m256d tmp3 = _mm256_add_pd(tmp1,tmp2);
             _mm256_storeu_pd(reinterpret_cast<double*>(&d_ptr[i]),tmp3);
            
        }
        std::cout << d_ptr[b_size-1] << std::endl;
            auto b = std::chrono::high_resolution_clock::Now();
            long long diff = std::chrono::duration_cast<std::chrono::microseconds>(b-a).count();
        std::cout << "avx takes " << diff << std::endl; 
    
    #endif
}

我已经在 Haswell 机器上运行了上面的代码。结果令人惊讶：

没有 AVX 并使用 O3 编译：

~$ ./test_avx512_auto_noavx 
malloc finishes!
1.07374e+08
No avx takes 3824740

使用 AVX 并在没有任何优化标志的情况下编译：

~$ ./test_avx512_auto
malloc finishes!
1.07374e+08
avx takes 2121917

使用 AVX 并使用 O3 编译：

~$ ./test_avx512_auto_o3 
malloc finishes!
1.07374e+08
avx takes 6307190

这与我们之前的想法相反。

另外，我已经实现了一个矢量化版本（类似于 Add+Mul become slower with Intrinsics - where am I wrong? ），见下面的代码：

#else
            auto a = std::chrono::high_resolution_clock::Now();
            __m256d tmp2 = _mm256_set1_pd(0.1);
            __m256d base = _mm256_set_pd(-1.0,-2.0,-3.0,-4.0);
            __m256d tmp3 = _mm256_set1_pd(4.0);
        for (int i = 0; i < b_size; i += 4)
        {
            /* __m128d tmp1 = _mm_load_pd(reinterpret_cast<double*>(&d_ptr[i]));
             __m128d tmp2 = _mm_set_pd((i+1)*0.1,tmp3);*/
            __m256d tmp1 = _mm256_loadu_pd(reinterpret_cast<double*>(&d_ptr[i]));
            base = _mm256_add_pd(base,tmp3);
            __m256d tmp5 = _mm256_mul_pd(base,tmp2);
            tmp1 = _mm256_add_pd(tmp1,tmp5);
             _mm256_storeu_pd(reinterpret_cast<double*>(&d_ptr[i]),tmp1);

        }
        std::cout << d_ptr[b_size-1] << std::endl;
            auto b = std::chrono::high_resolution_clock::Now();
            long long diff = std::chrono::duration_cast<std::chrono::microseconds>(b-a).count();
        std::cout << "avx takes " << diff << std::endl;

    #endif

在同一台机器上，这给了我：

使用 AVX 且没有任何优化标志

~$ ./test_avx512_manual 
malloc finishes!
1.07374e+08
avx takes 2151390

使用 AVX 和 O3：

~$ ./test_avx512_manual_o3 
malloc finishes!
1.07374e+08
avx takes 5965288

不知道问题出在哪里。为什么 O3 放弃了更差的性能？

编者注：在可执行文件名称中，

_avx512_ 似乎是 -march=native，尽管 Haswell 只有 AVX2。
_manual vs. _auto 似乎是 -DAVX512 使用手动矢量化的 AVX1 代码或编译器对仅使用 = 编写的标量代码的自动矢量化而不是像内在函数所做的 +=。