GCCがa * a * a * a * a * aを（a * a * a）*（a * a * a）に最適化しないのはなぜですか？

科学的なアプリケーションで数値の最適化を行っています。私が気づいたことの1つは、GCCはにpow(a,2)コンパイルすることで呼び出しを最適化しますa*aが、呼び出しpow(a,6)は最適化されておらず、実際にはライブラリ関数を呼び出すpowため、パフォーマンスが大幅に低下します。（対照的に、インテルC ++コンパイラー（実行可能icc）は、のライブラリー呼び出しを排除しますpow(a,6)。）

私は好奇心だと、私は交換したときにということであるpow(a,6)とa*a*a*a*a*aGCC 4.5.1とオプション「を使用して-O3 -lm -funroll-loops -msse4」、それは5つの使用mulsd説明書を：

movapd  %xmm14, %xmm13
mulsd   %xmm14, %xmm13
mulsd   %xmm14, %xmm13
mulsd   %xmm14, %xmm13
mulsd   %xmm14, %xmm13
mulsd   %xmm14, %xmm13

私が書いた場合(a*a*a)*(a*a*a)、それは生成されます

movapd  %xmm14, %xmm13
mulsd   %xmm14, %xmm13
mulsd   %xmm14, %xmm13
mulsd   %xmm13, %xmm13

乗算命令の数を3に減らすと、icc同様の動作になります。

コンパイラがこの最適化トリックを認識しないのはなぜですか？

そのため浮動小数点演算が連想ではありません。浮動小数点乗算でオペランドをグループ化する方法は、回答の数値精度に影響を与えます。

その結果、ほとんどのコンパイラーは、答えが変わらないと確信できない場合、または数値の精度を気にしないように指示しない限り、浮動小数点計算の並べ替えについて非常に保守的です。たとえば、次のオプション GCCは浮動小数点演算を再結合することを可能にするGCCの、あるいは速度に対する精度の一層積極的なトレードオフを可能にするオプション。-fassociative-math-ffast-math

