(1) Vs. for (;;) Hız farkı var mı?

Uzun versiyon...

Bir iş arkadaşı , daha hızlı while (1)olan bir Perl betiğindeki kullanımımı gördükten sonra bugün iddia etti for (;;). Tercümanın herhangi bir farkı optimize etmesi umuduyla aynı olmaları gerektiğini savundum. Döngü yinelemeleri için 1.000.000.000 çalıştıracak ve aynı sayıda döngüler çalıştıracak ve arasındaki süreyi kaydedecek bir komut dosyası ayarladım. Kayda değer bir fark bulamadım. İş arkadaşım bir profesörün ona while (1)bir karşılaştırma yaptığını 1 == 1ve for (;;)olmadığını söylediğini söyledi . Aynı testi C ++ ile 100x yineleme sayısıyla tekrarladık ve fark ihmal edilebilir düzeydeydi. Bununla birlikte, bir derleme koduna karşı derlenmiş kodun ne kadar hızlı olabileceğinin grafik bir örneğiydi.

Kısa versiyon...

Eğer kaçmak için sonsuz bir döngüye ihtiyacınız varsa bir while (1)fazla tercih etmek için herhangi bir neden var mı for (;;)?

Not: Sorudan net değilse. Bu, birkaç arkadaş arasında tamamen eğlenceli bir akademik tartışma oldu. Bunun, tüm programcıların acı çekmesi gereken çok önemli bir kavram olmadığının farkındayım. Tüm bu harika cevaplar için teşekkürler (ve eminim diğerleri) bu tartışmadan birkaç şey öğrendim.

Güncelleme: Sözü edilen iş arkadaşı aşağıda bir yanıtla tartıldı.

Gömülmesi durumunda burada alıntılanmıştır.

Bir AMD montaj programcısından geldi. C programcılarının (insanlar) kodlarının verimsiz olduğunu anlamadıklarını belirtti. Ancak bugün, gcc derleyicilerinin çok iyi olduğunu ve onun gibi insanları işten çıkardığını söyledi. Örneğin dedi ve bana while 1vs hakkında söyledi for(;;). Şimdi alışkanlık dışında kullanıyorum ama gcc ve özellikle tercümanlar optimize edildiğinden, her iki gün için de aynı işlemi (işlemci atlama) yapacaklar.

Perl'de aynı opcode neden olurlar:

$ 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

Aynı şekilde GCC'de:

#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

Yani sanırım cevap, birçok derleyicide aynı. Tabii ki, diğer bazı derleyiciler için durum böyle olmayabilir, ancak döngü içindeki kod zaten döngüden birkaç bin kat daha pahalı olacak, bu yüzden kimin umurunda?

GCC kullanarak, her ikisi de aynı montaj dilini derliyor gibi görünüyor:

L2:
        jmp     L2

Birini diğerine tercih etmek için fazla bir neden yok. Bence while(1)özellikle while(true)daha okunabilir for(;;), ama bu sadece benim tercihim.

Standarda göre hiçbir fark yoktur. 6.5.3 / 1 aşağıdakilere sahiptir:

For ifadesi

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

eşittir

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

Ve 6.5.3 / 2'de şunlar var:

Koşulun ve ifadenin biri veya her ikisi de atlanabilir. Eksik bir koşul, ima edilen while deyiminin while (true) ifadesine eşdeğer olmasını sağlar.

C ++ standardına göre kod:

for (;;);

tam olarak aynıdır:

{
  while (true) {
    ;
    ;
  }
}

Visual C ++ derleyicisi için uyarı yaymak için kullanılır

while (1) 

(sabit ifade) için değil

for (;;)

for (;;)Bu nedenle tercih etme pratiğine devam ettim , ancak derleyicinin bu günlerde hala bunu yapıp yapmadığını bilmiyorum.

for(;;) bir şeyleri optimize etmek için bu yönde gitmek istiyorsanız yazmak için daha az karakterdir.

Bu eski derleyicilere sahip Turbo C for(;;), daha hızlı kod sağlar while(1).

Bugün gcc, Visual C (sanırım neredeyse hepsi) derleyiciler iyi optimize eder ve 4.7 MHz'lik CPU'lar nadiren kullanılır.

