三項演算子はif-elseブロックの2倍遅いですか？
三項演算子は、同等の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());
私のコンピューターは上記のコードを実行するのに85ミリ秒かかりました。しかし、if-elseチャンクをコメントアウトし、三項演算子の行のコメントを外すと、約157ミリ秒かかります。
なぜこうなった？
この質問に答えるために、これらの各ケースについて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は、ループにいくつかのスタック操作（メモリアクセス）を配置します。 valueは64ビット整数で、X86では2つのマシン命令（addの後にadcが続く）が必要ですが、X64では1つだけです（add）。
2番目：X86とX64の両方で三項演算子が遅いのはなぜですか
これは、JITのオプティマイザーに影響を与える操作の順序の微妙な違いによるものです。 addマシン命令自体に2および3を直接コーディングするのではなく、三項演算子をJITするために、JITは結果を保持する中間変数（レジスター内）を作成します。このレジスタは、valueに追加する前に、32ビットから64ビットに符号拡張されます。このすべてがX64のレジスターで実行されるため、三項演算子の複雑さが大幅に増加しているにもかかわらず、最終的な影響はいくらか最小限に抑えられます。
一方、X86 JITは、内部ループに新しい中間値を追加すると別の値を「スピル」し、内部ループで少なくとも2つの追加メモリアクセスが発生するため、より大きな影響を受けます（アクセスを参照） X86三元コードの[ebp-14h]へ）。
編集：すべての変更...以下を参照してください。
X64 CLRでは結果を再現できませんが、x86ではcanです。 x64では、条件演算子とif/elseの間にsmallの差（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
したがって、以前とは異なり、are本当の違いが見られると思います。そして、それはすべてx86 JITに関係しています。 whatが違いを引き起こしているとは言いたくない-cordbgに入るのが面倒なら、詳細を後で投稿を更新するかもしれない:)
興味深いことに、最初に配列をソートせずに、少なくともx64では約4.5倍の時間がかかるテストになります。私の推測では、これは分岐予測と関係があると思われます。
コード：
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 vs ternaryとはあまり関係ありません。
Jitted disassembliesを見ると（ここでは繰り返しませんが、@ 280Z28の答えを見てください）、あなたはリンゴとオレンジの比較であることがわかります。 1つのケースでは、定数値を使用して2つの異なる+=操作を作成し、どちらを選択するかは条件に依存し、もう1つのケースでは、valueが追加する+=を作成します条件に依存します。
If/else vs ternaryを本当に比較したい場合、これはより公平な比較になります（今度は両方が等しく「遅い」、またはternaryが少し速いとさえ言えます）：
int diff;
if (i > 0)
diff = 2;
else
diff = 3;
value += diff;
vs.
value += i > 0 ? 2 : 3;
これで、if/elseの逆アセンブリは次のようになります。ループ変数（i）のレジスタも使用しなくなるため、これは3項の場合よりも少し悪いことに注意してください。
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氏のブログで[ どちらが速いですか？ ]をご覧ください。そして、私は Mr。Ersönmezの答え がここで最も正しいものだと思う。
高度なプログラミング言語で心に留めておくべきことを述べようとしています。
まず、条件演算子がif-elseステートメントin 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
Cはプラットフォームのアセンブリにより近いため、条件演算子とif-elseステートメントは同じことをすると概念的に同じになりますが、条件演算子in Cを使用するとさらに高速になる可能性があります。
指定した元のコードでは、foreachループで条件演算子が使用されます。これにより、それらの違いを確認するために混乱が生じます。だから私は次のコードを提案しています：
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の2つのバージョンであり、最適化されていません。それらは長いので、表示に画像を使用していますが、右側は最適化されたものです：
（クリックするとフルサイズの画像が表示されます。）
どちらのバージョンのコードでも、条件演算子のILはif-elseステートメントよりも短く見えますが、最終的に生成されるマシンコードには疑問が残ります。以下は両方の方法の手順であり、前者の画像は最適化されていません。後者は最適化された画像です。
最適化されていない指示：（フルサイズの画像を見るにはクリックしてください。）
![ybhgM.png]()
最適化された手順：（フルサイズの画像を見るにはクリックしてください。）
![6kgzJ.png]()
後者では、黄色のブロックはi<=0の場合にのみ実行されるコードで、青色のブロックはi>0の場合に実行されます。どちらのバージョンの命令でも、if-elseステートメントは短くなります。
異なる命令では、[ CPI ]は必ずしも同じではないことに注意してください。論理的には、同一の命令の場合、命令が増えるとサイクルが長くなります。ただし、命令フェッチ時間とパイプ/キャッシュも考慮に入れた場合、実行の実際の合計時間はプロセッサに依存します。プロセッサは分岐を予測することもできます。
最新のプロセッサにはさらに多くのコアがあり、それによって状況はより複雑になる可能性があります。 Intelプロセッサを使用している場合は、[ Intel®64およびIA-32アーキテクチャ最適化リファレンスマニュアル ]をご覧ください。
ハードウェアで実装されたCLRがあったかどうかはわかりませんが、はいの場合、ILの方が明らかに小さいため、条件演算子を使用した方がおそらく高速になります。
注：すべてのマシンコードはx86です。
Jon Skeetが行ったことを実行し、1回の反復と1,000回の反復を実行したところ、OPとJonの両方から異なる結果が得られました。私の場合、3進法はわずかに高速です。正確なコードは次のとおりです。
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
Ternaryの経過時間：00：00：00.0136723
If-Elseの経過時間：00：00：14.0167870
Ternaryの経過時間：00：00：13.9418520
ミリ秒単位での別の実行：
If-Elseの経過時間：20
Ternaryの経過時間：19
If-Elseの経過時間：13854
Ternaryの経過時間：13610
これは64ビットXPで実行されており、デバッグなしで実行しました。
編集-x86での実行：
X86を使用すると大きな違いがあります。これは、以前と同じXP 64ビットマシン上でデバッグせずに行われましたが、x86 CPU用に構築されました。これは、OPのように見えます。
If-Elseの経過時間：18
Ternaryの経過時間：35
If-Elseの経過時間：20512
Ternaryの経過時間：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:
したがって、3進数のcanは、使用する命令の数が少なくジャンプがないために短く、速くなりますif真/偽を探しています。 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と同じです。
生成されたILを見ると、if/elseステートメント（@JonSkeetのコードのコピーと貼り付け）よりも操作が16個少なくなっています。しかし、それはそれがより速いプロセスであるべきという意味ではありません！
ILの違いをまとめると、if/elseメソッドはC＃コードの読み取り（ブランチ内での追加を実行）とほぼ同じに変換されますが、条件コードは2または3をスタックに（値に応じて）ロードし、その後、条件外の値に追加します。
もう1つの違いは、使用される分岐命令です。 if/elseメソッドは、brtrue（trueの場合はブランチ）を使用して最初の条件を飛び越え、無条件ブランチを使用してifステートメントの最初のアウトからジャンプします。条件コードは、brtrueの代わりにbgt（より大きい場合は分岐）を使用します。これは、比較に時間がかかる可能性があります。
また、（分岐予測について読んだだけで）分岐のパフォーマンスが低下する可能性があります。条件分岐には分岐内に1つの命令しかありませんが、if/elseには7があります。これは、longとintの使用に違いがある理由も説明します。 （先読みを少なくする）
Ctrl + F5をデバッグせずに実行すると、デバッガーはifsとternaryの両方を大幅に遅くするように見えますが、三項演算子をさらに遅くするようです。
ここで次のコードを実行すると、結果が得られます。小さなミリ秒の違いは、コンパイラが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("#.####"));
}
次のコードでは、if/elseは三項演算子よりも約1.4倍速いようです。しかし、一時変数を導入すると、三項演算子の実行時間が約1.4倍減少することがわかりました。
If/Else：98ミリ秒
Ternary：141ミリ秒
Temp varを含む3値：100ミリ秒
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);
}
}
}