sementara (1) Vs. untuk (;;) Apakah ada perbedaan kecepatan?

Versi panjang ...

Seorang rekan kerja menegaskan hari ini setelah melihat penggunaan saya while (1)dalam skrip Perl yang for (;;)lebih cepat. Saya berpendapat bahwa mereka harus sama berharap bahwa juru bahasa akan mengoptimalkan perbedaan. Saya membuat skrip yang menjalankan 1.000.000.000 untuk iterasi loop dan jumlah yang sama saat loop dan mencatat waktu antara. Saya tidak dapat menemukan perbedaan yang berarti. Rekan kerja saya mengatakan bahwa seorang profesor telah memberi tahu dia bahwa yang while (1)melakukan perbandingan 1 == 1dan yang for (;;)tidak. Kami mengulangi tes yang sama dengan 100x jumlah iterasi dengan C ++ dan perbedaannya dapat diabaikan. Namun itu adalah contoh grafik tentang seberapa cepat kode terkompilasi dapat dibandingkan dengan bahasa scripting.

Versi pendek...

Apakah ada alasan untuk memilih while (1)lebih daripada for (;;)jika Anda membutuhkan loop tak terbatas untuk keluar?

Catatan: Jika tidak jelas dari pertanyaan. Ini murni diskusi akademik yang menyenangkan antara beberapa teman. Saya sadar ini bukan konsep super penting yang harus dipikirkan oleh semua programmer. Terima kasih atas semua jawaban hebat yang saya (dan saya yakin orang lain) telah pelajari beberapa hal dari diskusi ini.

Pembaruan: Rekan kerja yang disebutkan di atas menimbang dengan tanggapan di bawah ini.

Dikutip di sini kalau-kalau itu akan dimakamkan.

Itu datang dari programmer AMD assembly. Dia menyatakan bahwa programmer C (poeple) tidak menyadari bahwa kode mereka memiliki inefisiensi. Dia mengatakan hari ini, kompiler gcc sangat bagus, dan membuat orang seperti dia keluar dari bisnis. Dia mengatakan misalnya, dan bercerita tentang while 1vs for(;;). Saya menggunakannya sekarang karena kebiasaan tetapi gcc dan terutama interpreter akan melakukan operasi yang sama (lompatan prosesor) untuk kedua hari ini, karena mereka dioptimalkan.

Pada perl, mereka menghasilkan opcode yang sama:

