ในขณะที่ (1) สำหรับ (;;) มีความแตกต่างความเร็วหรือไม่

รุ่นยาว ...

เพื่อนร่วมงานยืนยันในวันนี้หลังจากเห็นการใช้งานของฉันwhile (1)ในสคริปต์ Perl ที่for (;;)เร็วขึ้น ฉันแย้งว่าพวกเขาควรจะเหมือนกันโดยหวังว่าล่ามจะปรับความแตกต่างให้เหมาะสม ฉันตั้งค่าสคริปต์ที่จะเรียกใช้ 1,000,000,000 สำหรับการวนซ้ำวนซ้ำและในขณะเดียวกันก็วนซ้ำและบันทึกเวลาระหว่างกัน ฉันไม่พบความแตกต่างที่เห็นคุณค่า เพื่อนร่วมงานของฉันบอกว่าศาสตราจารย์คนหนึ่งบอกเขาว่าการwhile (1)เปรียบเทียบกำลังดำเนินการอยู่1 == 1และfor (;;)ไม่ใช่ เราทำการทดสอบซ้ำกับ 100x จำนวนการวนซ้ำด้วย C ++ และความแตกต่างนั้นเล็กน้อย อย่างไรก็ตามเป็นตัวอย่างที่แสดงให้เห็นว่าโค้ดที่คอมไพล์ได้เร็วขึ้นสามารถเทียบกับภาษาสคริปต์ได้

เวอร์ชั่นสั้น...

มีเหตุผลใดที่จะชอบwhile (1)มากกว่าfor (;;)ถ้าคุณต้องการวงวนไม่สิ้นสุดเพื่อแยกออกจากกัน?

หมายเหตุ:หากยังไม่ชัดเจนจากคำถาม นี่เป็นการสนทนาทางวิชาการที่สนุกสนานระหว่างเพื่อนสองคน ฉันรู้ว่านี่ไม่ใช่แนวคิดที่สำคัญอย่างยิ่งที่โปรแกรมเมอร์ทุกคนควรทนทุกข์ทรมาน ขอบคุณสำหรับคำตอบที่ดีทั้งหมดที่ฉัน (และฉันแน่ใจว่าคนอื่น ๆ ) ได้เรียนรู้เล็ก ๆ น้อย ๆ จากการสนทนานี้

ปรับปรุง:เพื่อนร่วมงานดังกล่าวชั่งน้ำหนักด้วยคำตอบด้านล่าง

อ้างถึงที่นี่ในกรณีที่ถูกฝังอยู่

มันมาจากโปรแกรมเมอร์แอสเซมบลีของ AMD เขาระบุว่าโปรแกรมเมอร์ C (ผู้ประพันธ์) ไม่ทราบว่ารหัสของพวกเขาไม่มีประสิทธิภาพ เขากล่าวในวันนี้ว่าคอมไพเลอร์ gcc นั้นดีมากและทำให้คนอย่างเขาทำธุรกิจ เขากล่าวว่าเช่นและบอกฉันเกี่ยวกับVSwhile 1 for(;;)ฉันใช้มันตอนนี้นิสัย แต่ gcc และโดยเฉพาะล่ามจะดำเนินการเดียวกัน (ตัวประมวลผลกระโดด) สำหรับทั้งสองวันนี้เนื่องจากพวกเขาได้รับการปรับให้เหมาะสม

ใน Perl พวกเขาส่งผลให้ opcodes เดียวกัน:

$ 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

เช่นเดียวกันใน 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

ดังนั้นฉันเดาว่าคำตอบคือพวกมันเหมือนกันในคอมไพเลอร์หลาย ๆ ตัว แน่นอนว่าสำหรับคอมไพเลอร์อื่น ๆ อาจไม่ได้เป็นอย่างนั้น แต่โอกาสที่รหัสภายในวงจะมีราคาแพงกว่าการวนซ้ำสองสามพันเท่าแล้วใครจะสนใจล่ะ

ใช้ GCC พวกเขาทั้งคู่ดูเหมือนจะรวบรวมเป็นภาษาแอสเซมบลีเดียวกัน:

L2:
        jmp     L2

ไม่มีเหตุผลมากนักที่จะชอบอีกคนหนึ่ง ฉันคิดว่าwhile(1)โดยเฉพาะอย่างยิ่งwhile(true)สามารถอ่านได้มากกว่าfor(;;)แต่นั่นเป็นเพียงการตั้งค่าของฉัน

ไม่มีความแตกต่างตามมาตรฐาน 6.5.3 / 1 มี:

