SSE skaler sqrt (x) neden rsqrt (x) * x'ten daha yavaş?

Intel Core Duo'da bazı temel matematiğimizin profilini çıkarıyorum ve karekök için çeşitli yaklaşımlara bakarken tuhaf bir şey fark ettim: SSE skaler işlemlerini kullanarak, karşılıklı bir karekök alıp çarpmak daha hızlı sqrt'yi elde etmek için, yerel sqrt opcode kullanmaktan çok!

Şunun gibi bir döngü ile test ediyorum:

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() );
}

Bunu TestSqrtFunction için birkaç farklı vücutla denedim ve gerçekten kafamı kaşıyan bazı zamanlamalarım var. En kötüsü, yerel sqrt () işlevini kullanmak ve "akıllı" derleyicinin "optimize etmesine" izin vermekti. 24ns / float'ta, x87 FPU kullanıldığında bu çok kötüydü:

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

Bir sonraki denediğim şey, derleyiciyi SSE'nin skalar sqrt işlem kodunu kullanmaya zorlamak için bir intrinsic kullanmaktı:

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
}

Bu 11.9ns / float ile daha iyiydi. Ben de denedim Carmack'in kaçık Newton Raphson yaklaşım tekniği rağmen 2'de 1'lik bir hata ile, 4.3ns / şamandıra, hatta daha iyi donanım daha koştu, ¹⁰ (benim amaçlar için çok fazla).

Doozy, karşılıklı karekök için SSE işlemini denediğimde ve daha sonra karekökü (x * 1 / √x = √x) elde etmek için bir çarpma kullandığım zamandı. Bu iki bağımlı işlemleri sürüyor olsa da, en hızlı çözüm ile uzak, 1.24ns / şamandıra de ve doğru 2'ye oldu ^-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
}

Benim sorum temelde ne verir ? SSE'nin donanıma yerleşik karekök işlem kodu, onu diğer iki matematik işleminden sentezlemekten neden daha yavaş ?

Eminim bu gerçekten operasyonun kendisinin maliyeti, çünkü doğruladım:

• Tüm veriler önbelleğe sığar ve erişimler sıralıdır
• işlevler satır içi
• Döngüyü açmak fark etmez
• derleyici bayrakları tam optimizasyona ayarlandı (ve montaj iyi, kontrol ettim)

( düzenleme : stephentyrone, uzun sayı dizilerindeki işlemlerin vektörleştirici SIMD paketlenmiş işlemlerini kullanması gerektiğini doğru bir şekilde belirtir rsqrtps- ancak buradaki dizi veri yapısı yalnızca test amaçlıdır: gerçekten ölçmeye çalıştığım şey , kodda kullanım için skaler performans bu vektörleştirilemez.)

sqrtssdoğru şekilde yuvarlatılmış bir sonuç verir. tersine yaklaşık 11 bitlik doğru rsqrtssbir yaklaşım verir .

sqrtssdoğruluk gerektiğinde çok daha doğru bir sonuç üretiyor. rsqrtssbir yaklaşımın yeterli olduğu ancak hızın gerekli olduğu durumlar için mevcuttur. Intel'in belgelerini okursanız, neredeyse tam kesinlik (doğru hatırlıyorsam ~ 23 bitlik doğruluk) veren ve hala bir yönerge dizisi (karşılıklı karekök yaklaşımı ve ardından tek bir Newton-Raphson adımı) bulacaksınız. daha hızlı sqrtss.

edit: Eğer hız kritikse ve bunu gerçekten birçok değer için bir döngü içinde çağırıyorsanız, bu komutların vektörleştirilmiş versiyonlarını rsqrtpsveya sqrtpsher ikisi de komut başına dört kayan nokta işleyen her ikisini de kullanıyor olmalısınız .