O günlerde a for( i=10; i; i-- )daha hızlıydı for( i=1; i <=10; i++ ), çünkü karşılaştırma i0 olduğundan, CPU-Zero-Flag koşullu Jump ile sonuçlanır. Ve Sıfır Bayrağı son azaltma işlemiyle değiştirildi ( i-- ), fazladan bir cmp işlemine gerek yok.

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

ve burada for(i=1; i<=10; i++)ekstra cmpl ile:

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

Tüm insanlar açık kullanarak while döngüleri indefinte kullanmamalısınız savunarak ve benzeri aptal şeyler düşündüren için goto ifadesi 'ın (gerçekten, ah)

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

Gerçekten başka hiçbir şekilde etkili bir şekilde temsil edilemez. Bir çıkış değişkeni oluşturmadan ve senkronize tutmak için kara büyü yapmadan olmaz.

Daha goto-esque sözdizimi için bir tutkunuz varsa, kapsamı sınırlayan aklı başında bir şey kullanın.

flow: { 

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

Sonuçta Hız o kadar önemli değil

Farklı döngü yapılarının hız açısından ne kadar etkili olduğu konusunda endişe etmek büyük bir zaman kaybıdır. Aracılığıyla erken optimizasyon. Profil oluşturma kodunun döngü oluşturucu seçimimde darboğazlar bulduğunu gördüğüm herhangi bir durumu düşünemiyorum.

Genellikle döngü nasıl ve döngü ne .

Okunabilirlik ve özlü olma için "optimize etmelisiniz" ve sorunu açıklayan en iyi olanı kodunuzu bulan bir sonraki kötü emiciye yazmalısınız.

Bahsedilen "goto LABEL" numarasını kullanırsanız ve kodunuzu kullanmam gerekiyorsa, özellikle bir kereden fazla yaparsanız, bir gözü açık olarak uyumaya hazır olun, çünkü bu tür şeyler yaratır korkunç spagetti kodu .

Eğer sırf yapabilirsiniz spagetti oluşturmak kod size anlamına gelmez should

Stroustrup'tan, TC ++ PL (3. baskı), §6.1.1:

Meraklı gösterim for (;;), sonsuz bir döngü belirtmenin standart yoludur; "sonsuza dek" telaffuz edebilirsin. [...] while (true)bir alternatiftir.

Ben tercih ederim for (;;).

Derleyici herhangi bir optimizasyon yapmazsa, for(;;)her zamankinden daha hızlı olurwhile(true) . Bunun nedeni while-ifadesinin durumu her zaman değerlendirmesidir, ancak for-ifadesi koşulsuz bir sıçramadır. Ancak derleyici kontrol akışını optimize ederse, bazı opodlar üretebilir. Sökme kodunu çok kolay okuyabilirsiniz.

PS böyle sonsuz bir döngü yazabilirsiniz:

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

Bunu bir kez duydum.

Bir AMD montaj programcısından geldi. C programcılarının (insanlar) kodlarının verimsiz olduğunu anlamadıklarını belirtti. Ancak bugün, gcc derleyicilerinin çok iyi olduğunu ve onun gibi insanları işten çıkardığını söyledi. Örneğin dedi ve bana while 1vs hakkında söyledi for(;;). Şimdi alışkanlık dışında kullanıyorum ama gcc ve özellikle tercümanlar optimize edildiğinden, her iki gün için de aynı işlemi (işlemci atlama) yapacaklar.

Derlenmiş bir dilin optimize edilmiş bir yapısında, ikisi arasında kayda değer bir fark olmamalıdır. İkisi de çalışma zamanında herhangi bir karşılaştırma yapmamalıdır, döngüden manuel olarak çıkana kadar döngü kodunu yürütürler (örneğin a ile break).

Kimsenin perl'e for (;;)karşı düzgün bir şekilde test edilmemesine şaşırdım while (1)!

Perl yorumlanmış dil olduğundan, perl betiğini çalıştırma süresi yalnızca yürütme aşamasından (bu durumda aynıdır) değil, aynı zamanda yürütmeden önceki yorumlama aşamasından oluşur. Hız karşılaştırması yapılırken bu aşamaların her ikisi de dikkate alınmalıdır.

Neyse ki perl, aşağıdaki gibi bir ölçüt uygulamak için kullanabileceğimiz kullanışlı bir Benchmark modülüne sahiptir:

#!/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 });

Sonsuz for döngüsünün iki farklı versiyonunu test ettiğime dikkat edin: biri while döngüsünden daha kısa ve diğeri while döngüsü ile aynı uzunlukta yapmak için fazladan bir alana sahip.

Perl 5.10.1 ile Ubuntu 11.04 x86_64 üzerinde Aşağıdaki sonuçları elde ediyorum:

          Süre için oran2
100588 / s için -% -0% -2
for2 100937 / s% 0 -% -1
102147 / s% 2% 1 -

While döngüsü bu platformda açıkça kazanıyor.

Perl 5.14.1 ile FreeBSD 8.2 x86_64'te:

         Süre için oran2
53453 / s için -% -0% -2
for2 53552 / s% 0 -% -2
54564 / s% 2% 2 -

Döngü de burada kazanan.

Perl 5.14.1 ile FreeBSD 8.2 i386'da:

         For2 için oy ver
24311 / s -% -1 -1%
24481 / s için% 1 -% -1
for2 24637 / s% 1% 1 -

Şaşırtıcı bir şekilde ekstra bir alana sahip for döngüsü burada en hızlı seçimdir!

Sonuç olarak, programcı hız için optimizasyon yapıyorsa while döngüsü x86_64 platformunda kullanılmalıdır. Açıkçası alan için optimizasyon yaparken bir for döngüsü kullanılmalıdır. Sonuçlarım maalesef diğer platformlarla ilgili olarak net değil.

Teorik olarak, tamamen naif bir derleyici, '1' hazır bilgisini ikili dosyada (israf boşluğu) saklayabilir ve her yinelemede 1 == 0 olup olmadığını (israf süresi ve daha fazla alan) kontrol edebilir.

Ancak gerçekte, "hayır" optimizasyonlarında bile, derleyiciler her ikisini de aynı şekilde azaltacaktır. Ayrıca mantıklı bir hataya işaret edebileceğinden uyarılar yayınlayabilirler. Örneğin, argümanı whilebaşka bir yerde tanımlanabilir ve bunun sabit olduğunu fark edemezsiniz.

Kimsenin istenen düzene karşılık gelen daha doğrudan bir form sunmadığına şaşırdım:

forever:
     do stuff;
     goto forever;

while(1)for(;;)çoğu derleyici tarafından tanınan bir deyimdir .

Perl'in de tanıdığını gördüğüme sevindim until(0).

for (;;)Vs while (1)tartışmasını özetlemek için , eski optimize olmayan derleyiciler günlerinde daha hızlı olduğu açıktır, bu yüzden bunu Lions Unix Kaynak kodu yorumu gibi eski kod tabanlarında görme eğilimindedir, ancak badass optimizasyon çağında derleyiciler bu kazançlar, ikincisinin anlaşılması daha kolay olduğu gerçeği ile birleştiğinde optimize edildiğine inanıyorum.

Sadece bu iplik geldi (oldukça birkaç yıl geçmesine rağmen).

"For (;;)" nin "while (1)" den daha iyi olmasının gerçek nedenini bulduğumu düşünüyorum.

"barr kodlama standardı 2018" e göre

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’.

temel olarak, bu bir hız sorunu değil, okunabilirlik sorunudur. Kodun yazı tipine / baskısına bağlı olarak, bir süre (1) küçük harf l gibi görünebilir.

yani 1'e karşı l. (bazı fontlarda bunlar aynı görünür).

Bu yüzden (1), L harfi değişken harfine bağlıyken döngü gibi görünebilir.

while (true) da işe yarayabilir ancak bazı eski C ve gömülü C durumlarında stdbool.h dahil edilmedikçe true / false henüz tanımlanmamıştır.

Her ikisinin de performans açısından aynı olduğunu düşünürdüm. Ancak okunabilirlik için (1) 'i tercih ederim ama neden sonsuz bir döngüye ihtiyacınız olduğunu soruyorum.

Onlar aynı. Düşünmek için çok daha önemli sorular var.