Lambdageekは、連想性が浮動小数点数に対して保持されないため、a*a*a*a*a*atoの「最適化」が(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）の間のすべての単精度浮動小数点数についてa ^ 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乗算ツリーの代わりにを使用すると、エラーバウンドが4倍になります。コンパイラーは、ユーザーが（例えばを介して-ffast-math）許可を与えていない限り、エラーを増加させる「最適化」を行うべきではありません（通常は行いません）。

GCCは__builtin_powi(x,n)の代替としてを提供しpow( )、インライン乗算ツリーを生成することに注意してください。精度とパフォーマンスをトレードオフしたいが、高速演算を有効にしたくない場合に使用します。

別の同様のケース：ほとんどのコンパイラーは最適化a + b + c + dせず(a + b) + (c + d)（これは2番目の式をより適切にパイプライン化できるため、最適化です）、指定されたとおりに（つまりとして(((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 ++には、残念ながらパワーオペレーターがありません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)。

これにより、累乗を簡単に入力できるようになり（a括弧で6 秒を入力する必要はありません）、補正された合計（演算の順序が不可欠な例）-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

GCCは実際にはaが整数のときに最適化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最適化レベルを使用します。バイナリの代わりにアセンブリ言語のリストを出力します。リストはIntelアセンブリ言語構文を使用する必要があります。入力はC言語です（通常、言語は入力ファイル拡張子から推測されますが、stdinから読み取るときにファイル拡張子はありません）。標準出力に書き込みます。

出力の重要な部分は次のとおりです。アセンブリ言語で何が行われているのかを示すコメントで注釈を付けました。

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

私はLinux Mint 16ペトラ、Ubuntu派生物でシステムGCCを使用しています。これがgccのバージョンです。

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

他の投稿者が指摘したように、浮動小数点演算は結合的でないため、このオプションは浮動小数点では使用できません。

32ビット浮動小数点数（1.024など）は1.024ではないためです。コンピュータでは、1.024は（1.024-e）から（1.024 + e）までの間隔です。ここで、「e」はエラーを表します。一部の人々はこれに気付かず、* in a * aが任意の精度の数値の乗算を意味し、これらの数値にエラーが付加されていないと信じています。一部の人がこれに気付かない理由は、おそらく小学校で練習した数学の計算です。エラーを付けずに理想的な数値のみを扱い、乗算を実行している間は単に「e」を無視してもよいと信じています。「float a = 1.2」、「a * a * a」、および類似のCコードに暗黙的に含まれる「e」は表示されません。

大多数のプログラマーが、Cの式a * a * a * a * a * aが実際には理想的な数値で機能していないことを認識（そして実行できる）場合、GCCコンパイラーは「a * a」を自由に最適化できます。 * a * a * a * a "から" t =（a * a）; t * t * t "に変更すると、乗算回数が少なくなります。しかし、残念ながら、GCCコンパイラーは、コードを書いているプログラマーが「a」がエラーの有無にかかわらず数値であると考えているかどうかを知りません。そのため、GCCはソースコードの外観のみを実行します。これは、GCCが「裸眼」で見ているものだからです。

...自分がどのようなプログラマであるかがわかったら、「-ffast-math」スイッチを使用して、GCCに「ねえ、GCC、私がやっていることを知っている！」と伝えます。これにより、GCCはa * a * a * a * a * aを別のテキストに変換できます-これはa * a * a * a * a * aとは異なりますが、エラー間隔内の数値を計算しますa * a * a * a * a * a。理想的な数値ではなく間隔で作業していることはすでにわかっているので、これは問題ありません。

フローティング式の縮小について言及しているポスターはまだありません（ISO C標準、6.5p8および7.12.2）。場合はFP_CONTRACT、プラグマに設定されON、コンパイラは、次のような表現を考えるために許可されているa*a*a*a*a*a単一の丸めと正確に評価したかのように、単一の操作など。たとえば、コンパイラは、より高速で正確な内部電源関数に置き換えます。エンドユーザーが提供するコンパイラオプションが誤って使用されることがありますが、動作は部分的にプログラマによってソースコードで直接制御されるため、これは特に興味深いものです。

FP_CONTRACTプラグマのデフォルトの状態は実装定義であり、コンパイラーはデフォルトでそのような最適化を実行できます。したがって、IEEE 754ルールに厳密に従う必要がある移植可能なコードは、明示的にに設定する必要がありOFFます。

コンパイラがこのプラグマをサポートしていない場合、開発者がそれをに設定することを選択した場合に備えて、そのような最適化を回避することにより、保守的でなければなりませんOFF。

GCCはこのプラグマをサポートしていませんが、デフォルトのオプションでは、それがであると想定していますON。したがって、ハードウェアFMAを備えたターゲットの場合a*b+c、fma（a、b、c）への変換を防止したい場合は、-ffp-contract=off（プラグマを明示的にに設定するOFF）または-std=c99（GCCにいくつかに準拠するように指示する）などのオプションを提供する必要がありますC標準バージョン、ここではC99なので、上記の段落に従います）。以前は、後者のオプションは変換を妨げていませんでした。つまり、GCCはこの点に準拠していませんでした：https : //gcc.gnu.org/bugzilla/show_bug.cgi?id=37845

Lambdageekが指摘したように、floatの乗算は関連性がなく、精度が低下する可能性がありますが、精度が向上すると最適化に反対する可能性があります。確定的なアプリケーションが必要だからです。たとえば、ゲームシミュレーションクライアント/サーバーでは、すべてのクライアントが同じ世界をシミュレートする必要があるため、浮動小数点計算を確定的にする必要があります。

「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」はエラーなしで乗算できる特別な値（2の累乗または小さな整数）であるため、最適化a*a*a*a*a*a するpow(a,6)と実際に精度が低下する可能性がある場合
3. 最適化pow(a,6)する場合、(a*a*a)*(a*a*a)または機能(a*a)*(a*a)*(a*a)と比較して精度が低下する可能性があるpow場合。

一般に、任意の浮動小数点値の「pow」は、最終的に作成できる関数よりも精度が高いことがわかっていますが、特殊なケースでは、複数の乗算の精度とパフォーマンスが向上する場合があるため、開発者がより適切なものを選択する必要があります。最終的にコードにコメントを付けて、誰もそのコードを「最適化」しないようにします。

最適化する意味がある（個人的な意見、および特定の最適化またはコンパイラフラグのないGCCでの選択）唯一のことは、「pow（a、2）」を「a * a」で置き換えることです。これは、コンパイラベンダーが行うべき唯一の正気なことです。

このケースが最適化されるとはまったく思っていませんでした。操作全体を削除するために再グループ化できる部分式が式に含まれている場合は、それほど頻繁ではありません。コンパイラの作成者は、めったに遭遇しないエッジケースをカバーするのではなく、顕著な改善をもたらす可能性が高い領域に時間を費やすことを期待します。

他の回答から、この式が実際に適切なコンパイラスイッチで最適化できることを知って驚いた。最適化が取るに足らないことであるか、それはより一般的な最適化の最悪のケースであるか、またはコンパイラー作成者が非常に徹底的でした。

ここで行ったように、コンパイラーにヒントを提供することに問題はありません。ステートメントと式を再配置してそれらがもたらす違いを確認することは、マイクロ最適化プロセスの通常の予想される部分です。

コンパイラーは2つの式を考慮して（適切なスイッチなしで）一貫性のない結果を提供することを正当化できますが、その制限に拘束される必要はありません。違いは信じられないほど小さなものになります-そのため、違いが重要な場合は、最初に標準の浮動小数点演算を使用しないでください。

この質問にはすでにいくつかの良い答えがありますが、完全を期すために、C標準の適用可能なセクションは5.1.2.2.3 / 15（これは、 C ++ 11標準）。このセクションでは、演算子が実際に連想的または可換的である場合にのみ、演算子を再グループ化できると述べています。

gccは、浮動小数点数であっても、実際にこの最適化を行うことができます。例えば、

double foo(double a) {
  return a*a*a*a*a*a;
}

なる

foo(double):
    mulsd   %xmm0, %xmm0
    movapd  %xmm0, %xmm1
    mulsd   %xmm0, %xmm1
    mulsd   %xmm1, %xmm0
    ret

と-O -funsafe-math-optimizations。ただし、この並べ替えはIEEE-754に違反するため、フラグが必要です。

符号付き整数は、Peter Cordesがコメントで指摘したように、-funsafe-math-optimizationsオーバーフローがない場合に正確に保持され、オーバーフローがある場合に未定義の動作が発生するため、この最適化を行うことなく実行できます。だからあなたは得る

foo(long):
    movq    %rdi, %rax
    imulq   %rdi, %rax
    imulq   %rdi, %rax
    imulq   %rax, %rax
    ret

だけで-O。符号なし整数の場合、2の累乗のmodが機能するため、オーバーフローが発生した場合でも自由に並べ替えることができるため、さらに簡単です。