问题 为什么GCC不优化a * a * a * a * a * a到（a * a * a）*（a * a * a）？

Lambdageek 正确地指出，因为关联性不适用于浮点数，所以“优化” a*a*a*a*a*a 至 (a*a*a)*(a*a*a) 可能会改变价值。这就是C99不允许的原因（除非用户特别允许，通过编译器标志或编译指示）。一般来说，假设程序员为了某个原因编写了她所做的事情，编译器应该尊重这一点。如果你想 (a*a*a)*(a*a*a)写下来。

但是，这可能是一种痛苦;为什么编译器在你使用时不能做[你认为是什么]正确的事情 pow(a,6)？因为它会是 错误 要做的事。在一个拥有良好数学库的平台上， pow(a,6) 比任何一个都明显更准确 a*a*a*a*a*a 要么 (a*a*a)*(a*a*a)。为了提供一些数据，我在我的Mac Pro上运行了一个小实验，测量了[1,2]之间所有单精度浮点数的^ 6评估中的最差错误：

worst relative error using    powf(a, 6.f): 5.96e-08
worst relative error using (a*a*a)*(a*a*a): 2.94e-07
worst relative error using     a*a*a*a*a*a: 2.58e-07

运用 pow 而不是乘法树减少了由a约束的误差 因子4。编译器不应（并且通常不）进行“优化”以增加错误，除非用户许可（例如通过 -ffast-math）。

请注意GCC提供 __builtin_powi(x,n) 作为替代 pow( )，应生成内联乘法树。如果您想要牺牲性能的准确性，但又不想启用快速数学运算，请使用它。

另一个类似的案例：大多数编译器都不会优化 a + b + c + d 至 (a + b) + (c + d) （这是一个优化，因为第二个表达式可以更好地流水线化）并将其评估为给定（即as (((a + b) + c) + d)）。这也是因为角落的情况：

float a = 1e35, b = 1e-5, c = -1e35, d = 1e-5;
printf("%e %e\n", a + b + c + d, (a + b) + (c + d));

这输出 1.000000e-05 0.000000e+00

Fortran（专为科学计算而设计）具有内置的幂运算符，据我所知，Fortran编译器通常会以与您描述的方式类似的方式优化提升到整数幂。遗憾的是，C / C ++没有power运算符，只有库函数 pow()。这并不妨碍智能编译器进行处理 pow 特别是为特殊情况以更快的方式计算它，但似乎它们不那么常见......

几年前，我试图以最佳方式计算整数幂更方便，并提出以下建议。它是C ++，而不是C，但仍然依赖于编译器在如何优化/内联事物方面有点聪明。无论如何，希望你在实践中发现它有用：

template<unsigned N> struct power_impl;

template<unsigned N> struct power_impl {
    template<typename T>
    static T calc(const T &x) {
        if (N%2 == 0)
            return power_impl<N/2>::calc(x*x);
        else if (N%3 == 0)
            return power_impl<N/3>::calc(x*x*x);
        return power_impl<N-1>::calc(x)*x;
    }
};

template<> struct power_impl<0> {
    template<typename T>
    static T calc(const T &) { return 1; }
};

template<unsigned N, typename T>
inline T power(const T &x) {
    return power_impl<N>::calc(x);
}

_{对好奇的澄清： 这并没有找到计算能力的最佳方法，但从那以后 找到最优解是NP完全问题 无论如何这对小功率来说都是值得做的（而不是使用 pow），没有理由对细节大惊小怪。}

然后用它作为 power<6>(a)。

这样可以轻松输入功率（无需拼出6 as with parens），让你无需进行这种优化 -ffast-math 如果你有精确依赖的东西，比如 补偿总和 （操作顺序必不可少的例子）。

您可能还会忘记这是C ++并且只是在C程序中使用它（如果它与C ++编译器一起编译）。

希望这可能有用。

编辑：

这是我从编译器得到的：

对于 a*a*a*a*a*a，

    movapd  %xmm1, %xmm0
    mulsd   %xmm1, %xmm0
    mulsd   %xmm1, %xmm0
    mulsd   %xmm1, %xmm0
    mulsd   %xmm1, %xmm0
    mulsd   %xmm1, %xmm0

对于 (a*a*a)*(a*a*a)，

    movapd  %xmm1, %xmm0
    mulsd   %xmm1, %xmm0
    mulsd   %xmm1, %xmm0
    mulsd   %xmm0, %xmm0

对于 power<6>(a)，

    mulsd   %xmm0, %xmm0
    movapd  %xmm0, %xmm1
    mulsd   %xmm0, %xmm1
    mulsd   %xmm0, %xmm1

因为32位浮点数（例如1.024）不是1.024。在计算机中，1.024是间隔：从（1.024-e）到（1.024 + e），其中“e”表示错误。有些人没有意识到这一点，并且还认为* a中的*表示任意精度数的乘法而没有任何附加到这些数字的错误。有些人没有意识到这一点的原因可能是他们在小学里运用的数学计算：只使用没有错误的理想数字工作，并且相信在执行乘法时简单地忽略“e”是可以的。他们没有看到“浮动a = 1.2”，“a * a * a”和类似的C代码中隐含的“e”。

如果大多数程序员认识到（并且能够执行）C表达式a * a * a * a * a * a实际上并不适用于理想数字的想法，那么GCC编译器将可以自由地优化“a * a * a * a * a * a“to say”t =（a * a）; t * t * t“，需要较少的乘法次数。但不幸的是，GCC编译器不知道编写代码的程序员是否认为“a”是带有或不带错误的数字。所以GCC只会做源代码的样子 - 因为这就是GCC用“肉眼”看到的东西。

