SSEスカラーsqrt（x）がrsqrt（x）* xより遅いのはなぜですか？

私はIntel Core Duoでいくつかのコア計算をプロファイリングしており、平方根へのさまざまなアプローチを検討しているときに、奇妙なことに気付きました：SSEスカラー演算を使用すると、逆平方根を取得して乗算する方が高速ですネイティブのsqrtオペコードを使用するよりも、sqrtを取得する方が便利です。

私はそれを次のようなループでテストしています：

inline float TestSqrtFunction( float in );

void TestFunc()
{
  #define ARRAYSIZE 4096
  #define NUMITERS 16386
  float flIn[ ARRAYSIZE ]; // filled with random numbers ( 0 .. 2^22 )
  float flOut [ ARRAYSIZE ]; // filled with 0 to force fetch into L1 cache

  cyclecounter.Start();
  for ( int i = 0 ; i < NUMITERS ; ++i )
    for ( int j = 0 ; j < ARRAYSIZE ; ++j )
    {
       flOut[j] = TestSqrtFunction( flIn[j] );
       // unrolling this loop makes no difference -- I tested it.
    }
  cyclecounter.Stop();
  printf( "%d loops over %d floats took %.3f milliseconds",
          NUMITERS, ARRAYSIZE, cyclecounter.Milliseconds() );
}

TestSqrtFunctionのいくつかの異なるボディでこれを試してみましたが、本当に頭を悩ましているいくつかのタイミングがあります。最悪なのは、ネイティブのsqrt（）関数を使用して、「スマート」コンパイラーを「最適化」することです。24 ns / floatで、x87 FPUを使用すると、これは明らかに悪いことでした。

inline float TestSqrtFunction( float in )
{  return sqrt(in); }

次に試したのは、コンパイラにSSEのスカラーsqrtオペコードを使用させるために組み込み関数を使用することでした。

inline void SSESqrt( float * restrict pOut, float * restrict pIn )
{
   _mm_store_ss( pOut, _mm_sqrt_ss( _mm_load_ss( pIn ) ) );
   // compiles to movss, sqrtss, movss
}

これは11.9ns / floatでより優れていました。また、カーマックの奇抜なニュートンラフソン近似手法も試してみました。これは、ハードウェアよりも4.3ns / floatで実行されましたが、エラーは1 in 2 ¹⁰でした（これは、私の目的には多すぎます）。

危険なのは、逆平方根のSSE演算を試し、乗算を使用して平方根を取得したときです（x * 1 /√x=√x）。これには2つの依存する演算が必要ですが、1.24ns / floatで2 ^-14までの精度で、これははるかに高速なソリューションでした。

inline void SSESqrt_Recip_Times_X( float * restrict pOut, float * restrict pIn )
{
   __m128 in = _mm_load_ss( pIn );
   _mm_store_ss( pOut, _mm_mul_ss( in, _mm_rsqrt_ss( in ) ) );
   // compiles to movss, movaps, rsqrtss, mulss, movss
}

私の質問は基本的に何が与えるのですか？SSEの組み込みからハードウェアへの平方根オペコードが他の2つの数学演算から合成するよりも遅いのはなぜですか？

私は確認したので、これは実際にはオペレーション自体のコストであると確信しています：

• すべてのデータはキャッシュに収まり、アクセスはシーケンシャルです
• 関数はインライン化されます
• ループを展開しても違いはありません
• コンパイラー・フラグは完全最適化に設定されています（そして、アセンブリーは良好です。

（編集：stephentyroneは、数値の長い文字列の操作では、ベクトル化SIMDパック演算を使用する必要があることを正しく指摘していますrsqrtpsが、ここでの配列データ構造は、テスト目的のみです。私が実際に測定しようとしているのは、コードで使用するスカラーパフォーマンスです。ベクトル化できません。）

sqrtss正しく丸められた結果が得られます。 rsqrtss与え近似約11ビットの精度の逆数にし、。

