使用 g++ 5.3.1 编译的程序运行速度比使用 g++ 4.8.4 编译的相同程序慢 3 倍，相同的命令

最近，我开始使用 Ubuntu 16.04 和 g++ 5.3.1 并检查我的程序是否运行慢3倍。 在此之前我使用过 Ubuntu 14.04、g++ 4.8.4。 我用相同的命令构建它：CFLAGS = -std=c++11 -Wall -O3.

我的程序包含循环，充满数学调用（sin、cos、exp）。 你可以找到它here https://github.com/mediev/inclined_well/tree/gcc_bug.

我尝试使用不同的优化标志（O0、O1、O2、O3、Ofast）进行编译，但在所有情况下都会重现问题（Ofast 的两个变体运行速度更快，但第一个运行速度仍慢 3 倍）。

在我的程序中我使用libtinyxml-dev, libgslcblas。但在这两种情况下，它们具有相同的版本，并且在性能方面并不在程序中发挥任何重要作用（根据代码和 callgrind 分析）。

我已经进行了分析，但它并没有让我知道为什么会发生这种情况。Kcachegrind对比（左边较慢） https://i.stack.imgur.com/E19Q7.png。 我只注意到现在程序使用libm-2.23相比libm-2.19使用 Ubuntu 14.04。

我的处理器是 i7-5820k，Haswell。

我不知道为什么它变得更慢。你有什么想法？

附：下面你可以找到最耗时的函数：

void InclinedSum::prepare3D()
{
double buf1, buf2;
double sum_prev1 = 0.0, sum_prev2 = 0.0;
int break_idx1, break_idx2; 
int arr_idx;

for(int seg_idx = 0; seg_idx < props->K; seg_idx++)
{
    const Point& r = well->segs[seg_idx].r_bhp;

    for(int k = 0; k < props->K; k++)
    {
        arr_idx = seg_idx * props->K + k;
        F[arr_idx] = 0.0;

        break_idx2 = 0;

        for(int m = 1; m <= props->M; m++)
        {
            break_idx1 = 0;

            for(int l = 1; l <= props->L; l++)
            {
                buf1 = ((cos(M_PI * (double)(m) * well->segs[k].r1.x / props->sizes.x - M_PI * (double)(l) * well->segs[k].r1.z / props->sizes.z) -
                            cos(M_PI * (double)(m) * well->segs[k].r2.x / props->sizes.x - M_PI * (double)(l) * well->segs[k].r2.z / props->sizes.z)) /
                        ( M_PI * (double)(m) * tan(props->alpha) / props->sizes.x + M_PI * (double)(l) / props->sizes.z ) + 
                            (cos(M_PI * (double)(m) * well->segs[k].r1.x / props->sizes.x + M_PI * (double)(l) * well->segs[k].r1.z / props->sizes.z) -
                            cos(M_PI * (double)(m) * well->segs[k].r2.x / props->sizes.x + M_PI * (double)(l) * well->segs[k].r2.z / props->sizes.z)) /
                        ( M_PI * (double)(m) * tan(props->alpha) / props->sizes.x - M_PI * (double)(l) / props->sizes.z )
                            ) / 2.0;

                buf2 = sqrt((double)(m) * (double)(m) / props->sizes.x / props->sizes.x + (double)(l) * (double)(l) / props->sizes.z / props->sizes.z);

                for(int i = -props->I; i <= props->I; i++)
                {   

                    F[arr_idx] += buf1 / well->segs[k].length / buf2 *
                        ( exp(-M_PI * buf2 * fabs(r.y - props->r1.y + 2.0 * (double)(i) * props->sizes.y)) - 
                        exp(-M_PI * buf2 * fabs(r.y + props->r1.y + 2.0 * (double)(i) * props->sizes.y)) ) *
                        sin(M_PI * (double)(m) * r.x / props->sizes.x) * 
                        cos(M_PI * (double)(l) * r.z / props->sizes.z);
                }

                if( fabs(F[arr_idx] - sum_prev1) > F[arr_idx] * EQUALITY_TOLERANCE )
                {
                    sum_prev1 = F[arr_idx];
                    break_idx1 = 0;
                } else
                    break_idx1++;

                if(break_idx1 > 1)
                {
                    //std::cout << "l=" << l << std::endl;
                    break;
                }
            }

            if( fabs(F[arr_idx] - sum_prev2) > F[arr_idx] * EQUALITY_TOLERANCE )
            {
                sum_prev2 = F[arr_idx];
                break_idx2 = 0;
            } else
                break_idx2++;

            if(break_idx2 > 1)
            {
                std::cout << "m=" << m << std::endl;
                break;
            }
        }
    }
}
}