$ perl -MO=Concise -e 'for(;;) { print "foo\n" }'
a  <@> leave[1 ref] vKP/REFC ->(end)
1     <0> enter ->2
2     <;> nextstate(main 2 -e:1) v ->3
9     <2> leaveloop vK/2 ->a
3        <{> enterloop(next->8 last->9 redo->4) v ->4
-        <@> lineseq vK ->9
4           <;> nextstate(main 1 -e:1) v ->5
7           <@> print vK ->8
5              <0> pushmark s ->6
6              <$> const[PV "foo\n"] s ->7
8           <0> unstack v ->4
-e syntax OK

$ perl -MO=Concise -e 'while(1) { print "foo\n" }'
a  <@> leave[1 ref] vKP/REFC ->(end)
1     <0> enter ->2
2     <;> nextstate(main 2 -e:1) v ->3
9     <2> leaveloop vK/2 ->a
3        <{> enterloop(next->8 last->9 redo->4) v ->4
-        <@> lineseq vK ->9
4           <;> nextstate(main 1 -e:1) v ->5
7           <@> print vK ->8
5              <0> pushmark s ->6
6              <$> const[PV "foo\n"] s ->7
8           <0> unstack v ->4
-e syntax OK

Demikian juga dalam GCC:

#include <stdio.h>

void t_while() {
    while(1)
        printf("foo\n");
}

void t_for() {
    for(;;)
        printf("foo\n");
}

    .file   "test.c"
    .section    .rodata
.LC0:
    .string "foo"
    .text
.globl t_while
    .type   t_while, @function
t_while:
.LFB2:
    pushq   %rbp
.LCFI0:
    movq    %rsp, %rbp
.LCFI1:
.L2:
    movl    $.LC0, %edi
    call    puts
    jmp .L2
.LFE2:
    .size   t_while, .-t_while
.globl t_for
    .type   t_for, @function
t_for:
.LFB3:
    pushq   %rbp
.LCFI2:
    movq    %rsp, %rbp
.LCFI3:
.L5:
    movl    $.LC0, %edi
    call    puts
    jmp .L5
.LFE3:
    .size   t_for, .-t_for
    .section    .eh_frame,"a",@progbits
.Lframe1:
    .long   .LECIE1-.LSCIE1
.LSCIE1:
    .long   0x0
    .byte   0x1
    .string "zR"
    .uleb128 0x1
    .sleb128 -8
    .byte   0x10
    .uleb128 0x1
    .byte   0x3
    .byte   0xc
    .uleb128 0x7
    .uleb128 0x8
    .byte   0x90
    .uleb128 0x1
    .align 8
.LECIE1:
.LSFDE1:
    .long   .LEFDE1-.LASFDE1
.LASFDE1:
    .long   .LASFDE1-.Lframe1
    .long   .LFB2
    .long   .LFE2-.LFB2
    .uleb128 0x0
    .byte   0x4
    .long   .LCFI0-.LFB2
    .byte   0xe
    .uleb128 0x10
    .byte   0x86
    .uleb128 0x2
    .byte   0x4
    .long   .LCFI1-.LCFI0
    .byte   0xd
    .uleb128 0x6
    .align 8
.LEFDE1:
.LSFDE3:
    .long   .LEFDE3-.LASFDE3
.LASFDE3:
    .long   .LASFDE3-.Lframe1
    .long   .LFB3
    .long   .LFE3-.LFB3
    .uleb128 0x0
    .byte   0x4
    .long   .LCFI2-.LFB3
    .byte   0xe
    .uleb128 0x10
    .byte   0x86
    .uleb128 0x2
    .byte   0x4
    .long   .LCFI3-.LCFI2
    .byte   0xd
    .uleb128 0x6
    .align 8
.LEFDE3:
    .ident  "GCC: (Ubuntu 4.3.3-5ubuntu4) 4.3.3"
    .section    .note.GNU-stack,"",@progbits

Jadi saya kira jawabannya adalah, mereka sama dalam banyak kompiler. Tentu saja, untuk beberapa kompiler lain ini mungkin tidak selalu demikian, tetapi kemungkinan kode di dalam loop akan menjadi beberapa ribu kali lebih mahal daripada loop itu sendiri, jadi siapa yang peduli?

Dengan menggunakan GCC, keduanya sepertinya dikompilasi dengan bahasa assembly yang sama:

L2:
        jmp     L2

Tidak ada banyak alasan untuk memilih satu dari yang lain. Saya pikir itu while(1)dan terutama while(true)lebih mudah dibaca daripada for(;;), tapi itu hanya preferensi saya.

Tidak ada perbedaan menurut standar. 6.5.3 / 1 memiliki:

Pernyataan untuk

for ( for-init-statement ; conditionopt ; expressionopt ) statement

setara dengan

{
  for-init-statement
  while ( condition ) {
    statement
    expression ;
  }
}

Dan 6.5.3 / 2 memiliki:

Salah satu atau keduanya dari kondisi dan ekspresi dapat dihilangkan. Kondisi yang hilang membuat klausa yang tersirat sementara setara dengan while (true).

Jadi menurut standar C ++ kode:

for (;;);

persis sama dengan:

{
  while (true) {
    ;
    ;
  }
}

Kompiler Visual C ++ digunakan untuk memancarkan peringatan

while (1) 

(Ekspresi konstan) tetapi tidak untuk

for (;;)

Saya telah melanjutkan praktik lebih memilih for (;;)untuk alasan itu, tetapi saya tidak tahu apakah kompiler masih melakukannya hari ini.

for(;;) adalah satu karakter yang kurang untuk mengetik jika Anda ingin pergi ke arah itu untuk mengoptimalkan hal-hal.

Turbo C dengan kompiler lama ini for(;;)menghasilkan kode yang lebih cepat while(1).

Hari ini gcc, Visual C (saya pikir hampir semua) kompiler mengoptimalkan dengan baik, dan CPU dengan 4,7 MHz jarang digunakan.

Pada hari-hari for( i=10; i; i-- )itu lebih cepat daripada for( i=1; i <=10; i++ ), karena perbandingannya iadalah 0, menghasilkan lompatan bersyarat CPU-Zero-Flag. Dan Zero-Flag telah dimodifikasi dengan operasi pengurangan terakhir ( i-- ), tidak diperlukan operasi cmp tambahan.

    call    __printf_chk
    decl    %ebx          %ebx=iterator i 
    jnz     .L2
    movl    -4(%ebp), %ebx
    leave

dan di sini dengan for(i=1; i<=10; i++)cmpl tambahan:

    call    __printf_chk
    incl    %ebx
    cmpl    $11, %ebx
    jne     .L2
    movl    -4(%ebp), %ebx
    leave

Untuk semua orang yang berdebat Anda tidak boleh menggunakan indefinte while loop, dan menyarankan hal-hal gila seperti menggunakan open goto (serius, aduh)

while (1) {
     last if( condition1 );
     code();
     more_code(); 
     last if( condition2 ); 
     even_more_code(); 
}

Tidak bisa diwakili secara efektif dengan cara lain. Bukan tanpa membuat variabel keluar dan melakukan sihir hitam agar tetap disinkronkan.

Jika Anda memiliki kecenderungan untuk sintaks yang lebih goto-esque, gunakan sesuatu yang waras yang membatasi ruang lingkup.

flow: { 

   if ( condition ){ 
      redo flow;
   }
   if ( othercondition ){ 
       redo flow;
   }
   if ( earlyexit ){ 
       last flow;
   }
   something(); # doesn't execute when earlyexit is true 
}

Akhirnya Kecepatan tidak begitu penting

Mengkhawatirkan tentang seberapa efektif kecepatan membangun looping yang berbeda adalah buang-buang waktu. Optimalisasi prematur melalui dan melalui. Saya tidak bisa memikirkan situasi apa pun yang pernah saya lihat di mana kode profil menemukan kemacetan dalam pilihan saya membangun perulangan.

Umumnya bagaimana loop dan bagaimana loop.

Anda harus "mengoptimalkan" agar mudah dibaca dan ringkas, dan menulis apa pun yang terbaik untuk menjelaskan masalah kepada pengisap miskin berikutnya yang menemukan kode Anda.

Jika Anda menggunakan trik "goto LABEL" yang disebutkan oleh seseorang, dan saya harus menggunakan kode Anda, bersiaplah untuk tidur dengan satu mata terbuka, terutama jika Anda melakukannya lebih dari sekali, karena hal-hal semacam itu menciptakan kode spageti yang mengerikan .

Hanya karena Anda dapat membuat kode spaghetti bukan berarti Anda harus melakukannya

Dari Stroustrup, TC ++ PL (edisi ke-3), §6.1.1:

Notasi penasaran for (;;)adalah cara standar untuk menentukan loop tak terbatas; Anda bisa mengucapkannya "selamanya". [...] while (true)adalah alternatif.

Saya lebih suka for (;;).

Jika kompiler tidak melakukan optimasi apa pun, for(;;)akan selalu lebih cepat daripadawhile(true) . Ini karena sementara-pernyataan mengevaluasi kondisi setiap saat, tetapi untuk-pernyataan adalah lompatan tanpa syarat. Tetapi jika kompiler mengoptimalkan aliran kontrol, ia dapat menghasilkan beberapa opcode. Anda dapat membaca kode pembongkaran dengan sangat mudah.

PS Anda bisa menulis loop tak terbatas seperti ini:

#define EVER ;;
  //...
  for (EVER) {
    //...
  }

Saya pernah mendengar tentang ini sekali.

Itu datang dari programmer AMD assembly. Dia menyatakan bahwa programmer C (orang-orang) tidak menyadari bahwa kode mereka memiliki inefisiensi. Dia mengatakan hari ini, kompiler gcc sangat bagus, dan membuat orang seperti dia keluar dari bisnis. Dia mengatakan misalnya, dan bercerita tentang while 1vs for(;;). Saya menggunakannya sekarang karena kebiasaan tetapi gcc dan terutama interpreter akan melakukan operasi yang sama (lompatan prosesor) untuk kedua hari ini, karena mereka dioptimalkan.

Dalam versi bahasa kompilasi yang dioptimalkan, seharusnya tidak ada perbedaan yang berarti antara keduanya. Seharusnya keduanya tidak melakukan perbandingan saat runtime, mereka hanya akan mengeksekusi kode loop sampai Anda keluar dari loop secara manual (misalnya dengan a break).

Saya terkejut bahwa tidak ada yang diuji dengan benar for (;;)dibandingkan while (1)di perl!

Karena perl adalah bahasa yang diinterpretasikan, waktu untuk menjalankan skrip perl tidak hanya terdiri dari fase eksekusi (yang dalam hal ini sama) tetapi juga fase interpretasi sebelum eksekusi. Kedua fase ini harus diperhitungkan saat melakukan perbandingan kecepatan.

Untungnya perl memiliki modul Benchmark yang nyaman yang dapat kita gunakan untuk mengimplementasikan benchmark seperti berikut:

#!/usr/bin/perl -w

use Benchmark qw( cmpthese );

sub t_for   { eval 'die; for (;;) { }'; }
sub t_for2  { eval 'die; for (;;)  { }'; }
sub t_while { eval 'die; while (1) { }'; }

cmpthese(-60, { for => \&t_for, for2 => \&t_for2, while => \&t_while });

Perhatikan bahwa saya menguji dua versi berbeda dari loop tak terbatas: satu yang lebih pendek dari loop sementara dan satu lagi yang memiliki ruang ekstra untuk membuatnya panjang sama dengan loop sementara.

Di Ubuntu 11.04 x86_64 dengan perl 5.10.1 saya mendapatkan hasil berikut:

          Nilai untuk2 sementara
untuk 100588 / s - -0% -2%
for2 100937 / s 0% - -1%
sementara 102147 / s 2% 1% -

Loop sementara jelas merupakan pemenang di platform ini.

Pada FreeBSD 8.2 x86_64 dengan perl 5.14.1:

         Nilai untuk2 sementara
untuk 53453 / s - -0% -2%
for2 53552 / s 0% - -2%
sementara 54564 / s 2% 2% -

Sedangkan loop adalah pemenangnya juga di sini.

Pada FreeBSD 8.2 i386 dengan perl 5.14.1:

         Nilai sementara untuk for2
sementara 24311 / s - -1% -1%
untuk 24481 / s 1% - -1%
for2 24637 / s 1% 1% -

Secara mengejutkan for for dengan ruang tambahan adalah pilihan tercepat di sini!

Kesimpulan saya adalah bahwa while loop harus digunakan pada platform x86_64 jika programmer mengoptimalkan kecepatan. Jelas a for loop harus digunakan ketika mengoptimalkan ruang. Sayangnya hasil saya tidak dapat disimpulkan tentang platform lain.

Secara teori, kompiler yang sepenuhnya naif dapat menyimpan literal '1' dalam biner (ruang pemborosan) dan memeriksa untuk melihat apakah 1 == 0 setiap iterasi (membuang-buang waktu dan lebih banyak ruang).

Namun pada kenyataannya, bahkan dengan optimisasi "tidak", kompiler masih akan mengurangi keduanya menjadi sama. Mereka juga dapat memancarkan peringatan karena bisa menunjukkan kesalahan logis. Misalnya, argumen dari whiledapat didefinisikan di tempat lain dan Anda tidak menyadari itu konstan.

Saya terkejut tidak ada yang menawarkan bentuk yang lebih langsung, sesuai dengan perakitan yang diinginkan:

forever:
     do stuff;
     goto forever;

while(1)adalah ungkapan for(;;)yang diakui oleh sebagian besar penyusun.

Saya senang melihat perl mengakui until(0)juga.

Untuk meringkas perdebatan for (;;)vs while (1)jelas bahwa yang pertama lebih cepat pada hari-hari kompiler tidak mengoptimalkan yang lebih lama, itu sebabnya Anda cenderung melihatnya di basis kode yang lebih lama seperti komentar kode Lions Unix Source, namun di era badass mengoptimalkan kompiler keuntungan tersebut dioptimalkan jauh ditambah dengan fakta bahwa yang terakhir lebih mudah dipahami daripada yang sebelumnya saya percaya bahwa itu akan lebih disukai.

Baru saja menemukan utas ini (meskipun terlambat beberapa tahun).

Saya pikir saya menemukan alasan sebenarnya mengapa "untuk (;;)" lebih baik daripada "sementara (1)".

sesuai dengan "standar pengkodean barr 2018"

Kernighan & Ritchie long ago recommended for (;;) , which has the additional benefit
of insuring against the visually-confusing defect of a while (l); referencing a variable ‘l’.

pada dasarnya, ini bukan masalah kecepatan tetapi masalah keterbacaan. Bergantung pada font / cetak kode nomor satu (1) untuk sementara waktu mungkin terlihat seperti huruf kecil l.

yaitu 1 vs l. (dalam beberapa font ini terlihat identik).

Jadi sementara (1) mungkin terlihat seperti beberapa while tergantung pada variabel huruf L.

sementara (benar) mungkin juga bekerja tetapi dalam beberapa kasus C yang lama dan tertanam C benar / salah belum didefinisikan kecuali stdbool.h disertakan.

Saya akan berpikir bahwa keduanya sama dalam hal kinerja. Tapi saya lebih suka sementara (1) untuk keterbacaan tetapi saya mempertanyakan mengapa Anda membutuhkan loop tak terbatas.

Mereka sama. Ada banyak pertanyaan yang lebih penting untuk direnungkan.