TCO olmadığında, yığını üfleme konusunda ne zaman endişelenmelisiniz?

Her seferinde JVM'yi hedefleyen yeni bir programlama dili hakkında bir tartışma var, kaçınılmaz olarak insanlar şöyle şeyler söylüyor:

"JVM kuyruk arama optimizasyonunu desteklemediğinden, çok sayıda patlayan yığın öngörüyorum"

Bu tema üzerinde binlerce varyasyon var.

Şimdi biliyorum ki, örneğin Clojure gibi bazı dillerde kullanabileceğiniz özel bir tekrar yapısı vardır.

Anlamadığım şey: Kuyruk çağrısı optimizasyonunun eksikliği ne kadar ciddi? Ne zaman endişelenmeliyim?

Ana karışıklık kaynağım muhtemelen Java'nın şimdiye kadarki en başarılı dillerden biri olması ve JVM dillerinin birkaçının oldukça iyi performans gösterdiği gerçeğinden kaynaklanıyor. Bu nasıl TCO olmaması gerçekten eğer mümkün herhangi bir endişe?

Bunu düşünün, diyelim ki Java'daki tüm döngülerden kurtulduk (derleyici yazarları grevde falan). Şimdi faktöriyel yazmak istiyoruz, bu yüzden böyle bir şeyi düzeltebiliriz

int factorial(int i){ return factorial(i, 1);}
int factorial(int i, int accum){
  if(i == 0) return accum;
  return factorial(i-1, accum * i);
}

Şimdi oldukça zeki hissediyoruz, çarpanlarımızı döngüsüz bile yazmayı başardık! Ancak test ettiğimizde, makul boyutta herhangi bir sayı ile, toplam sahip olma maliyeti olmadığından yığın akışı hataları aldığımızı fark ediyoruz.

Gerçek Java'da bu bir sorun değildir. Bir kuyruk özyinelemeli algoritmamız varsa, onu bir döngüye dönüştürebilir ve iyi olabiliriz. Ancak, döngüsüz diller ne olacak? O zaman yeni evlendin. Bu yüzden clojure bu recurforma sahiptir, onsuz, tamamlanmamış bile değildir (Sonsuz döngüler yapmanın yolu yoktur).

JVM, Frege, Kawa (Şema), Clojure'u hedefleyen fonksiyonel dil sınıfı her zaman kuyruk çağrılarının eksikliğiyle uğraşmaya çalışmaktadır, çünkü bu dillerde TC döngüler yapmanın deyimsel yoludur! Şemaya çevrilirse, yukarıdaki faktöriyel iyi bir faktöriyel olacaktır. 5000 kez döngü yapmak programınızın çökmesine neden olsaydı çok rahatsız edici olurdu. Bu, recurözel formlar, kendi kendine çağrıları optimize etme, tramplen yapma, ne olursa olsun ek açıklamalar ile çözülebilir . Ancak hepsi ya performans vuruşlarını ya da programcı üzerinde gereksiz çalışmaları zorlar.

Artık Java da serbest kalmıyor, çünkü TCO'da daha sonra özyineleme var, karşılıklı özyinelemeli işlevler ne olacak? Basitçe döngülere çevrilemezler, ancak JVM tarafından hala optimize edilmezler. Bu, Java kullanarak karşılıklı özyineleme kullanarak algoritmalar yazmaya çalışmayı oldukça tatsız kılar, çünkü iyi bir performans / aralık istiyorsanız, döngülere sığdırmak için kara büyü yapmanız gerekir.

Yani, özet olarak, bu birçok vaka için büyük bir anlaşma değil. Çoğu kuyruk çağrısı ya sadece bir yığın karenin derinliklerinde ilerler.

return foo(bar, baz); // foo is just a simple method

veya özyineleme. Ancak, buna uymayan TC sınıfı için her JVM dili acıyı hisseder.

Ancak henüz TCO'muzun olmamasının iyi bir nedeni var. JVM bize yığın izleri veriyor. TCO ile "mahkum" olduğunu bildiğimiz yığın çerçevelerini sistematik olarak ortadan kaldırıyoruz, ancak JVM bunları daha sonra bir yığın izlemesi için isteyebilir! Diyelim ki böyle bir FSM uyguluyoruz, her eyalet bir sonrakini çağırıyor. Önceki durumların tüm kayıtlarını sileriz, böylece bir iz bize hangi eyaleti gösterir, ancak oraya nasıl geldiğimizle ilgili hiçbir şey göstermez.