...一旦你知道什么样的程序员 您 是的，你可以使用“-ffast-math”开关告诉GCC“嘿，海湾合作委员会，我知道我在做什么！”。这将允许GCC将* a * a * a * a * a转换为不同的文本 - 它看起来与a * a * a * a * a * a不同 - 但仍然计算错误间隔内的数字A * A * A * A * A * A。这没关系，因为你已经知道你正在使用间隔，而不是理想的数字。

当a是整数时，GCC确实优化a * a * a * a * a * a到（a * a * a）*（a * a * a）。我试过这个命令：

$ echo 'int f(int x) { return x*x*x*x*x*x; }' | gcc -o - -O2 -S -masm=intel -x c -

有很多gcc标志，但没有什么花哨的。他们的意思是：从stdin读取;使用O2优化级别;输出汇编语言列表而不是二进制;列表应使用英特尔汇编语言语法;输入是用C语言编写的（通常是从输入文件扩展名推断语言，但是从stdin读取时没有文件扩展名）;并写信给stdout。

这是输出的重要部分。我用一些评论来注释它，表明汇编语言中发生了什么：

    ; x is in edi to begin with.  eax will be used as a temporary register.
    mov    eax, edi     ; temp1 = x
    imul    eax, edi    ; temp2 = x * temp1
    imul    eax, edi    ; temp3 = x * temp2
    imul    eax, eax    ; temp4 = temp3 * temp3

我在Linux Mint 16 Petra上使用系统GCC，这是一个Ubuntu衍生产品。这是gcc版本：

$ gcc --version
gcc (Ubuntu/Linaro 4.8.1-10ubuntu9) 4.8.1

正如其他海报所指出的那样，这个选项在浮点时是不可能的，因为浮点运算实际上不是关联的。

没有海报提到浮动表达的收缩（ISO C标准，6.5p8和7.12.2）。如果 FP_CONTRACT pragma设置为 ON，允许编译器考虑诸如的表达式 a*a*a*a*a*a 作为单个操作，就好像使用单个舍入精确评估一样。例如，编译器可以用更快和更准确的内部功率函数代替它。这一点特别有趣，因为行为部分由程序员直接在源代码中控制，而最终用户提供的编译器选项有时可能会被错误地使用。

默认状态 FP_CONTRACT pragma是实现定义的，因此默认情况下允许编译器执行此类优化。因此，需要严格遵循IEEE 754规则的可移植代码应明确地将其设置为 OFF。

如果编译器不支持此编译指示，则必须保守，避免任何此类优化，以防开发人员选择将其设置为 OFF。

GCC不支持此pragma，但使用默认选项时，它会假定它 ON;因此，对于具有硬件FMA的目标，如果想要阻止转换 a*b+c 对于fma（a，b，c），需要提供诸如的选项 -ffp-contract=off （将pragma明确设置为 OFF） 要么 -std=c99 （告诉GCC符合某些C标准版本，这里是C99，因此遵循上面的段落）。在过去，后一种选择并没有阻止转型，这意味着海湾合作委员会在这一点上不符合要求： https://gcc.gnu.org/bugzilla/show_bug.cgi?id=37845

正如Lambdageek指出浮点乘法不是关联的，你可以得到更低的准确性，但是当获得更好的准确性时，你可以反对优化，因为你想要一个确定性的应用程序。例如，在游戏模拟客户端/服务器中，每个客户端都必须模拟同一个世界，您希望浮点计算是确定性的。

我不希望这个案例得到优化。在表达式包含可以重新分组以删除整个操作的子表达式的情况下，通常不会这样。我希望编译器编写者将时间投入到更有可能带来明显改进的领域，而不是覆盖很少遇到的边缘情况。

我很惊讶地从其他答案中得知这个表达式确实可以通过适当的编译器开关进行优化。优化是微不足道的，或者它是更常见优化的边缘情况，或者编译器编写者非常彻底。

像在这里一样，为编译器提供提示没有任何问题。重新排列语句和表达式是微观优化过程中正常和预期的一部分，以了解它们将带来的差异。

虽然编译器可能在考虑两个表达式以提供不一致的结果（没有正确的开关）时是合理的，但是您不需要受该限制的约束。差异将非常小 - 如果差异对您很重要，那么您首先不应该使用标准浮点运算。

像“pow”这样的库函数通常是精心设计的，以产生最小可能的错误（在通用情况下）。这通常是使用样条函数实现近似函数（根据Pascal的注释，最常见的实现似乎正在使用 Remez算法）

从根本上说是以下操作：

pow(x,y);

有大约的固有误差 与任何单个乘法或除法中的误差大小相同。

同时进行以下操作：

float a=someValue;
float b=a*a*a*a*a*a;

具有更大的固有误差 单次乘法误差的5倍 或除法（因为你正在组合5次乘法）。

编译器应该非常小心它正在进行的优化：

1. 如果优化 pow(a,6) 至 a*a*a*a*a*a 它 可能 提高性能，但大幅降低浮点数的准确性。
2. 如果优化 a*a*a*a*a*a  至 pow(a,6) 它可能实际上降低了准确性，因为“a”是一些特殊值，允许无误差乘法（2的幂或一些小的整数）
3. 如果优化 pow(a,6) 至 (a*a*a)*(a*a*a) 要么 (a*a)*(a*a)*(a*a) 与...相比，仍然可能会失去准确性 pow 功能。

一般来说，你知道对于任意浮点值，“pow”比你最终可以编写的任何函数都具有更好的精度，但在某些特殊情况下，多次乘法可能具有更好的准确性和性能，这取决于开发人员选择哪种更合适，最终评论代码，以便其他任何人都不会“优化”该代码。

唯一有意义的事情（个人意见，显然是GCC中的选择，没有任何特定的优化或编译器标志）要优化应该用“a * a”替换“pow（a，2）”。这将是编译器供应商应该做的唯一理智的事情。