进一步的调查。 我写了下面的简单程序：

#include <cmath>
#include <iostream>
#include <chrono>

#define CYCLE_NUM 1E+7

using namespace std;
using namespace std::chrono;

int main()
{
    double sum = 0.0;

    auto t1 = high_resolution_clock::now();
    for(int i = 1; i < CYCLE_NUM; i++)
    {
        sum += sin((double)(i)) / (double)(i);
    }
    auto t2 = high_resolution_clock::now();

    microseconds::rep t = duration_cast<microseconds>(t2-t1).count();

    cout << "sum = " << sum << endl;
    cout << "time = " << (double)(t) / 1.E+6 << endl;

    return 0;
}

我真的很想知道为什么这个简单的示例程序在 g++ 4.8.4 libc-2.19 (libm-2.19) 下比在 g++ 5.3.1 libc-2.23 (libm-2.23) 下快 2.5 倍。

编译命令是：

g++ -std=c++11 -O3 main.cpp -o sum

使用其他优化标志不会改变该比率。

我如何了解谁（gcc 或 libc）减慢了程序速度？

为了获得真正精确的答案，您可能需要 libm 维护人员来查看您的问题。但是，这是我的看法 - 将其作为草稿，如果我发现其他内容，我会将其添加到此答案中。

首先看GCC生成的asm，之间海湾合作委员会 4.8.2 https://godbolt.org/g/LtwXrv and gcc 5.3 https://godbolt.org/g/BBgqso。只有4处不同：

• 在开始时xorpd转变为pxor，对于相同的寄存器
• a pxor xmm1, xmm1在从 int 转换为 double 之前添加 (cvtsi2sd)
• a movsd在转换之前被移动
• 加法（addsd) 在比较之前被移动 (ucomisd)

所有这些可能还不足以导致性能下降。拥有一个优秀的分析器（例如英特尔）可以让我们更有结论性，但我无法使用它。

现在，有一个依赖sin，让我们看看发生了什么变化。问题首先是确定你使用的平台... glibc 中有 17 个不同的子文件夹sysdeps（其中定义了罪），所以我选择了x86_64 one.

首先，处理器功能的处理方式发生了变化，例如glibc/sysdeps/x86_64/fpu/multiarch/s_sin.c用于在 2.19 中对 FMA / AVX 进行检查，但在 2.23 中是在外部完成的。可能存在未正确报告功能的错误，导致不使用 FMA 或 AVX。然而，我认为这个假设不太合理。

其次，在.../x86_64/fpu/s_sinf.S，唯一的修改（除了版权更新之外）更改了堆栈偏移量，将其对齐到 16 字节； sincos 同上。不确定这会产生巨大的变化。

然而，2.23 添加了许多数学函数矢量化版本的源，其中一些使用 AVX512 - 您的处理器可能不支持，因为它确实是新的。也许 libm 尝试使用此类扩展，并且由于您没有它们，因此可以回退到通用版本吗？

EDIT:我尝试使用 gcc 4.8.5 编译它，但为此我需要重新编译 glibc-2.19。目前我无法链接，因为：

/usr/lib/gcc/x86_64-linux-gnu/4.8/../../../x86_64-linux-gnu/libm.a(s_sin.o): in function « __cos »:
(.text+0x3542): undefined reference to « _dl_x86_cpu_features »
/usr/lib/gcc/x86_64-linux-gnu/4.8/../../../x86_64-linux-gnu/libm.a(s_sin.o): in function « __sin »:
(.text+0x3572): undefined reference to « _dl_x86_cpu_features »

我将尝试解决此问题，但事先请注意，该符号很可能负责根据处理器选择正确的优化版本，这可能是性能影响的一部分。