Ek olarak ve daha acil olarak, bayt kodu doğrulamanın büyük kısmı yığın tabanlıdır ve bayt kodunu doğru bir olasılık olmadığını doğrulamamıza izin veren şeyi ortadan kaldırır. Bu ve Java'nın döngülere sahip olması arasında, TCO, JVM mühendislerine göre biraz daha fazla sorun gibi görünüyor.

Kuyruk çağrıları optimizasyonu esas olarak kuyruk özyineleme nedeniyle önemlidir. Bununla birlikte, JVM'nin kuyruk çağrılarını optimize etmemesinin gerçekten iyi olduğu konusunda bir argüman vardır: TCO yığının bir kısmını yeniden kullandığından, bir istisnanın yığın izlemesi eksik olacak, böylece hata ayıklamayı biraz daha zorlaştıracaktır.

JVM'nin sınırlamaları üzerinde çalışmanın yolları vardır:

1. Basit kuyruk özyineleme derleyici tarafından bir döngü için optimize edilebilir.
2. Program devam eden bir tarzdaysa, “tramplen” kullanmak önemsizdir. Burada, bir işlev nihai sonucu döndürmez, daha sonra dışarıdan yürütülür. Bu teknik, bir derleyici yazarının rastgele karmaşık kontrol akışını modellemesine izin verir.

Bunun daha büyük bir örneğe ihtiyacı olabilir. Kapakları olan bir dil düşünün (ör. JavaScript veya benzeri). Faktöriyeli olarak yazabiliriz

def fac(n, acc = 1) = if (n <= 1) acc else n * fac(n-1, acc*n)

print fac(x)

Şimdi bunun yerine geri arama yapabiliriz:

def fac(n, acc = 1) =
  if (n <= 1) acc
  else        (() => fac(n-1, acc*n))  // this isn't full CPS, but you get the idea…

var continuation = (() => fac(x))
while (continuation instanceof function) {
  continuation = continuation()
}
var result = continuation
print result

Bu artık sürekli yığın alanında çalışıyor, bu da yine de kuyruk yinelemeli olduğu için biraz saçma. Bununla birlikte, bu teknik tüm kuyruk çağrılarını sabit yığın alanına düzleştirebilir . Ve eğer program CPS'de ise, bu durum çağrı kaydının genel olarak sabit olduğu anlamına gelir (CPS'de her çağrı bir kuyruk çağrısıdır).

Bu tekniğin önemli bir dezavantajı, hata ayıklamanın çok daha zor, uygulanması biraz daha zor ve daha az performans - kullandığım tüm kapanışları ve dolaylamaları görmeniz.

Bu nedenlerden dolayı, VM'nin kuyruk çağrılarını desteklememek için iyi nedenleri olan Java gibi bir kuyruk çağrısı op - dilleri kullanması büyük ölçüde tercih edilir.

Bir programdaki çağrıların önemli bir kısmı kuyruk çağrılarıdır. Her altyordamın son bir çağrısı vardır, bu nedenle her altyordamın en az bir kuyruk çağrısı vardır. Kuyruk çağrıları GOTO, bir altyordam çağrısının güvenliği ancak performans özelliklerine sahiptir .

Doğru Kuyruk Çağrılarına sahip olmak, başka türlü yazamayacağınız programları yazmanıza olanak tanır. Örneğin, bir durum makinesini ele alalım. Bir durum makinesi, her durumun bir alt rutin olması ve her bir durum geçişinin bir alt rutin çağrısı olmasıyla çok doğrudan uygulanabilir. Bu durumda, aramadan sonra arama yaptıktan sonra eyaletten eyalete geçiş yaparsınız ve aslında asla geri dönmezsiniz! Doğru Kuyruk Çağrıları olmadan, hemen yığını havaya uçururdunuz.

PTC olmadan, GOTOkontrol akışı veya bunun gibi bir şey olarak Trambolin veya istisnaları kullanmanız gerekir . Bu çok daha çirkin ve devlet makinesinin doğrudan 1: 1 temsili değil.

(I akıllıca "döngü" Örnek sıkıcı kullanılarak önlenir ne not edin. Bu PTC da dile yararlıdır bir örnek olan döngü).