sqrtss精度が必要な場合のために、はるかに正確な結果を生成しています。 rsqrtss近似で十分ですが、速度が必要な場合のために存在します。Intelのドキュメントを読むと、ほぼ完全な精度（私が正しく覚えていれば23ビットの精度）を提供する命令シーケンス（逆平方根近似とそれに続く単一のニュートンラフソンステップ）も見つかります。よりも速いsqrtss。

編集：速度が重要であり、多くの値に対してループでこれを実際に呼び出している場合は、これらの命令のベクトル化バージョンを使用するrsqrtpsかsqrtps、どちらも1つの命令で4つの浮動小数点を処理する必要があります。

これは除算にも当てはまります。MULSS（a、RCPSS（b））は、DIVSS（a、b）よりもはるかに高速です。実際、ニュートンラフソン反復法を使用して精度を上げても、さらに高速です。

IntelとAMDはどちらも、最適化マニュアルでこの手法を推奨しています。IEEE-754準拠を必要としないアプリケーションでは、div / sqrtを使用する唯一の理由はコードの読みやすさです。

答えを提供する代わりに、それは実際には正しくない可能性があります（キャッシュやその他のものについてもチェックしたり議論したりはしませんが、それらが同一であるとしましょう）。
違いは、sqrtとrsqrtの計算方法にある可能性があります。詳細については、http：//www.intel.com/products/processor/manuals/をご覧ください。私はあなたが使用しているプロセッサ関数について読むことから始めることをお勧めします、特にrsqrtに関するいくつかの情報があります（cpuは巨大な近似の内部ルックアップテーブルを使用しているため、結果を取得するのがはるかに簡単になります）。rsqrtはsqrtよりもはるかに高速であり、1つの追加のmul操作（コストは高くありません）で状況が変更されないように見えるかもしれません。

編集：言及する価値のあるいくつかの事実：
1.グラフィックライブラリに対していくつかのマイクロ最適化を行っていて、ベクトルの長さの計算にrsqrtを使用したことがある。（sqrtの代わりに、2乗の合計にそのrsqrtを掛けました。これは、テストで行ったとおりです）。
2. rsqrtのように、単純なルックアップテーブルを使用してrsqrtを計算する方が簡単かもしれません。 sqrt-それは無限に行くので、それはその単純なケースです;）。

また、明確化：リンクした本のどこにあるかはわかりませんが、rsqrtがいくつかのルックアップテーブルを使用していることを読んだことは確かです。正確である必要はありませんが、少し前のように、私も間違っている可能性があります。

ニュートンラプソンは、f(x)増分が-f/f' どこにあるかf'と等しい増分を使用してゼロに収束します。

についてはx=sqrt(y)、f(x) = 0をx使用して解決しようとすることができf(x) = x^2 - yます。

次に、増分は次のとおりです。dx = -f/f' = 1/2 (x - y/x) = 1/2 (x^2 - y) / x これには、ゆっくりとした分割があります。

他の関数（などf(x) = 1/y - 1/x^2）を試すこともできますが、それらも同様に複雑になります。

1/sqrt(y)今見てみましょう。を試すこともできますが、たとえば、f(x) = x^2 - 1/y同じように複雑dx = 2xy / (y*x^2 - 1)になります。の非自明な代替選択肢f(x)は次のとおりです。f(x) = y - 1/x^2

次に： dx = -f/f' = (y - 1/x^2) / (2/x^3) = 1/2 * x * (1 - y * x^2)

ああ！ささいな表現ではありませんが、乗算はあり、除算はありません。=>より速く！

そして、完全な更新ステップnew_x = x + dxは次のようになります：

x *= 3/2 - y/2 * x * x これも簡単です。

これに対する他の多くの回答が数年前からすでにあります。コンセンサスが正しいものは次のとおりです。

