Kompiler C ++ mana, yang melakukan optimasi rekursi ekor?

Tampaknya bagi saya itu akan bekerja dengan sangat baik untuk melakukan optimasi rekursi ekor di C dan C ++, namun saat debugging saya sepertinya tidak pernah melihat frame stack yang menunjukkan optimasi ini. Itu agak bagus, karena tumpukan memberi tahu saya seberapa dalam rekursi itu. Namun, pengoptimalan juga akan menyenangkan.

Apakah ada kompiler C ++ yang melakukan optimasi ini? Mengapa? Kenapa tidak?

Bagaimana cara saya memberitahu kompiler untuk melakukannya?

• Untuk MSVC: /O2atau/Ox
• Untuk GCC: -O2atau-O3

Bagaimana kalau memeriksa apakah kompiler telah melakukan ini dalam kasus tertentu?

• Untuk MSVC, aktifkan output PDB untuk dapat melacak kode, lalu periksa kodenya
• Untuk GCC ..?

Saya masih akan mengambil saran untuk bagaimana menentukan apakah fungsi tertentu dioptimalkan seperti ini oleh kompiler (meskipun saya merasa meyakinkan bahwa Konrad menyuruh saya untuk menganggapnya)

Selalu mungkin untuk memeriksa apakah kompiler melakukan ini sama sekali dengan membuat rekursi tak terbatas dan memeriksa apakah itu menghasilkan infinite loop atau stack overflow (saya melakukan ini dengan GCC dan menemukan itu -O2sudah cukup), tapi saya ingin menjadi mampu memeriksa fungsi tertentu yang saya tahu akan berakhir pula. Saya ingin memiliki cara mudah untuk memeriksa ini :)

Setelah beberapa pengujian, saya menemukan bahwa destruktor merusak kemungkinan melakukan optimasi ini. Kadang-kadang layak untuk mengubah cakupan variabel dan temporal tertentu untuk memastikan mereka keluar dari ruang lingkup sebelum pernyataan pengembalian dimulai.

Jika ada destructor yang perlu dijalankan setelah tail-call, optimasi tail-call tidak dapat dilakukan.

Semua kompiler arus utama saat ini melakukan optimasi panggilan ekor dengan cukup baik (dan telah dilakukan selama lebih dari satu dekade), bahkan untuk panggilan rekursif bersama seperti:

int bar(int, int);

int foo(int n, int acc) {
    return (n == 0) ? acc : bar(n - 1, acc + 2);
}

int bar(int n, int acc) {
    return (n == 0) ? acc : foo(n - 1, acc + 1);
}

Membiarkan kompiler melakukan optimasi secara langsung: Aktifkan optimasi untuk kecepatan:

• Untuk MSVC, gunakan /O2atau /Ox.
• Untuk GCC, Dentang dan ICC, gunakan -O3

Cara mudah untuk memeriksa apakah kompiler melakukan optimasi adalah dengan melakukan panggilan yang jika tidak akan menghasilkan stack overflow - atau melihat output perakitan.

Sebagai catatan sejarah yang menarik, optimisasi panggilan ekor untuk C ditambahkan ke GCC dalam rangka tesis diploma oleh Mark Probst. Tesis ini menggambarkan beberapa peringatan yang menarik dalam implementasi. Itu layak dibaca.

gcc 4.3.2 sepenuhnya menguraikan fungsi ini ( atoi()implementasi jelek / sepele ) ke main(). Level optimisasi adalah -O1. Saya perhatikan jika saya bermain-main dengannya (bahkan mengubahnya dari staticmenjadi extern, rekursi ekor hilang cukup cepat, jadi saya tidak akan bergantung padanya untuk kebenaran program.

#include <stdio.h>
static int atoi(const char *str, int n)
{
    if (str == 0 || *str == 0)
        return n;
    return atoi(str+1, n*10 + *str-'0');
}
int main(int argc, char **argv)
{
    for (int i = 1; i != argc; ++i)
        printf("%s -> %d\n", argv[i], atoi(argv[i], 0));
    return 0;
}

Seperti halnya yang jelas (kompiler tidak melakukan optimasi semacam ini kecuali Anda memintanya), ada kerumitan tentang optimasi panggilan ekor di C ++: destructors.

Diberikan sesuatu seperti:

   int fn(int j, int i)
   {
      if (i <= 0) return j;
      Funky cls(j,i);
      return fn(j, i-1);
   }

Compiler tidak dapat (secara umum) mengoptimalkan panggilan karena ini perlu memanggil destruktor cls setelah panggilan rekursif kembali.

Terkadang kompilator dapat melihat bahwa destruktor tidak memiliki efek samping yang terlihat secara eksternal (sehingga dapat dilakukan lebih awal), tetapi seringkali tidak.

Bentuk yang sangat umum dari ini adalah di mana Funkysebenarnya astd::vector atau serupa.

Sebagian besar kompiler tidak melakukan optimasi dalam bentuk debug.

Jika menggunakan VC, coba versi rilis dengan dinyalakan info PDB - ini akan membuat Anda menelusuri aplikasi yang dioptimalkan dan semoga Anda akan melihat apa yang Anda inginkan. Perhatikan, bagaimanapun, bahwa debugging dan penelusuran build yang dioptimalkan akan membuat Anda berputar-putar di mana-mana, dan sering kali Anda tidak dapat memeriksa variabel secara langsung karena mereka hanya berakhir di register atau dioptimalkan sepenuhnya sepenuhnya. Ini pengalaman yang "menarik" ...

Seperti yang disebutkan Greg, kompiler tidak akan melakukannya dalam mode debug. Tidak apa-apa untuk debug build menjadi lebih lambat daripada build prod, tetapi mereka seharusnya tidak crash lebih sering: dan jika Anda bergantung pada optimisasi panggilan ekor, mereka mungkin melakukan hal itu. Karena itu, seringkali yang terbaik adalah menulis ulang panggilan ekor sebagai loop normal. :-(