삼항 연산자는 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보다 훨씬 느립니까?
이는 코드의 다음 특성 때문입니다.
- X64에는 사용 가능한 추가 레지스터가 여러 개 있으며 각 레지스터는 64 비트입니다. 이를 통해 X64 JIT
i는 어레이 에서로드 하는 것 외에 레지스터를 사용하여 내부 루프를 완전히 수행 할 수 있으며 X86 JIT는 루프에 여러 스택 작업 (메모리 액세스)을 배치합니다. value64 비트 정수이며 X86에서 2 개의 기계 명령어 (add뒤에adc)가 필요하지만 X64 (add) 에서는 1 만 필요합니다 .
둘째 : 왜 삼항 연산자가 X86과 X64에서 더 느려 집니까?
This is due to a subtle difference in the order of operations impacting the JIT's optimizer. To JIT the ternary operator, rather than directly coding 2 and 3 in the add machine instructions themselves, the JIT creating an intermediate variable (in a register) to hold the result. This register is then sign-extended from 32-bits to 64-bits before adding it to value. Since all of this is performed in registers for X64, despite the significant increase in complexity for the ternary operator the net impact is somewhat minimized.
반면에 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와 3 진과는 관련이 없습니다.
jitted disassemblies를 보면 (여기서는 다시 붙여 넣지 않을 것이며, 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의 대답 이 여기에 가장 맞는 것 같습니다.
고급 프로그래밍 언어로 명심해야 할 것을 언급하려고합니다.
우선, 조건부 연산자가 C in의 if-else 문 을 사용하여 더 빠르거나 동등한 성능을 발휘한다고 들었습니다 .
그 이유는 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);
}
}
}
참고 URL : https://stackoverflow.com/questions/17328641/ternary-operator-is-twice-as-slow-as-an-if-else-block
'IT story' 카테고리의 다른 글
| Git GUI 또는 ssh-keygen을 사용하는 SSH 개인 키 권한이 너무 열려 있습니다. (0) | 2020.04.08 |
|---|---|
| NameError : 전역 이름 'xrange'가 Python 3에 정의되어 있지 않습니다 (0) | 2020.04.08 |
| SQL Server에서 열 크기 변경 (0) | 2020.04.08 |
| Windows 서비스의 "실행 파일 경로"수정 (0) | 2020.04.08 |
| iPhone 브라우저에서 localhost에서 실행되는 웹 사이트에 액세스하는 방법 (0) | 2020.04.08 |