• rsqrt *命令は、逆平方根の近似値を計算します。約11〜12ビットで十分です。
• これは、仮数によってインデックスが付けられたルックアップテーブル（つまりROM）を使用して実装されます。（実際、これは古い数学テーブルに似た圧縮ルックアップテーブルであり、下位ビットの調整を使用してトランジスタを節約しています。）
• これが使用できる理由は、「実際の」平方根アルゴリズムのFPUで使用される初期推定値だからです。
• おおよその逆数の命令、rcpもあります。これらの命令はどちらも、FPUが平方根と除算を実装する方法の手掛かりです。

コンセンサスが間違っているのはここにあります：

• SSE時代のFPUは平方根の計算にNewton-Raphsonを使用しません。これはソフトウェアでは優れた方法ですが、ハードウェアでそのように実装するのは誤りです。

他の人が指摘しているように、逆平方根を計算するNRアルゴリズムにはこの更新ステップがあります。

x' = 0.5 * x * (3 - n*x*x);

これは、データに依存する多くの乗算と1つの減算です。

以下は、最新のFPUが実際に使用するアルゴリズムです。

が与えられた場合b[0] = n、1に近づくY[i]ような一連の数値を見つけることができると仮定しb[n] = b[0] * Y[0]^2 * Y[1]^2 * ... * Y[n]^2ます。次に、以下を考慮します。

x[n] = b[0] * Y[0] * Y[1] * ... * Y[n]
y[n] = Y[0] * Y[1] * ... * Y[n]

明らかにx[n]近づきsqrt(n)とy[n]アプローチ1/sqrt(n)。

Newton-Raphson更新ステップを使用して、逆平方根を取得し、良い結果を得ることができY[i]ます。

b[i] = b[i-1] * Y[i-1]^2
Y[i] = 0.5 * (3 - b[i])

次に：

x[0] = n Y[0]
x[i] = x[i-1] * Y[i]

そして：

y[0] = Y[0]
y[i] = y[i-1] * Y[i]

次の重要な観察はそれb[i] = x[i-1] * y[i-1]です。そう：

Y[i] = 0.5 * (3 - x[i-1] * y[i-1])
     = 1 + 0.5 * (1 - x[i-1] * y[i-1])

次に：

x[i] = x[i-1] * (1 + 0.5 * (1 - x[i-1] * y[i-1]))
     = x[i-1] + x[i-1] * 0.5 * (1 - x[i-1] * y[i-1]))
y[i] = y[i-1] * (1 + 0.5 * (1 - x[i-1] * y[i-1]))
     = y[i-1] + y[i-1] * 0.5 * (1 - x[i-1] * y[i-1]))

つまり、初期のxとyを指定すると、次の更新ステップを使用できます。

r = 0.5 * (1 - x * y)
x' = x + x * r
y' = y + y * r

または、さらに洗練された設定も可能ですh = 0.5 * y。これは初期化です：

Y = approx_rsqrt(n)
x = Y * n
h = Y * 0.5

そして、これは更新手順です：

r = 0.5 - x * h
x' = x + x * r
h' = h + h * r

これはGoldschmidtのアルゴリズムであり、ハードウェアで実装する場合に非常に有利です。「内部ループ」は3つの積和演算で他には何もありません。2つは独立しており、パイプライン化できます。

1999年には、FPUはすでにパイプライン化された加算/減算回路とパイプライン化された乗算回路を必要としていましたが、そうでなければSSEはあまり「ストリーミング」されませんでした。平方根だけで多くのハードウェアを無駄にすることなく、完全にパイプライン化された方法でこの内部ループを実装するために、1999年には各回路の1つだけが必要でした。

もちろん、今日、プログラマーに公開された乗加算を融合しました。繰り返しになりますが、内側のループは3つのパイプラインFMAであり、平方根を計算していない場合でも（再び）一般に役立ちます。

これらの命令は丸めモードを無視し、浮動小数点例外や非正規化数を処理しないため、処理が速くなります。これらの理由により、他のfp命令を順不同でパイプライン処理、推測、および実行する方がはるかに簡単です。