삼항 연산자는 if-else 블록보다 두 배 느립니다?

나는 삼항 연산자가 빠르게보다 가정, 또는 이에 상응하는 등 적어도 같은 것을 어디에서나 읽기 if- else블록.

그러나 다음 테스트를 수행했지만 사실이 아니라는 것을 알았습니다.

Random r = new Random();
int[] array = new int[20000000];
for(int i = 0; i < array.Length; i++)
{
    array[i] = r.Next(int.MinValue, int.MaxValue);
}
Array.Sort(array);

long value = 0;
DateTime begin = DateTime.UtcNow;

foreach (int i in array)
{
    if (i > 0)
    {
        value += 2;
    }
    else
    {
        value += 3;
    }
    // if-else block above takes on average 85 ms

    // OR I can use a ternary operator:
    // value += i > 0 ? 2 : 3; // takes 157 ms
}
DateTime end = DateTime.UtcNow;
MessageBox.Show("Measured time: " + (end-begin).TotalMilliseconds + " ms.\r\nResult = " + value.ToString());

내 컴퓨터는 위의 코드를 실행하는 데 85ms가 걸렸습니다. 그러나 if- else청크를 주석 처리하고 삼항 연산자 줄의 주석 처리를 제거하면 약 157ms가 걸립니다.

왜 이런 일이 발생합니까?

이 질문에 답하기 위해 X86 및 X64 JIT에서 생성 된 어셈블리 코드를 각각 살펴 보겠습니다.

X86, if / then

    32:                 foreach (int i in array)