สำหรับงบ

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

เทียบเท่ากับ

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

และ 6.5.3 / 2 มี:

สามารถละเว้นเงื่อนไขอย่างใดอย่างหนึ่งหรือทั้งสองอย่างและนิพจน์ได้ เงื่อนไขที่หายไปทำให้นัยในขณะที่ประโยคเทียบเท่ากับ (จริง)

ดังนั้นตามมาตรฐาน C ++ รหัส:

for (;;);

เหมือนกับ:

{
  while (true) {
    ;
    ;
  }
}

คอมไพเลอร์ Visual C ++ ที่ใช้ในการปล่อยคำเตือน

while (1) 

(นิพจน์คงที่) แต่ไม่ใช่สำหรับ

for (;;)

ฉันยังคงฝึกการเลือกfor (;;)เหตุผลต่อไป แต่ฉันไม่รู้ว่าผู้รวบรวมยังคงทำเช่นนั้นในวันนี้หรือไม่

for(;;) เป็นหนึ่งในตัวละครที่พิมพ์น้อยถ้าคุณต้องการไปในทิศทางนั้นเพื่อปรับสิ่งต่าง ๆ ให้เหมาะสม

Turbo C ที่มีคอมไพเลอร์เก่านี้ผลในรหัสได้เร็วขึ้นแล้วfor(;;)while(1)

วันนี้ gcc, Visual C (ฉันคิดว่าเกือบทั้งหมด) คอมไพเลอร์ปรับให้เหมาะสมและ CPU ที่มี 4.7 MHz ไม่ค่อยได้ใช้

ในสมัยนั้น a for( i=10; i; i-- )เร็วกว่าfor( i=1; i <=10; i++ )เนื่องจากการเปรียบเทียบiเป็น 0 ผลลัพธ์ในการกระโดดตามเงื่อนไขของ CPU-Zero-Flag และ Zero-Flag ได้รับการแก้ไขด้วยการลดทอนครั้งล่าสุด( i-- )ไม่จำเป็นต้องมีการใช้งาน cmp เพิ่มเติม

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

และที่นี่ด้วยfor(i=1; i<=10; i++)cmpl พิเศษ:

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

สำหรับทุกคนที่โต้เถียงคุณไม่ควรใช้ indefinte ในขณะที่ลูปและแนะนำสิ่งที่บ้าคลั่งเช่นใช้ open goto (จริงจังจริงจัง)

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

ไม่สามารถแสดงได้อย่างมีประสิทธิภาพด้วยวิธีอื่น ไม่ได้โดยไม่ต้องสร้างตัวแปรทางออกและทำเวทมนต์ดำเพื่อทำให้ข้อมูลตรงกัน

หากคุณมีใจชอบไวยากรณ์ที่เพิ่มมากขึ้นให้ใช้สิ่งที่มีสติซึ่ง จำกัด ขอบเขต