Bu, bölünme için de geçerlidir. MULSS (a, RCPSS (b)) DIVSS'den (a, b) çok daha hızlıdır. Aslında, bir Newton-Raphson yinelemesiyle hassasiyetini artırdığınızda bile daha hızlıdır.

Intel ve AMD, bu tekniği optimizasyon kılavuzlarında tavsiye ediyor. IEEE-754 uyumluluğu gerektirmeyen uygulamalarda div / sqrt kullanmanın tek nedeni kod okunabilirliğidir.

Aslında yanlış olabilecek bir cevap vermek yerine (ayrıca önbellek ve diğer şeyleri kontrol etmeyeceğim veya tartışmayacağım, diyelim ki bunların aynı olduğunu söyleyelim) Sizi sorunuza cevap verebilecek kaynağı göstermeye çalışacağım.
Fark, sqrt ve rsqrt'nin nasıl hesaplandığına bağlı olabilir. Daha fazla bilgiyi burada http://www.intel.com/products/processor/manuals/ okuyabilirsiniz . Kullanmakta olduğunuz işlemci işlevleri hakkında okumaya başlamanızı öneririm, özellikle rsqrt hakkında bazı bilgiler var (cpu, sonucu elde etmeyi çok daha basit hale getiren büyük bir yaklaşımla dahili arama tablosu kullanıyor). Görünüşe göre rsqrt, sqrt'den çok daha hızlıdır, 1 ek çoklu işlem (ki bu maliyetli değildir) buradaki durumu değiştirmeyebilir.

Düzenleme: Bahsetmeye değer birkaç gerçek:
1. Bir zamanlar grafik kütüphanem için bazı mikro optimizasyonlar yapıyordum ve vektörlerin uzunluklarını hesaplamak için rsqrt kullandım. (sqrt yerine, karelerimin karesini rsqrt ile çarptım, testlerinizde yaptığınız tam olarak buydu) ve daha iyi performans gösterdi.
2. Basit arama tablosu kullanarak rsqrt'yi hesaplamak daha kolay olabilir, rsqrt için, x sonsuza gittiğinde, 1 / sqrt (x) 0'a gider, bu nedenle küçük x'ler için fonksiyon değerleri değişmez (çok), oysa sqrt - sonsuza gider, bu yüzden bu kadar basit;).

Ayrıca açıklama: Bağladığım kitaplarda onu nerede bulduğumdan emin değilim, ancak rsqrt'nin bazı arama tablosu kullandığını okuduğuma eminim ve yalnızca sonuç olduğunda kullanılmalıdır tam olmasına gerek yok - bir süre önce olduğu gibi ben de yanılıyor olabilirim :).

Newton-Raphson , türevin nerede olduğuna f(x)eşit artışları kullanarak sıfıra yakınsar .-f/f'f'

İçin x=sqrt(y), sen çözmeyi deneyebilirsiniz f(x) = 0için xkullanarak f(x) = x^2 - y;

O zaman artış: dx = -f/f' = 1/2 (x - y/x) = 1/2 (x^2 - y) / x içinde yavaş bir bölünmeye sahip.

Diğer işlevleri deneyebilirsiniz (gibi f(x) = 1/y - 1/x^2), ancak bunlar da aynı derecede karmaşık olacaktır.

Şimdi bakalım 1/sqrt(y). Deneyebilirsiniz f(x) = x^2 - 1/y, ancak aynı derecede karmaşık olacaktır: dx = 2xy / (y*x^2 - 1)örneğin. Şunlar için açık olmayan alternatif bir seçenek f(x)şudur:f(x) = y - 1/x^2

Sonra: dx = -f/f' = (y - 1/x^2) / (2/x^3) = 1/2 * x * (1 - y * x^2)

Ah! Bu önemsiz bir ifade değil, ama içinde sadece çarpımlar var, bölünme yok. => Daha hızlı!

Ve: tam güncelleme adımı new_x = x + dxdaha sonra okur:

x *= 3/2 - y/2 * x * x ki bu da kolaydır.

