(1) 대. for (;;) 속도 차이가 있습니까?

긴 버전 ...

동료는 오늘 while (1)Perl 스크립트에서 for (;;)더 빠른 사용을보고 나서 주장했다 . 나는 그들이 통역사가 어떤 차이를 최적화하길 바라고 같은 것이되어야한다고 주장했다. 루프 반복 및 동일한 수의 while 루프에 대해 1,000,000,000을 실행하고 그 사이의 시간을 기록하는 스크립트를 설정했습니다. 나는 눈에 띄는 차이를 찾을 수 없었다. 저의 동료는 교수가 그에게 while (1)비교를 1 == 1하고 있지만 for (;;)그렇지 않다고 그에게 말했습니다 . 우리는 C ++로 반복 횟수를 100 배로 동일한 테스트를 반복했으며 그 차이는 무시할 만했습니다. 그러나 컴파일 된 코드가 스크립팅 언어에 비해 얼마나 빠른지를 보여주는 그래픽 예입니다.

짧은 버전 ...

탈출하기 위해 무한 루프가 필요한 경우 while (1)오버 오버 를 선호하는 이유 for (;;)가 있습니까?

참고 : 질문에서 명확하지 않은 경우. 이것은 순전히 두 친구 사이의 재미있는 학술 토론이었습니다. 나는 이것이 모든 프로그래머가 고민해야 할 매우 중요한 개념이 아니라는 것을 알고 있습니다. 이 토론에서 몇 가지를 배웠습니다.

업데이트 : 위에서 언급 한 동료의 무게는 다음과 같습니다.

그것이 묻힐 경우를 대비하여 여기에 인용하십시오.

AMD 어셈블리 프로그래머가 제공 한 것입니다. 그는 C 프로그래머들 (사람들)은 그들의 코드가 비효율적이라는 것을 깨닫지 못한다고 말했다. 그는 오늘 gcc 컴파일러는 매우 훌륭하며 그와 같은 사람들을 사업에서 제외 시켰다고 말했다. 그는 예를 while 1들어서 vs 에 대해 이야기했습니다 for(;;). 지금은 습관이 없지만 gcc 및 특히 통역사는 최적화되어 있기 때문에 요즘 두 가지 모두 동일한 작업 (프로세서 점프)을 수행합니다.

펄에서는 동일한 opcode가 발생합니다.

$ 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 ( for-init-statement ; conditionopt ; expressionopt ) statement

에 해당

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

그리고 6.5.3 / 2에는 다음이 있습니다.

조건과 표현식 중 하나 또는 둘 다를 생략 할 수 있습니다. 누락 된 조건은 암시적인 while 절을 while (true)와 동일하게 만듭니다.

따라서 C ++ 표준에 따르면 코드는 다음과 같습니다.

for (;;);

정확히 다음과 같습니다.

{
  while (true) {
    ;
    ;
  }
}

에 대한 경고를 발생시키는 데 사용되는 Visual C ++ 컴파일러

while (1) 

(일정한 표현)

for (;;)

나는 for (;;)그 이유 를 선호하는 관행을 계속 했지만 컴파일러가 여전히 그렇게하는지 모르겠습니다.

for(;;) 당신이 물건을 최적화하기 위해 그 방향으로 가고 싶다면 입력 할 문자가 적습니다.

이 오래된 컴파일러를 사용하는 Turbo C for(;;)는 더 빠른 코드를 생성 while(1)합니다.

오늘날 gcc, Visual C (거의 모든 것) 컴파일러는 잘 최적화되며 4.7 MHz의 CPU는 거의 사용되지 않습니다.

당시에는 a for( i=10; i; i-- )가보다 빠릅니다. for( i=1; i <=10; i++ )비교 i가 0 이기 때문에 CPU- 제로-플래그 조건부 점프가 발생합니다. 그리고 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

주장하는 모든 사람들에게 당신은 undefinte while 루프를 사용해서는 안되며 open goto (진지하게 ouch)를 사용하는 것과 같은 멍청한 물건을 제안해서는 안됩니다

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 
}

궁극적으로 속도는 그렇게 중요하지 않습니다

현명하게 다른 루핑 구조물이 얼마나 효과적인지 걱정하는 것은 엄청난 시간 낭비입니다. 통과하는 조기 최적화. 프로파일 링 코드가 루핑 구조를 선택할 때 병목 현상이 발견되는 상황을 전혀 생각할 수 없습니다.

일반적으로 그것 방법 루프와는 어떤 루프.

가독성과 간결성을 위해 "최적화"하고, 코드를 찾는 다음 빈약 한 빨판에게 문제를 설명하는 데 가장 적합한 것을 작성해야합니다.

누군가가 언급 한 "goto LABEL"트릭을 사용하고 코드를 사용해야하는 경우 특히 눈을 뜨고 잠을 잘 수 있도록 준비하십시오. 특히 두 번 이상 사용하는 경우 이러한 종류의 물건이 끔찍하게 스파게티 코드를 생성하기 때문입니다 .

당신은 그냥 있기 때문에 할 수 스파게티를 만드는 코드가 당신에게 의미하지 않는다 해야

Stroustrup, TC ++ PL (3 판), §6.1.1에서 :

호기심 표기법 for (;;)은 무한 루프를 지정하는 표준 방법입니다. "영원히"발음 할 수 있습니다. [...] while (true)는 대안입니다.