flow: { 

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

ในที่สุดความเร็วก็ไม่สำคัญเท่าไหร่

การกังวลเกี่ยวกับความเร็วที่มีประสิทธิภาพของการสร้างลูปที่แตกต่างกันอย่างชาญฉลาดนั้นเป็นการเสียเวลามาก การเพิ่มประสิทธิภาพก่อนวัยอันควรผ่านและผ่าน ฉันไม่สามารถนึกถึงสถานการณ์ใด ๆ ที่ฉันเคยเห็นที่รหัสการทำโปรไฟล์พบปัญหาคอขวดในตัวเลือกการวนลูปของฉัน

โดยทั่วไปแล้วมันเป็นวิธีการของห่วงและสิ่งที่ห่วง

คุณควร "ปรับ" ให้เหมาะสมสำหรับการอ่านและความรัดกุมและเขียนสิ่งที่ดีที่สุดในการอธิบายปัญหาไปยังผู้อมยิ้มรายถัดไปที่พบรหัสของคุณ

หากคุณใช้ "โกโตะ LABEL" เคล็ดลับใครบางคนที่กล่าวถึงและฉันต้องใช้รหัสของคุณได้เตรียมที่จะหลับนอนกับตาเปิดหนึ่งโดยเฉพาะอย่างยิ่งถ้าคุณทำมันมากกว่าหนึ่งครั้งเพราะการจัดเรียงของสิ่งที่สร้างความสยองรหัสปาเก็ตตี้

เพียงเพราะคุณสามารถสร้างรหัสสปาเก็ตตี้ไม่ได้หมายความว่าคุณควร

จาก Stroustrup, TC ++ PL (รุ่นที่ 3), §6.1.1:

สัญกรณ์อยากรู้อยากเห็นfor (;;)เป็นวิธีมาตรฐานในการระบุวงไม่สิ้นสุด คุณสามารถออกเสียงว่า "ถาวร" [... ] while (true)เป็นทางเลือก

for (;;)ฉันชอบ

หากคอมไพเลอร์ไม่ทำการเพิ่มประสิทธิภาพใด ๆfor(;;)ก็จะเร็วกว่าwhile(true)เสมอ นี่เป็นเพราะ while-statement ประเมินเงื่อนไขทุกครั้ง แต่ for-statement เป็นการกระโดดแบบไม่มีเงื่อนไข แต่ถ้าคอมไพเลอร์ปรับการควบคุมการไหลให้เหมาะสมมันอาจสร้าง opcode บางตัว คุณสามารถอ่านรหัสถอดแยกชิ้นส่วนได้ง่ายมาก

ป.ล. คุณสามารถเขียนวนรอบไม่สิ้นสุดเช่นนี้:

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

ฉันเคยได้ยินเกี่ยวกับเรื่องนี้ครั้งเดียว

มันมาจากโปรแกรมเมอร์แอสเซมบลีของ AMD เขากล่าวว่าโปรแกรมเมอร์ C (คน) ไม่ทราบว่ารหัสของพวกเขาไม่มีประสิทธิภาพ เขากล่าวในวันนี้ว่าคอมไพเลอร์ gcc นั้นดีมากและทำให้คนอย่างเขาทำธุรกิจ เขากล่าวว่าเช่นและบอกฉันเกี่ยวกับVSwhile 1 for(;;)ฉันใช้มันตอนนี้นิสัย แต่ gcc และโดยเฉพาะล่ามจะดำเนินการเดียวกัน (ตัวประมวลผลกระโดด) สำหรับทั้งสองวันนี้เนื่องจากพวกเขาได้รับการปรับให้เหมาะสม

ในโครงสร้างที่ได้รับการปรับปรุงของภาษาที่คอมไพล์แล้วควรไม่มีความแตกต่างที่เห็นได้ระหว่างสองภาษา ไม่ควรทำการเปรียบเทียบใด ๆ ที่รันไทม์พวกเขาจะรันโค้ดลูปจนกว่าคุณจะออกจากลูปด้วยตนเอง (เช่นด้วย a break)

ฉันประหลาดใจที่ไม่มีใครทดสอบอย่างถูกต้องfor (;;)กับwhile (1)Perl!

เนื่องจากภาษา Perl แปลภาษาเวลาในการเรียกใช้สคริปต์ Perl ไม่เพียง แต่ประกอบด้วยช่วงการดำเนินการเท่านั้น (ซึ่งในกรณีนี้คือเหมือนกัน) แต่ยังเป็นช่วงการตีความก่อนดำเนินการด้วย ขั้นตอนเหล่านี้ทั้งสองจะต้องนำมาพิจารณาเมื่อทำการเปรียบเทียบความเร็ว

โชคดีที่ Perl มีโมดูลเกณฑ์มาตรฐานที่สะดวกซึ่งเราสามารถใช้เพื่อสร้างเกณฑ์มาตรฐานเช่น:

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

โปรดทราบว่าฉันกำลังทดสอบอนันต์วนลูปสองเวอร์ชัน: อันหนึ่งสั้นกว่าขณะลูปและอีกอันหนึ่งซึ่งมีพื้นที่พิเศษเพื่อให้มีความยาวเท่ากับลูปในขณะที่

บน Ubuntu 11.04 x86_64 ด้วย perl 5.10.1 ฉันได้ผลลัพธ์ดังนี้:

          อัตราสำหรับ 2 ในขณะที่
สำหรับ 100588 / s - -0% -2%
for2 100937 / s 0% - -1%
ในขณะที่ 102147 / s 2% 1% -

ขณะที่ลูปเป็นผู้ชนะอย่างชัดเจนในแพลตฟอร์มนี้

ใน FreeBSD 8.2 x86_64 ด้วย perl 5.14.1:

         อัตราสำหรับ 2 ในขณะที่
สำหรับ 53453 / s - -0% -2%
for2 53552 / s 0% - -2%
ในขณะที่ 54564 / s 2% 2% -

ในขณะที่วงเป็นผู้ชนะที่นี่ด้วย

บน FreeBSD 8.2 i386 ด้วย perl 5.14.1:

         ให้คะแนนในขณะที่ for2
ในขณะที่ 24311 / s - -1% -1%
สำหรับ 24481 / s 1% - -1%
for2 24637 / s 1% 1% -

น่าประหลาดใจที่วงที่มีพื้นที่ว่างเพิ่มเป็นตัวเลือกที่เร็วที่สุดที่นี่!

ข้อสรุปของฉันคือขณะที่ลูปควรใช้บนแพลตฟอร์ม x86_64 หากโปรแกรมเมอร์กำลังปรับให้เหมาะสมสำหรับความเร็ว เห็นได้ชัดว่าควรใช้ a for loop เมื่อปรับพื้นที่ให้เหมาะสม ผลลัพธ์ของฉันยังสรุปไม่ได้เกี่ยวกับแพลตฟอร์มอื่น

ในทางทฤษฎีคอมไพเลอร์ที่ไร้เดียงสาอย่างสมบูรณ์สามารถเก็บตัวอักษร '1' ในไบนารี่ (พื้นที่ว่างเปล่า) และตรวจสอบเพื่อดูว่า 1 == 0 ทุกการวนซ้ำ (เสียเวลาและพื้นที่ว่างมากขึ้น)

ในความเป็นจริงอย่างไรก็ตามถึงแม้จะมีการเพิ่มประสิทธิภาพ "ไม่" คอมไพเลอร์จะยังคงลดลงทั้งสองเหมือนกัน พวกเขายังอาจส่งคำเตือนเพราะอาจบ่งบอกถึงข้อผิดพลาดเชิงตรรกะ ตัวอย่างเช่นการโต้แย้งของwhileสามารถกำหนดที่อื่นและคุณไม่ได้ตระหนักว่ามันคงที่

ฉันประหลาดใจที่ไม่มีใครเสนอรูปแบบที่ตรงมากขึ้นซึ่งสอดคล้องกับชุดประกอบที่ต้องการ:

forever:
     do stuff;
     goto forever;

while(1)เป็นสำนวนfor(;;)ที่นักแปลส่วนใหญ่ยอมรับ

ฉันดีใจที่เห็นว่า Perl ตระหนักuntil(0)เช่นกัน

เพื่อสรุปการโต้วาทีfor (;;)vs while (1)เห็นได้ชัดว่าอดีตนั้นเร็วขึ้นในวันที่คอมไพเลอร์เก่าที่ไม่ได้เพิ่มประสิทธิภาพนั่นคือเหตุผลที่คุณมักจะเห็นมันในฐานรหัสเก่าเช่นความเห็นรหัส Lions Unix ซอร์สโค้ดอย่างไรก็ตามในยุคของการเพิ่มประสิทธิภาพ badass การรวบรวมผลกำไรเหล่านั้นได้รับการปรับให้เหมาะกับการมีเพศสัมพันธ์กับความจริงที่ว่าหลังจะเข้าใจได้ง่ายกว่าในอดีตฉันเชื่อว่ามันจะเป็นที่นิยมมากกว่า

เพิ่งเจอหัวข้อนี้ (แม้ว่าจะค่อนข้างช้าไม่กี่ปี)

ฉันคิดว่าฉันพบเหตุผลที่แท้จริงว่าทำไม "for (;;)" ดีกว่า "ในขณะที่ (1)"

ตามที่ "มาตรฐานการเข้ารหัส 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’.

โดยทั่วไปนี่ไม่ใช่ปัญหาความเร็ว แต่เป็นปัญหาการอ่านได้ง่าย ขึ้นอยู่กับแบบอักษร / พิมพ์ของรหัสหมายเลขหนึ่ง (1) ในขณะที่อาจดูเหมือนตัวอักษรตัวพิมพ์เล็ก l

เช่น 1 vs l (ในแบบอักษรบางแบบจะมีลักษณะเหมือนกัน)

ดังนั้นในขณะที่ (1) อาจดูเหมือนบางอย่างในขณะที่วงขึ้นอยู่กับตัวอักษรตัวแปร L

ในขณะที่ (จริง) อาจทำงานได้ แต่ใน C เก่าและกรณี C ฝังตัวจริง / เท็จยังไม่ได้กำหนดเว้นแต่ stdbool.h รวมอยู่

ฉันคิดว่าทั้งสองอย่างนั้นเหมือนกันในแง่ของประสิทธิภาพ แต่ฉันต้องการในขณะที่ (1) สำหรับการอ่าน แต่ฉันถามว่าทำไมคุณต้องวนซ้ำไม่สิ้นสุด

พวกเขาก็เหมือน ๆ กัน. มีคำถามสำคัญมากมายที่ต้องไตร่ตรอง