Döngü açma ne zaman hala yararlıdır?

Döngü açarak son derece performans açısından kritik bazı kodları (bir monte carlo simülasyonunda milyonlarca kez denilen hızlı sıralama algoritması) optimize etmeye çalışıyorum. İşte hızlandırmaya çalıştığım iç döngü:

// Search for elements to swap.
while(myArray[++index1] < pivot) {}
while(pivot < myArray[--index2]) {}

Şunun gibi bir şeye geçmeyi denedim:

while(true) {
    if(myArray[++index1] < pivot) break;
    if(myArray[++index1] < pivot) break;
    // More unrolling
}


while(true) {
    if(pivot < myArray[--index2]) break;
    if(pivot < myArray[--index2]) break;
    // More unrolling
}

Bu kesinlikle bir fark yaratmadı, ben de onu daha okunaklı hale getirdim. Döngü açmayı denediğim diğer zamanlarda da benzer deneyimler yaşadım. Modern donanımdaki branş tahmin edicilerinin kalitesi düşünüldüğünde, döngü açma işlemi ne zaman yararlı bir optimizasyon olur?

Bağımlılık zincirlerini kırabilirseniz döngü açma mantıklıdır. Bu, bozuk veya süper skaler bir CPU'ya işleri daha iyi planlama ve böylece daha hızlı çalışma imkanı verir.

Basit bir örnek:

for (int i=0; i<n; i++)
{
  sum += data[i];
}

Burada argümanların bağımlılık zinciri çok kısadır. Veri dizisinde bir önbellek kaybınız olduğu için bir durma yaşarsanız, işlemci beklemekten başka bir şey yapamaz.

Öte yandan bu kod:

for (int i=0; i<n; i+=4)
{
  sum1 += data[i+0];
  sum2 += data[i+1];
  sum3 += data[i+2];
  sum4 += data[i+3];
}
sum = sum1 + sum2 + sum3 + sum4;

daha hızlı koşabilir. Bir hesaplamada bir önbelleği kaçırırsanız veya başka bir durakla karşılaşırsanız, durmaya bağlı olmayan başka üç bağımlılık zinciri vardır. Arızalı bir CPU bunları çalıştırabilir.

Bunlar herhangi bir fark yaratmaz çünkü aynı sayıda karşılaştırma yapıyorsunuz. İşte daha iyi bir örnek. Onun yerine:

for (int i=0; i<200; i++) {
  doStuff();
}

yazmak:

for (int i=0; i<50; i++) {
  doStuff();
  doStuff();
  doStuff();
  doStuff();
}

O zaman bile neredeyse kesinlikle önemli olmayacak, ancak şu anda 200 yerine 50 karşılaştırma yapıyorsunuz (karşılaştırmanın daha karmaşık olduğunu hayal edin).

Bununla birlikte, manuel döngü açma genel olarak büyük ölçüde tarihin bir eseridir. Bu, önemli olduğunda iyi bir derleyicinin sizin için yapacağı şeylerin büyüyen bir başka listesidir. Örneğin, çoğu insan yazmaya zahmet etmeyin x <<= 1veya x += xyerine x *= 2. Siz sadece yazın x *= 2ve derleyici onu sizin için en iyi olana göre optimize eder.

Temel olarak, derleyicinizi ikinci kez tahmin etmeye giderek daha az ihtiyaç duyulmaktadır.

Modern donanımdaki dal tahminine bakılmaksızın, çoğu derleyici yine de sizin için döngü açma işlemi yapar.

Derleyicinizin sizin için ne kadar optimizasyon yaptığını öğrenmek faydalı olacaktır.

Felix von Leitner'ın sunumunu konu hakkında çok aydınlatıcı buldum . Okumanızı tavsiye ederim. Özet: Modern derleyiciler ÇOK akıllıdır, bu nedenle el optimizasyonları neredeyse hiçbir zaman etkili değildir.

Anladığım kadarıyla, modern derleyiciler halihazırda uygun yerlerde döngüleri açıyor - bir örnek gcc, optimizasyon bayraklarını geçerse kılavuzda şunu söylüyor:

Derleme zamanında veya döngüye girildiğinde yineleme sayısı belirlenebilen döngüleri geri alma.

Dolayısıyla, pratikte derleyicinizin sizin için önemsiz durumları yapması muhtemeldir. Bu nedenle, derleyicinin kaç tane yinelemeye ihtiyaç duyacağını belirlemesi için döngülerinizden mümkün olduğunca çoğunun kolay olduğundan emin olmak size kalmıştır.

Döngü açma, ister elle açma isterse derleyiciyi açma olsun, özellikle daha yeni x86 CPU'larda (Core 2, Core i7) genellikle ters yönde verimli olabilir. Alt satır: Kodunuzu, bu kodu dağıtmayı planladığınız CPU'lar üzerinde döngü açarak ve döngü olmadan kıyaslayın.

Bilmeden denemek bunu yapmanın yolu değildir.
Bu sıralama, toplam sürenin yüksek bir yüzdesini mi alıyor?

Döngü açmanın tüm yaptığı, durma koşulu için karşılaştırma ve atlama, artan / azalan döngü ek yükünü azaltmaktır. Döngüde yaptığınız şey, döngünün kendisinden daha fazla talimat döngüsü gerektiriyorsa, yüzde olarak çok fazla gelişme görmeyeceksiniz.

İşte maksimum performansın nasıl alınacağına dair bir örnek.

Döngü açma, belirli durumlarda yardımcı olabilir. Tek kazanç bazı testleri atlamak değil!

Örneğin, skaler değiştirmeye, yazılımın önceden getirilmesinin verimli bir şekilde eklenmesine izin verebilir ... Agresif bir şekilde kaydırarak bunun ne kadar yararlı olabileceğini (-O3 ile bile çoğu döngüde kolayca% 10 hızlanma elde edebilirsiniz) gerçekten şaşıracaksınız.

Yine de daha önce söylendiği gibi, bu döngüye çok bağlıdır ve derleyici ve deney gereklidir. Bir kural yapmak zordur (veya listeyi açmak için derleyici buluşsal yöntemi mükemmel olacaktır)

Döngü açma tamamen probleminizin boyutuna bağlıdır. Tamamen algoritmanızın boyutu daha küçük çalışma gruplarına indirebilmesine bağlıdır. Yukarıda yaptığın şey öyle görünmüyor. Bir monte carlo simülasyonunun açılıp kapanmayacağından bile emin değilim.

Döngü açma için iyi bir senaryo bir görüntüyü döndürmek olacaktır. Ayrı çalışma gruplarını döndürebildiğiniz için. Bunun işe yaraması için yineleme sayısını azaltmanız gerekir.

Döngüde ve döngüde çok sayıda yerel değişken varsa, döngü açma hala yararlıdır. Döngü indeksi için bir tane kaydetmek yerine bu kayıtları daha fazla yeniden kullanmak.

Örneğinizde, kayıtları aşırı kullanmak yerine az miktarda yerel değişken kullanıyorsunuz.

Karşılaştırma (döngü sonuna kadar) test, özellikle de harici bir işleve bağlıysa, karşılaştırma ağırsa (yani talimatsız ) önemli bir dezavantajdır .

Döngü açma, CPU'nun dal tahmini için farkındalığını artırmaya da yardımcı olur, ancak bunlar yine de olur.