0000007c 33 D2                xor         edx,edx 
0000007e 83 7E 04 00          cmp         dword ptr [esi+4],0 
00000082 7E 1C                jle         000000A0 
00000084 8B 44 96 08          mov         eax,dword ptr [esi+edx*4+8] 
    33:                 {
    34:                     if (i > 0)
00000088 85 C0                test        eax,eax 
0000008a 7E 08                jle         00000094 
    35:                     {
    36:                         value += 2;
0000008c 83 C3 02             add         ebx,2 
0000008f 83 D7 00             adc         edi,0 
00000092 EB 06                jmp         0000009A 
    37:                     }
    38:                     else
    39:                     {
    40:                         value += 3;
00000094 83 C3 03             add         ebx,3 
00000097 83 D7 00             adc         edi,0 
0000009a 42                   inc         edx 
    32:                 foreach (int i in array)
0000009b 39 56 04             cmp         dword ptr [esi+4],edx 
0000009e 7F E4                jg          00000084 
    30:             for (int x = 0; x < iterations; x++)
000000a0 41                   inc         ecx 
000000a1 3B 4D F0             cmp         ecx,dword ptr [ebp-10h] 
000000a4 7C D6                jl          0000007C 

X86, 삼항

    59:                 foreach (int i in array)
00000075 33 F6                xor         esi,esi 
00000077 83 7F 04 00          cmp         dword ptr [edi+4],0 
0000007b 7E 2D                jle         000000AA 
0000007d 8B 44 B7 08          mov         eax,dword ptr [edi+esi*4+8] 
    60:                 {
    61:                     value += i > 0 ? 2 : 3;
00000081 85 C0                test        eax,eax 
00000083 7F 07                jg          0000008C 
00000085 BA 03 00 00 00       mov         edx,3 
0000008a EB 05                jmp         00000091 
0000008c BA 02 00 00 00       mov         edx,2 
00000091 8B C3                mov         eax,ebx 
00000093 8B 4D EC             mov         ecx,dword ptr [ebp-14h] 
00000096 8B DA                mov         ebx,edx 
00000098 C1 FB 1F             sar         ebx,1Fh 
0000009b 03 C2                add         eax,edx 
0000009d 13 CB                adc         ecx,ebx 
0000009f 89 4D EC             mov         dword ptr [ebp-14h],ecx 
000000a2 8B D8                mov         ebx,eax 
000000a4 46                   inc         esi 
    59:                 foreach (int i in array)
000000a5 39 77 04             cmp         dword ptr [edi+4],esi 
000000a8 7F D3                jg          0000007D 
    57:             for (int x = 0; x < iterations; x++)
000000aa FF 45 E4             inc         dword ptr [ebp-1Ch] 
000000ad 8B 45 E4             mov         eax,dword ptr [ebp-1Ch] 
000000b0 3B 45 F0             cmp         eax,dword ptr [ebp-10h] 
000000b3 7C C0                jl          00000075 

X64, if / then

    32:                 foreach (int i in array)
00000059 4C 8B 4F 08          mov         r9,qword ptr [rdi+8] 
0000005d 0F 1F 00             nop         dword ptr [rax] 
00000060 45 85 C9             test        r9d,r9d 
00000063 7E 2B                jle         0000000000000090 
00000065 33 D2                xor         edx,edx 
00000067 45 33 C0             xor         r8d,r8d 
0000006a 4C 8B 57 08          mov         r10,qword ptr [rdi+8] 
0000006e 66 90                xchg        ax,ax 
00000070 42 8B 44 07 10       mov         eax,dword ptr [rdi+r8+10h] 
    33:                 {
    34:                     if (i > 0)
00000075 85 C0                test        eax,eax 
00000077 7E 07                jle         0000000000000080 
    35:                     {
    36:                         value += 2;
00000079 48 83 C5 02          add         rbp,2 
0000007d EB 05                jmp         0000000000000084 
0000007f 90                   nop 
    37:                     }
    38:                     else
    39:                     {
    40:                         value += 3;
00000080 48 83 C5 03          add         rbp,3 
00000084 FF C2                inc         edx 
00000086 49 83 C0 04          add         r8,4 
    32:                 foreach (int i in array)
0000008a 41 3B D2             cmp         edx,r10d 
0000008d 7C E1                jl          0000000000000070 
0000008f 90                   nop 
    30:             for (int x = 0; x < iterations; x++)
00000090 FF C1                inc         ecx 
00000092 41 3B CC             cmp         ecx,r12d 
00000095 7C C9                jl          0000000000000060 

X64, 삼항

    59:                 foreach (int i in array)
00000044 4C 8B 4F 08          mov         r9,qword ptr [rdi+8] 
00000048 45 85 C9             test        r9d,r9d 
0000004b 7E 2F                jle         000000000000007C 
0000004d 45 33 C0             xor         r8d,r8d 
00000050 33 D2                xor         edx,edx 
00000052 4C 8B 57 08          mov         r10,qword ptr [rdi+8] 
00000056 8B 44 17 10          mov         eax,dword ptr [rdi+rdx+10h] 
    60:                 {
    61:                     value += i > 0 ? 2 : 3;
0000005a 85 C0                test        eax,eax 
0000005c 7F 07                jg          0000000000000065 
0000005e B8 03 00 00 00       mov         eax,3 
00000063 EB 05                jmp         000000000000006A 
00000065 B8 02 00 00 00       mov         eax,2 
0000006a 48 63 C0             movsxd      rax,eax 
0000006d 4C 03 E0             add         r12,rax 
00000070 41 FF C0             inc         r8d 
00000073 48 83 C2 04          add         rdx,4 
    59:                 foreach (int i in array)
00000077 45 3B C2             cmp         r8d,r10d 
0000007a 7C DA                jl          0000000000000056 
    57:             for (int x = 0; x < iterations; x++)
0000007c FF C1                inc         ecx 
0000007e 3B CD                cmp         ecx,ebp 
00000080 7C C6                jl          0000000000000048 

첫째 : 왜 X86 코드 가 X64보다 훨씬 느립니까?

코드의 특성은 다음과 같습니다.

1. X64에는 사용 가능한 추가 레지스터가 여러 개 있으며 각 레지스터는 64 비트입니다. 이를 통해 X64 JIT i는 어레이 에서로드 하는 것 외에 레지스터를 사용하여 내부 루프를 완전히 수행 할 수 있으며 X86 JIT는 루프에 여러 스택 작업 (메모리 액세스)을 배치합니다.
2. value64 비트 정수이며 X86에서 2 개의 기계 명령어 ( add뒤에 adc)가 필요하지만 X64 ( add) 에서는 1 개만 필요합니다 .

둘째 : 삼항 연산자가 왜 X86과 X64에서 느려 집니까?

이는 JIT 옵티 마이저에 영향을주는 조작 순서의 미묘한 차이로 인한 것입니다. 삼원 오퍼레이터보다는 직접 코딩 JIT로 2하고 3에 add직접 기계 명령어 (레지스터)에서 중간 변수를 생성하는 JIT는 결과를 저장한다. 그런 다음이 레지스터는에 추가하기 전에 32 비트에서 64 비트로 부호 확장됩니다 value. 이 모든 것이 X64의 레지스터에서 수행되기 때문에 삼항 연산자의 복잡성이 크게 증가하더라도 순 영향은 다소 최소화됩니다.

반면에 X86 JIT는 내부 루프에 새로운 중간 값을 추가하면 다른 값을 "흘리게"하여 내부 루프에 최소 2 개의 추가 메모리 액세스가 발생하기 때문에 더 큰 영향을받습니다 (액세스 참조). 에 [ebp-14h])에 X86의 삼항 코드입니다.

편집 : 모든 변경 ... 아래를 참조하십시오.

나는 64의 CLR에 결과를 재현 할 수없는,하지만 난 할 수 x86에서. x64 에서는 조건부 연산자와 if / else 사이에 작은 차이 (10 % 미만)를 볼 수 있지만보고있는 것보다 훨씬 작습니다.

다음과 같은 잠재적 인 변경을 수행했습니다.

• 콘솔 앱에서 실행
• 로 빌드 /o+ /debug-하고 디버거 외부에서 실행
• 두 코드를 한 번 실행하여 JIT 한 다음 더 많은 정확도를 위해 여러 번 실행
• 사용하다 Stopwatch

/platform:x64"무시"행이없는 결과 :

if/else with 1 iterations: 17ms
conditional with 1 iterations: 19ms
if/else with 1000 iterations: 17875ms
conditional with 1000 iterations: 19089ms

/platform:x86"무시"행이없는 결과 :

if/else with 1 iterations: 18ms
conditional with 1 iterations: 49ms
if/else with 1000 iterations: 17901ms
conditional with 1000 iterations: 47710ms

내 시스템 정보 :

• x64 i7-2720QM CPU @ 2.20GHz
• 64 비트 Windows 8
• .NET 4.5

이전과 달리, 당신 은 실제 차이를보고 있다고 생각합니다. 그리고 그것은 모두 x86 JIT와 관련이 있습니다. 나는 정확히 대답하는 것처럼 어떤 차이를 일으키는 - 나는 cordbg에 가서 귀찮게 수 있다면 좀 더 세부 나중에 게시물을 업데이트 할 수 있습니다 :

흥미롭게도, 배열을 먼저 정렬하지 않으면 적어도 x64에서 약 4.5x 길이의 테스트가 끝납니다. 내 생각에 이것은 분기 예측과 관련이 있습니다.

암호:

using System;
using System.Diagnostics;

class Test
{
    static void Main()
    {
        Random r = new Random(0);
        int[] array = new int[20000000];
        for(int i = 0; i < array.Length; i++)
        {
            array[i] = r.Next(int.MinValue, int.MaxValue);
        }
        Array.Sort(array);
        // JIT everything...
        RunIfElse(array, 1);
        RunConditional(array, 1);
        // Now really time it
        RunIfElse(array, 1000);
        RunConditional(array, 1000);
    }

    static void RunIfElse(int[] array, int iterations)
    {        
        long value = 0;
        Stopwatch sw = Stopwatch.StartNew();

        for (int x = 0; x < iterations; x++)
        {
            foreach (int i in array)
            {
                if (i > 0)
                {
                    value += 2;
                }
                else
                {
                    value += 3;
                }
            }
        }
        sw.Stop();
        Console.WriteLine("if/else with {0} iterations: {1}ms",
                          iterations,
                          sw.ElapsedMilliseconds);
        // Just to avoid optimizing everything away
        Console.WriteLine("Value (ignore): {0}", value);
    }

    static void RunConditional(int[] array, int iterations)
    {        
        long value = 0;
        Stopwatch sw = Stopwatch.StartNew();

        for (int x = 0; x < iterations; x++)
        {
            foreach (int i in array)
            {
                value += i > 0 ? 2 : 3;
            }
        }
        sw.Stop();
        Console.WriteLine("conditional with {0} iterations: {1}ms",
                          iterations,
                          sw.ElapsedMilliseconds);
        // Just to avoid optimizing everything away
        Console.WriteLine("Value (ignore): {0}", value);
    }
}

차이점은 실제로 if / else 대 삼항과 관련이 없습니다.

불안한 분해를 보면 (여기서는 다시 붙여 넣지 않을 것이며, pls는 @ 280Z28의 답변을 참조하십시오), 그것은 당신이 밝혀졌습니다 사과와 오렌지를 비교 . 어떤 경우에는 +=상수 값 을 사용하여 두 개의 다른 작업 을 만들고 선택하는 작업은 조건에 따라 달라지며 다른 경우에는 추가+= 할 값 이 조건 에 따라 달라지는 위치 를 만듭니다 .

if / else 대 삼항을 실제로 비교하려면 이것이 더 공정한 비교가 될 것입니다 (이제 둘 다 동등하게 "느리게"또는 삼항이 조금 더 빠를 수도 있습니다).

int diff;
if (i > 0) 
    diff = 2;
else 
    diff = 3;
value += diff;

vs.

value += i > 0 ? 2 : 3;

이제 분해 if/else는 아래와 같이됩니다. 루프 변수에 대한 레지스터 사용을 끝내기 때문에 이것은 삼항 경우보다 약간 나쁩니다.i )에 .

                if (i > 0)
0000009d  cmp         dword ptr [ebp-20h],0 
000000a1  jle         000000AD 
                {
                    diff = 2;
000000a3  mov         dword ptr [ebp-24h],2 
000000aa  nop 
000000ab  jmp         000000B4 
                }
                else
                {
                    diff = 3;
000000ad  mov         dword ptr [ebp-24h],3 
                }
                value += diff;
000000b4  mov         eax,dword ptr [ebp-18h] 
000000b7  mov         edx,dword ptr [ebp-14h] 
000000ba  mov         ecx,dword ptr [ebp-24h] 
000000bd  mov         ebx,ecx 
000000bf  sar         ebx,1Fh 
000000c2  add         eax,ecx 
000000c4  adc         edx,ebx 
000000c6  mov         dword ptr [ebp-18h],eax 
000000c9  mov         dword ptr [ebp-14h],edx 
000000cc  inc         dword ptr [ebp-28h] 

편집하다:

조건부 연산자가 아닌 if-else 문으로 수행 할 수있는 예제를 추가했습니다.

답변을보기 전에 [ 어느 것이 더 빠릅니까? ] Lippert 씨의 블로그. 그리고 Ersönmez의 대답은 이 여기에서 가장 정확 합니다.

고급 프로그래밍 언어로 명심해야 할 것을 언급하려고합니다.

먼저 조건부 연산자가 if-else 문을 사용하여 더 빠르거나 동등한 성능을 발휘한다고 들었습니다. C♯의 을 .

그 이유는 if-else 문을 사용하여 작업이없는 경우 다음과 같습니다.

if (i > 0)
{
    value += 2;
}
else
{
}

조건부 연산자의 요구 사항은 값이 있어야합니다 양쪽에 C♯에는 양쪽의: 유형이 같아야합니다. 이것은 if-else 문과 다르게 만듭니다. 따라서 귀하의 질문은 성능의 차이를 위해 기계 코드의 명령이 생성되는 방법을 묻는 질문이됩니다.

조건부 연산자를 사용하면 의미 상 다음과 같습니다.

식이 무엇이든 평가됩니다.

그러나 if-else 문으로 :

표현식이 true로 평가되면 무언가를 수행하십시오. 그렇지 않은 경우 다른 작업을 수행하십시오.

값이 if-else 문에 반드시 포함되는 것은 아닙니다. 귀하의 가정은 최적화를 통해서만 가능합니다.

차이점을 보여주는 또 다른 예는 다음과 같습니다.

var array1=new[] { 1, 2, 3 };
var array2=new[] { 5, 6, 7 };

if(i>0)
    array1[1]=4;
else
    array2[2]=4;

위의 코드는 컴파일되지만 if-else 문을 조건부 연산자로 바꾸면 컴파일되지 않습니다.

var array1=new[] { 1, 2, 3 };
var array2=new[] { 5, 6, 7 };
(i>0?array1[1]:array2[2])=4; // incorrect usage 

조건부 연산자와 if-else 문은 동일한 작업을 수행 할 때 개념적으로 동일합니다. C가 플랫폼의 어셈블리에 더 가깝기 때문에 C 의 조건부 연산자 를 사용하면 훨씬 빠릅니다 .

제공 한 원래 코드의 경우 조건부 연산자는 foreach-loop에서 사용되며,이 연산자는 차이점을 확인하기 위해 문제를 엉망으로 만듭니다. 그래서 나는 다음 코드를 제안하고 있습니다 :

public static class TestClass {
    public static void TestConditionalOperator(int i) {
        long value=0;
        value+=i>0?2:3;
    }

    public static void TestIfElse(int i) {
        long value=0;

        if(i>0) {
            value+=2;
        }
        else {
            value+=3;
        }
    }

    public static void TestMethod() {
        TestConditionalOperator(0);
        TestIfElse(0);
    }
}

다음은 최적화 된 IL의 두 가지 버전입니다. 길이가 길기 때문에 이미지를 사용하여 표시하고 있으며 오른쪽은 최적화 된 것입니다.

클릭하면 전체 크기 이미지를 볼 수 있습니다.

두 버전의 코드에서 조건부 연산자의 IL은 if-else 문보다 짧아 보이지만 최종적으로 생성 된 머신 코드는 여전히 의심의 여지가 있습니다. 다음은 두 방법의 지침이며, 이전 이미지는 최적화되지 않았으며 후자는 최적화 된 것입니다.

• 최적화되지 않은 지침 : (클릭하면 전체 크기 이미지를 볼 수 있습니다.)

• 최적화 된 지침 : (클릭하면 큰 이미지를 볼 수 있습니다.)

후자에서 노란색 블록은이면 코드 만 실행되고 i<=0파란색 블록은 이면 코드 i>0입니다. 두 버전의 명령어 모두 if-else 문이 더 짧습니다.

다른 지침에 대해서는 [ CPI ]가 반드시 같을 필요는 없습니다. 논리적으로 동일한 명령어의 경우 더 많은 명령어에 더 많은주기가 필요합니다. 그러나 명령 페치 시간과 파이프 / 캐시도 고려한 경우 실제 총 실행 시간은 프로세서에 따라 다릅니다. 프로세서는 분기를 예측할 수도 있습니다.

최신 프로세서에는 더 많은 코어가 있으므로 더 복잡 할 수 있습니다. 인텔 프로세서 사용자 인 경우 [ 인텔 ® 64 및 IA-32 아키텍처 최적화 참조 매뉴얼 ]을 원할 수 있습니다 .

하드웨어 구현 CLR이 있는지 모르겠지만, 그렇다면 IL이 분명히 적기 때문에 조건부 연산자를 사용하면 더 빨라질 수 있습니다.

_{참고 : 모든 기계 코드는 x86입니다.}

Jon Skeet이 한 일을하고 1 반복과 1,000 반복을 수행했으며 OP와 Jon 모두 다른 결과를 얻었습니다. 제 삼항은 조금 더 빠릅니다. 아래는 정확한 코드입니다.

static void runIfElse(int[] array, int iterations)
    {
        long value = 0;
        Stopwatch ifElse = new Stopwatch();
        ifElse.Start();
        for (int c = 0; c < iterations; c++)
        {
            foreach (int i in array)
            {
                if (i > 0)
                {
                    value += 2;
                }
                else
                {
                    value += 3;
                }
            }
        }
        ifElse.Stop();
        Console.WriteLine(String.Format("Elapsed time for If-Else: {0}", ifElse.Elapsed));
    }

    static void runTernary(int[] array, int iterations)
    {
        long value = 0;
        Stopwatch ternary = new Stopwatch();
        ternary.Start();
        for (int c = 0; c < iterations; c++)
        {
            foreach (int i in array)
            {
                value += i > 0 ? 2 : 3;
            }
        }
        ternary.Stop();


        Console.WriteLine(String.Format("Elapsed time for Ternary: {0}", ternary.Elapsed));
    }

    static void Main(string[] args)
    {
        Random r = new Random();
        int[] array = new int[20000000];
        for (int i = 0; i < array.Length; i++)
        {
            array[i] = r.Next(int.MinValue, int.MaxValue);
        }
        Array.Sort(array);

        long value = 0;

        runIfElse(array, 1);
        runTernary(array, 1);
        runIfElse(array, 1000);
        runTernary(array, 1000);
        
        Console.ReadLine();
    }

내 프로그램의 출력 :

If-Else의 경과 시간 : 00 : 00 : 00.0140543

3 차 경과 시간 : 00 : 00 : 00.0136723

If-Else의 경과 시간 : 00 : 00 : 14.0167870

3 차 경과 시간 : 00 : 00 : 13.9418520

밀리 초 단위로 또 다른 실행 :

If-Else의 경과 시간 : 20

3 차 경과 시간 : 19

If-Else의 경과 시간 : 13854

3 차 경과 시간 : 13610

이것은 64 비트 XP에서 실행 중이며 디버깅하지 않고 실행했습니다.

편집-x86에서 실행 :

x86을 사용하면 큰 차이가 있습니다. 이전과 동일한 xp 64 비트 시스템에서 디버깅하지 않고 수행되었지만 x86 CPU 용으로 빌드되었습니다. 이것은 OP와 비슷합니다.

If-Else의 경과 시간 : 18

3 차 경과 시간 : 35

If-Else의 경과 시간 : 20512

3 차 경과 시간 : 32673

생성 된 어셈블러 코드는 다음과 같이 이야기합니다.

a = (b > c) ? 1 : 0;

생성합니다 :

mov  edx, DWORD PTR a[rip]
mov  eax, DWORD PTR b[rip]
cmp  edx, eax
setg al

이므로:

if (a > b) printf("a");
else printf("b");

생성합니다 :

mov edx, DWORD PTR a[rip]
mov eax, DWORD PTR b[rip]
cmp edx, eax
jle .L4
    ;printf a
jmp .L5
.L4:
    ;printf b
.L5:

따라서 참 / 거짓을 찾고 있다면 명령을 적게 사용하고 점프하지 않기 때문에 삼항식 이 더 짧고 빨라질 수 있습니다 . 1과 0 이외의 값을 사용하면 if / else와 동일한 코드가 표시됩니다 (예 :

a = (b > c) ? 2 : 3;

생성합니다 :

mov edx, DWORD PTR b[rip]
mov eax, DWORD PTR c[rip]
cmp edx, eax
jle .L6
    mov eax, 2
jmp .L7
.L6:
    mov eax, 3
.L7:

if / else와 동일합니다.

ctrl + F5를 디버깅하지 않고 실행하면 디버거가 if와 삼항을 크게 느리게하는 것처럼 보이지만 삼항 연산자를 훨씬 느리게합니다.

다음 코드를 실행하면 결과가 표시됩니다. 컴파일러가 max = max를 최적화하고 제거하여 작은 밀리 초 차이가 발생한다고 생각하지만 삼항 연산자에 대해서는 최적화하지 않을 것입니다. 누군가가 어셈블리를 확인하고 이것을 확인할 수 있다면 멋질 것입니다.

--Run #1--
Type   | Milliseconds
Ternary 706
If     704
%: .9972
--Run #2--
Type   | Milliseconds
Ternary 707
If     704
%: .9958
--Run #3--
Type   | Milliseconds
Ternary 706
If     704
%: .9972

암호

  for (int t = 1; t != 10; t++)
        {
            var s = new System.Diagnostics.Stopwatch();
            var r = new Random(123456789);   //r
            int[] randomSet = new int[1000]; //a
            for (int i = 0; i < 1000; i++)   //n
                randomSet[i] = r.Next();     //dom
            long _ternary = 0; //store
            long _if = 0;      //time
            int max = 0; //result
            s.Start();
            for (int q = 0; q < 1000000; q++)
            {
                for (int i = 0; i < 1000; i++)
                    max = max > randomSet[i] ? max : randomSet[i];
            }
            s.Stop();
            _ternary = s.ElapsedMilliseconds;
            max = 0;
            s = new System.Diagnostics.Stopwatch();
            s.Start();
            for (int q = 0; q < 1000000; q++)
            {
                for (int i = 0; i < 1000; i++)
                    if (max > randomSet[i])
                        max = max; // I think the compiler may remove this but not for the ternary causing the speed difference.
                    else
                        max = randomSet[i];
            }

            s.Stop();
            _if = s.ElapsedMilliseconds;
            Console.WriteLine("--Run #" + t+"--");
            Console.WriteLine("Type   | Milliseconds\nTernary {0}\nIf     {1}\n%: {2}", _ternary, _if,((decimal)_if/(decimal)_ternary).ToString("#.####"));
        }

생성 된 IL을 살펴보면 if / else 문보다 @JonSkeet의 코드를 복사하여 붙여 넣는 것보다 16 개 적은 작업이 있습니다. 그러나 이것이 더 빠른 프로세스 여야한다는 것을 의미하지는 않습니다!

IL의 차이점을 요약하기 위해 if / else 메소드는 C # 코드 읽기 (분기 내에 추가 수행)와 거의 동일하게 변환되는 반면 조건부 코드는 값에 따라 2 또는 3을 스택에로드합니다. 그런 다음 조건부 외부의 값에 추가합니다.

다른 차이점은 사용 된 분기 명령입니다. if / else 메소드는 brtrue (true 인 경우 브랜치)를 사용하여 첫 번째 조건을 건너 뛰고 무조건 브랜치를 사용하여 if 문의 첫 번째 조건을 뛰어 넘습니다. 조건부 코드는 brtrue 대신 bgt (보다 큰 경우 분기)를 사용하므로 비교가 느릴 수 있습니다.

또한 (분기 예측에 대해 읽은 것만으로) 분기에 대한 성능 저하가 더 작을 수 있습니다. 조건부 분기에는 분기 내에 하나의 명령어 만 있지만 if / else에는 7이 있습니다. 또한 int로 변경하면 if / else 분기의 명령어 수가 1 씩 줄어들 기 때문에 long과 int를 사용하는 것 사이에 차이가있는 이유도 설명합니다. (선독을 적게한다)

다음 코드에서 if / else는 삼항 연산자보다 약 1.4 배 빠릅니다. 그러나 임시 변수를 도입하면 삼항 연산자의 런타임이 약 1.4 배 감소합니다.

If / Else : 98ms

3 차 : 141ms

임시 변수가있는 3 차 : 100ms

using System;
using System.Diagnostics;

namespace ConsoleApplicationTestIfElseVsTernaryOperator
{
    class Program
    {
        static void Main(string[] args)
        {
            Random r = new Random(0);
            int[] array = new int[20000000];
            for (int i = 0; i < array.Length; i++)
            {
                array[i] = r.Next(int.MinValue, int.MaxValue);
            }
            Array.Sort(array);
            long value;
            Stopwatch stopwatch = new Stopwatch();

            value = 0;
            stopwatch.Restart();
            foreach (int i in array)
            {
                if (i > 0)
                {
                    value += 2;
                }
                else
                {
                    value += 3;
                }
                // 98 ms
            }
            stopwatch.Stop();
            Console.WriteLine("If/Else: " + stopwatch.ElapsedMilliseconds.ToString() + " ms");

            value = 0;
            stopwatch.Restart();
            foreach (int i in array)
            {
                value += (i > 0) ? 2 : 3; 
                // 141 ms
            }

            stopwatch.Stop();
            Console.WriteLine("Ternary: " + stopwatch.ElapsedMilliseconds.ToString() + " ms");

            value = 0;
            int tempVar = 0;
            stopwatch.Restart();
            foreach (int i in array)
            {
                tempVar = (i > 0) ? 2 : 3;
                value += tempVar; 
                // 100ms
            }
            stopwatch.Stop();
            Console.WriteLine("Ternary with temp var: " + stopwatch.ElapsedMilliseconds.ToString() + " ms");

            Console.ReadKey(true);
        }
    }
}

훌륭한 답변이 너무 많지만 흥미롭고 간단한 변경 사항이 영향을 미칩니다. 아래 변경을 한 후 if-else 및 삼항 연산자를 실행하려면 동일한 시간이 걸립니다.

아래 줄을 쓰는 대신

value +=  i > 0 ? 2 : 3;

나는 이것을 사용했다.

int a =  i > 0 ? 2 : 3;
value += a;

아래 답변 중 하나는 삼항 연산자를 작성하는 나쁜 방법이 무엇인지 언급합니다.

이것이 어떤 것이 더 나은지 생각하는 대신 삼항 연산자를 작성하는 데 도움이되기를 바랍니다.

중첩 된 삼항 연산자 : 중첩 된 삼항 연산자와 여러 개의 블록이 있으면 실행하는 데 동일한 시간이 걸립니다.