Buna birkaç yıl öncesine ait başka cevaplar da var. İşte fikir birliğinin doğru olduğu:

• Rsqrt * komutları karşılıklı karekök yaklaşık 11-12 bit arası iyi bir yaklaşım hesaplar.
• Mantis tarafından indekslenen bir arama tablosu (yani bir ROM) ile gerçekleştirilir. (Aslında, eski matematik tablolarına benzer, transistörlerden tasarruf etmek için düşük sıralı bitlerde ayarlamalar kullanan sıkıştırılmış bir arama tablosu.)
• Kullanılabilir olmasının nedeni, FPU tarafından "gerçek" karekök algoritması için kullanılan ilk tahmin olmasıdır.
• Ayrıca yaklaşık bir karşılıklı talimat var, rcp. Bu talimatların her ikisi de, FPU'nun karekök ve bölmeyi nasıl uyguladığına dair bir ipucudur.

İşte fikir birliğinin yanlış yaptığı şey:

• SSE dönemi FPU'ları, karekökleri hesaplamak için Newton-Raphson kullanmazlar. Bu, yazılımda harika bir yöntemdir, ancak bunu donanımda bu şekilde uygulamak bir hata olur.

Karşılıklı karekök hesaplamak için NR algoritması, diğerlerinin de belirttiği gibi şu güncelleme adımına sahiptir:

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

Bu, çok fazla veriye bağlı çarpma ve bir çıkarma.

Aşağıda, modern FPU'ların gerçekte kullandığı algoritma yer almaktadır.

Verilen b[0] = nbiz sayı dizisi bulabilirsiniz varsayalım Y[i]böyle b[n] = b[0] * Y[0]^2 * Y[1]^2 * ... * Y[n]^21. Sonra düşünün yaklaşımlar:

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

Açıkça x[n]yaklaşımlar sqrt(n)ve y[n]yaklaşımlar 1/sqrt(n).

İyi bir sonuç elde etmek için, karşılıklı karekök için Newton-Raphson güncelleme adımını kullanabiliriz Y[i]:

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

Sonra:

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

ve:

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

Bir sonraki önemli gözlem şudur b[i] = x[i-1] * y[i-1]. Yani:

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

Sonra:

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]))

Yani, başlangıçtaki x ve y verildiğinde, aşağıdaki güncelleme adımını kullanabiliriz:

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

Ya da meraklısı bile ayarlayabiliriz h = 0.5 * y. Bu başlatmadır:

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

Ve bu güncelleme adımı:

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

Bu Goldschmidt'in algoritmasıdır ve bunu donanımda uyguluyorsanız çok büyük bir avantajı vardır: "iç döngü" üç çarpmalı toplamadır ve başka hiçbir şey değildir ve bunlardan ikisi bağımsızdır ve ardışık düzenlenebilir.

1999'da, FPU'lar zaten bir ardışık düzenlenmiş toplama / çıkarma devresine ve ardışık düzenlenmiş bir çoğaltma devresine ihtiyaç duyuyordu, aksi takdirde SSE çok "akış" olmazdı. 1999 yılında, bu iç döngüyü, yalnızca karekök üzerinde çok fazla donanım israfına neden olmadan, tamamen boru hatlı bir şekilde uygulamak için her devreden yalnızca birine ihtiyaç duyuldu.

Bugün, elbette, programcıya maruz kalan çarpma-toplamayı birleştirdik. Yine, iç döngü, karekökleri hesaplamasanız bile (yine) genel olarak yararlı olan üç ardışık düzenlenmiş FMA'dır.

Daha hızlıdır çünkü bu talimatlar yuvarlama modlarını yok sayar ve kayan nokta istisnalarını veya normalize olmayan sayıları işlemez. Bu nedenlerden ötürü, diğer fp komutlarını sıraya dizmek, speküle etmek ve yürütmek çok daha kolaydır.