나는 선호한다 for (;;).

컴파일러가 최적화를 수행하지 않으면 for(;;)항상보다 빠릅니다 while(true). while 문은 매번 조건을 평가하지만 for 문은 무조건 점프하기 때문입니다. 그러나 컴파일러가 제어 흐름을 최적화하면 일부 opcode가 생성 될 수 있습니다. 디스 어셈블리 코드를 매우 쉽게 읽을 수 있습니다.

추신 : 당신은 다음과 같이 무한 루프를 작성할 수 있습니다 :

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

나는 이것에 대해 한 번 들었다.

AMD 어셈블리 프로그래머가 제공 한 것입니다. 그는 C 프로그래머 (사람들)는 자신의 코드에 비 효율성이 있음을 깨닫지 못한다고 말했습니다. 그는 오늘 gcc 컴파일러는 매우 훌륭하며 그와 같은 사람들을 사업에서 제외 시켰다고 말했다. 그는 예를 while 1들어서 vs 에 대해 이야기했습니다 for(;;). 지금은 습관이 없지만 gcc 및 특히 통역사는 최적화되어 있기 때문에 요즘 두 가지 모두 동일한 작업 (프로세서 점프)을 수행합니다.

컴파일 된 언어의 최적화 된 빌드에서는 두 언어 사이에 뚜렷한 차이가 없어야합니다. 런타임에 비교를 수행해서는 안되며 루프를 수동으로 종료 할 때까지 (예 : a break) 루프 코드를 실행합니다 .

나는 아무도 제대로 테스트 없음을 놀라게하고 for (;;)대 while (1)펄!

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 });

두 가지 버전의 무한 for 루프를 테스트하고 있습니다. 하나는 while 루프보다 짧고 다른 하나는 while 루프와 동일한 길이를 만들기 위해 여분의 공간이 있습니다.

perl 5.10.1이있는 Ubuntu 11.04 x86_64에서 다음과 같은 결과가 나타납니다.

          for2 동안의 요금
100588 / s---0 % -2 %
for 2 100937 / s 0 %--1 %
102147 / s 2 % 1 %-

while 루프는 분명히이 플랫폼의 승자입니다.

Perl 5.14.1이있는 FreeBSD 8.2 x86_64에서 :

         for2 동안의 요금
53453 / s---0 % -2 %
for 2 53552 / s 0 %--2 %
54564 / s 2 % 2 %-

while 루프가 여기에서도 승자입니다.

Perl 5.14.1이있는 FreeBSD 8.2 i386 :

         for2 동안 평가
24311 / s--1 % -1 %
24481 / s의 경우 1 %--1 %
2 24637 / s 1 % 1 %-

놀랍게도 여분의 공간을 가진 for 루프가 가장 빠른 선택입니다!

필자의 결론은 프로그래머가 속도를 최적화하는 경우 x86_64 플랫폼에서 while 루프를 사용해야한다는 것입니다. 공간을 최적화 할 때는 분명히 for 루프를 사용해야합니다. 불행히도 다른 플랫폼과 관련하여 결과가 결정적이지 않습니다.

이론적으로 완전히 순진한 컴파일러는 리터럴 '1'을 이진 (과잉 공간)에 저장하고 매번 반복 할 때마다 (시간과 공간을 더 많이 낭비) 1 == 0인지 확인할 수 있습니다.

그러나 실제로는 "아니오"최적화로도 컴파일러는 여전히 둘 다 동일하게 줄입니다. 또한 논리적 오류를 나타낼 수 있으므로 경고가 표시 될 수 있습니다. 예를 들어,의 인수는 while다른 곳에서 정의 할 수 있으며 그것이 일정하다는 것을 인식하지 못합니다.

원하는 어셈블리에 따라 더 직접적인 형식을 제공 한 사람이 아무도 없습니다.

forever:
     do stuff;
     goto forever;

while(1)for(;;)대부분의 컴파일러에서 인식 하는 관용구입니다 .

펄도 인식한다는 것을 알게되어 기뻤 until(0)습니다.

for (;;)vs while (1)토론 을 요약하면, 최적화되지 않은 오래된 컴파일러의 시대에는 전자가 더 빠르다는 것이 분명합니다. 따라서 Lions Unix 소스 코드 해설과 같은 오래된 코드베이스에서 그것을 보는 경향이 있습니다. 컴파일러는 그 이익이 전자보다 더 이해하기 쉽다는 사실과 결합하여 최적화되어 있습니다.

방금이 스레드를 보았습니다 (몇 년이 늦었지만).

"for (;;)"가 "while (1)"보다 나은 실제 이유를 찾았습니다.

"바 코딩 표준 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 대 l. (일부 글꼴에서는 동일하게 보입니다).

따라서 while (1)은 변수 문자 L에 따라 while 루프처럼 보일 수 있습니다.

while (true)도 작동하지만 일부 오래된 C 및 임베디드 C의 경우 stdbool.h가 포함되어 있지 않으면 true / false가 아직 정의되지 않았습니다.

성능 측면에서 두 가지가 동일하다고 생각합니다. 그러나 가독성을 위해 while (1)을 선호하지만 무한 루프가 필요한 이유에 대해 의문입니다.

그들은 동일합니다. 숙고해야 할 훨씬 더 중요한 질문이 있습니다.