TCO yerine kasıtlı olarak "Doğru Kuyruk Çağrıları" terimini kullandım. TCO bir derleyici optimizasyonudur. PTC, her derleyicinin TCO yapmasını gerektiren bir dil özelliğidir .

"JVM kuyruk arama optimizasyonunu desteklemediğinden, çok sayıda patlayan yığın öngörüyorum"

Bunu söyleyen herkes (1) kuyruk çağrısı optimizasyonunu veya (2) JVM'yi veya (3) her ikisini de anlamıyor.

Wikipedia'dan kuyruk çağrılarının tanımıyla başlayacağım (Wikipedia'yı sevmiyorsanız, işte bir alternatif ):

Bilgisayar biliminde, kuyruk çağrısı, son eylemi olarak başka bir prosedür içinde gerçekleşen alt program çağrısıdır; daha sonra çağıran prosedür tarafından derhal döndürülen bir dönüş değeri üretebilir

Aşağıdaki kodda, çağrının bar()kuyruğu foo():

private void foo() {
    // do something
    bar()
}

Kuyruk çağrısı optimizasyonu , kuyruk çağrısını gören dil uygulaması normal yöntem çağırma (yığın çerçevesi oluşturur) kullanmadığında, bunun yerine bir şube oluşturduğunda gerçekleşir. Bu bir optimizasyondur, çünkü yığın çerçevesi bellek gerektirir ve bilgileri çerçeveye (dönüş adresi gibi) çerçeveye itmek için CPU döngüleri gerektirir ve çağrı / dönüş çiftinin koşulsuz atlamadan daha fazla CPU döngüsü gerektirdiği varsayılır.

TCO genellikle özyinelemeye uygulanır, ancak tek kullanımı bu değildir. Tüm özyinelemeler için de geçerli değildir. Bir faktöriyeli hesaplamak için basit özyinelemeli kod, kuyruk çağrısı için optimize edilemez, çünkü işlevde gerçekleşen son şey bir çarpma işlemidir.

public static int fact(int n) {
    if (n <= 1) return 1;
    else return n * fact(n - 1);
}

Kuyruk çağrısı optimizasyonunu uygulamak için iki şeye ihtiyacınız vardır:

• Altyordam çağrılarına ek olarak dallanmayı destekleyen bir platform.
• Kuyruk çağrısı optimizasyonunun mümkün olup olmadığını belirleyebilen statik bir analizör.

Bu kadar. Başka bir yerde belirttiğim gibi, JVM (diğer Turing-complete mimarisi gibi) bir goto'ya sahip. Koşulsuz bir gitme olur , ancak işlevsellik bir koşullu dal kullanılarak kolayca uygulanabilir.

Statik analiz parçası zor olan şeydir. Tek bir işlev içinde sorun değil. Örneğin, işte bir özyinelemeli Scala işlevi List:

def sum(acc:Int, list:List[Int]) : Int = {
  if (list.isEmpty) acc
  else sum(acc + list.head, list.tail)
}

Bu işlev aşağıdaki bayt koduna dönüşür:

public int sum(int, scala.collection.immutable.List);
  Code:
   0:   aload_2
   1:   invokevirtual   #63; //Method scala/collection/immutable/List.isEmpty:()Z
   4:   ifeq    9
   7:   iload_1
   8:   ireturn
   9:   iload_1
   10:  aload_2
   11:  invokevirtual   #67; //Method scala/collection/immutable/List.head:()Ljava/lang/Object;
   14:  invokestatic    #73; //Method scala/runtime/BoxesRunTime.unboxToInt:(Ljava/lang/Object;)I
   17:  iadd
   18:  aload_2
   19:  invokevirtual   #76; //Method scala/collection/immutable/List.tail:()Ljava/lang/Object;
   22:  checkcast   #59; //class scala/collection/immutable/List
   25:  astore_2
   26:  istore_1
   27:  goto    0

Not goto 0sonunda. Karşılaştırıldığında, eşdeğer bir Java işlevi ( Iteratorbir Scala listesini baş ve kuyruğa bölme davranışını taklit etmek için bir kullanması gerekir ) aşağıdaki bayt koduna dönüşür. Son iki işlemin şimdi bir çağırma olduğunu ve ardından bu özyinelemeli çağırma tarafından üretilen değerin açık bir şekilde geri döndüğünü unutmayın.

public static int sum(int, java.util.Iterator);
  Code:
   0:   aload_1
   1:   invokeinterface #64,  1; //InterfaceMethod java/util/Iterator.hasNext:()Z
   6:   ifne    11
   9:   iload_0
   10:  ireturn
   11:  iload_0
   12:  aload_1
   13:  invokeinterface #70,  1; //InterfaceMethod java/util/Iterator.next:()Ljava/lang/Object;
   18:  checkcast   #25; //class java/lang/Integer
   21:  invokevirtual   #74; //Method java/lang/Integer.intValue:()I
   24:  iadd
   25:  aload_1
   26:  invokestatic    #43; //Method sum:(ILjava/util/Iterator;)I
   29:  ireturn

Tek bir fonksiyonun Kuyruk çağrı optimizasyonu önemsiz şudur: yerine böylece derleyici, aramanın sonucunu kullanan kod bulunmadığından olduğunu görebilirsiniz çağırma işlemi bir ile goto.

Hayatın zorlaştığı yer birden fazla yönteminiz varsa. JVM'nin dallanma talimatları, 80x86 gibi genel amaçlı bir işlemcinin aksine, tek bir yöntemle sınırlıdır. Özel yöntemleriniz varsa hala nispeten basittir: derleyici bu yöntemleri uygun şekilde satır içi yapmakta serbesttir, bu nedenle kuyruk çağrılarını optimize edebilir (bunun nasıl çalıştığını merak ediyorsanız, switchdavranışı kontrol etmek için bir ortak yöntem kullanmayı düşünün ). Bu tekniği aynı sınıftaki birden çok genel yönteme bile genişletebilirsiniz: derleyici yöntem gövdelerini sıralar, genel köprü yöntemleri sağlar ve dahili çağrılar atlamalara dönüşür.

Ancak, özellikle arabirimler ve sınıf yükleyiciler ışığında, farklı sınıflardaki genel yöntemleri düşündüğünüzde bu model bozulur. Kaynak düzeyinde derleyici, kuyruk çağrısı optimizasyonlarını uygulamak için yeterli bilgiye sahip değildir. Ancak, aksine bunun olmadığını aslında gerçekleştirir bilmiyorum "çıplak metal" uygulamaları, * JVM ((en azından, eski Güneş derleyici yapar). Hotspot derleyici şeklinde Bunu yapmak için bilgi var kuyruk çağrı optimizasyonları ve şüpheli değil, ama olabilir .

Bu da beni sorunuzun ikinci kısmına getiriyor, hangisini "umursalıyız?"

Açıkça görüldüğü gibi, diliniz yinelemenin tek ilkesi olarak özyinelemeyi kullanıyorsa, önemsiyorsunuz. Ancak, bu özelliğe ihtiyaç duyan diller onu uygulayabilir; tek sorun, söz konusu dil için bir derleyicinin rasgele bir Java sınıfı tarafından çağrılabilen ve çağrılabilen bir sınıf üretip üretemeyeceğidir.

Bu davanın dışında, ilgisiz olduğunu söyleyerek aşağı oy davet edeceğim. Gördüğüm özyinelemeli kodların çoğu (ve birçok grafik projesiyle çalıştım) kuyruk çağrısı optimize edilemez . Basit faktöriyör gibi, durumu oluşturmak için özyineleme kullanır ve kuyruk işlemi birleşimdir.

Kuyruk çağrısı optimize edilebilir kod için, bu kodu tekrarlanabilir bir forma çevirmek genellikle kolaydır. Örneğin, sum()daha önce gösterdiğim bu işlev genelleştirilebilir foldLeft(). Kaynağa bakarsanız , bunun aslında yinelemeli bir işlem olarak uygulandığını göreceksiniz. Jörg W Mittag'ın işlev çağrıları yoluyla uygulanan bir durum makinesi örneği vardı; atlamalara çevrilen işlev çağrılarına dayanmayan çok sayıda verimli (ve bakım yapılabilir) durum makinesi uygulaması vardır.

Tamamen farklı bir şeyle bitireceğim. SICP'deki dipnotlardan Google'a doğru yol alırsanız, buraya gelebilirsiniz . Ben şahsen benim derleyici yerine sahip altında olması durumunda çok daha ilginç bir yer bulmak JSRtarafından JUMP.