c# - 三元运算符比 if-else block 慢两倍？-6ren

c# - 三元运算符比 if-else block 慢两倍？

转载作者：IT王子更新时间：2023-10-29 03:28:56

我到处都读到三元运算符应该比它的等效 if-else block 更快，或者至少与其相同。

但是，我做了下面的测试，发现不是这样的:

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 block ，并取消注释三元运算符行，则大约需要 157 毫秒。

为什么会这样？

最佳答案

为了回答这个问题，我们将针对每种情况检查 X86 和 X64 JIT 生成的汇编代码。

X86，如果/那么

    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，如果/那么

    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 条机器指令(添加)。

其次:为什么三元运算符在 X86 和 X64 上都比较慢？

这是由于影响 JIT 优化器的操作顺序存在细微差别。为了 JIT 三元运算符，而不是直接在 add 机器指令本身中编码 2 和 3，JIT 创建一个中间变量(在注册)来保存结果。然后将该寄存器从 32 位符号扩展为 64 位，然后再将其添加到 value。由于所有这些都是在 X64 的寄存器中执行的，尽管三元运算符的复杂性显着增加，但净影响在某种程度上被最小化了。

另一方面，X86 JIT 受到更大程度的影响，因为在内部循环中添加一个新的中间值会导致它“溢出”另一个值，导致内部循环中至少有 2 次额外的内存访问(请参阅 X86 三元代码中对 [ebp-14h] 的访问。

关于c# - 三元运算符比 if-else block 慢两倍？，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/17328641/

文章推荐： c# - Task.Result 和.GetAwaiter.GetResult() 一样吗？

文章推荐： go - 使用 go-restful 和 swagger 显示 PUT 正文格式

文章推荐： docker 环境下的 Golang revel 框架热重载

文章推荐： c# - 如何使用 OpenFileDialog 选择文件夹？

VBS教程：运算符-Or 运算符
Or 运算符对两个表达式进行逻辑“或”运算。 result = expression1 Or expression2 参数 result 任意数值变量。 expression1 任意
VBS教程：运算符-Not 运算符
Not 运算符对表达式执行逻辑非运算。 result = Not expression 参数 result 任意数值变量。 expression 任意表达式。说明下表显示如何
VBS教程：运算符-Is 运算符
Is 运算符比较两个对象引用变量。 result = object1 Is object2 参数 result 任意数值变量。 object1 任意对象名。 object2 任意
VBS教程：运算符-\ 运算符
\ 运算符两个数相除并返回以整数形式表示的结果。 result = number1\number2 参数 result 任意数值变量。 number1 任意数值表达式。 numbe
VBS教程：运算符-And 运算符
And 运算符对两个表达式进行逻辑“与”运算。 result = expression1 And expression2 参数 result 任意数值变量。 expression1
VBS教程：运算符-运算符(+)
运算符(+) 计算两个数之和。 result = expression1 + expression2 参数 result 任意数值变量。 expression1 任意表达式。 exp
Javascript + 运算符 vs - 运算符
我对此感到困惑snippet : var n1 = 5-"4"; var n2 = 5+"4"; alert(n1); alert(n2); 我知道 n1 是 1。那是因为减号运算符会将字符串“4”转
c++ - |运算符 ,++ 和 I 运算符
我想我会得到 12，而不是 7。 w++，那么w就是4，也就是100，而w++， w 将是 8，1000；所以 w++|z++ 将是 100|1000 = 1100 将是 12。我怎么了？ int
VBS教程：运算符-Xor 运算符
Xor 运算符对两个表达式进行逻辑“异或”运算。 result = expression1 Xor expression2 参数 result 任意数值变量。 expression1
VBS教程：运算符-Mod 运算符
Mod 运算符两个数值相除并返回其余数。 result = number1 Mod number2 参数 result 任意数值变量。 number1 任意数值表达式。 numbe
VBS教程：运算符-Imp 运算符
Imp 运算符对两个表达式进行逻辑蕴涵运算。 result = expression1 Imp expression2 参数 result 任意数值变量。 expression1 任
VBS教程：运算符-Eqv 运算符
Eqv 运算符执行两个表达式的逻辑等价运算。 result = expression1 Eqv expression2 参数 result 任意数值变量。 expression1 任
c++ - 时序运算符+、运算符-、运算符*和运算符/
我有一个运算符重载的简单数学 vector 类。我想为我的运算符(operator)获取一些计时结果。我可以通过计时以下代码轻松计时我的 +=、-=、*= 和/=: Vector sum; for(s
c++ - 用户定义的比较运算符(运算符>、运算符<等)
我是用户定义比较运算符的新手。我正在读一本书，其中提到了以下示例: struct P { int x, y; bool operator、运算符<等)，我们
sql - 标准 SQL bool 运算符 IS 与等于 (=) 运算符
在 SQL 的维基百科页面上，有一些关于 SQL 中 bool 逻辑的真值表。 [1] 维基百科页面似乎来源于 SQL:2003 标准。等号运算符 (=) 的真值表与 SQL:2003 草案中的 I
c++ - 奇怪的 c++ 运算符(运算符 unsigned short())
我遇到了一个奇怪的 C++ 运算符。 http://www.terralib.org/html/v410/classoracle_1_1occi_1_1_number.html#a0f2780081f
C++:如果我重载 new 运算符，我是否也必须重载 delete 运算符？
我正在阅读关于 SO 和 answers 中的一个问题，它被提到为: If no unambiguous matching deallocation function can be found, pr
python - 如何在不使用 * 运算符(或/运算符)的情况下递归地将两个正整数相乘？ .您可以使用加法、减法和位移
我偶然发现了这个解决方案，但我无法理解其中到底发生了什么。谁能解释一下! 据我了解，它试图通过计算一半的单元格然后将其加倍来计算 a*b 网格中的单元格数量。但是我无法理解递归调用。请不要建议其他解
Go学习笔记（6）Go基本类型&运算符
Go的基本类型布尔类型bool 长度：1字节取值：布尔类型的取值只能是true或者false，不能用数字来表示整型通用整型 int / uint（有符号 / 无符号，下面也类似）长度：根据运
JavaScript 运算符
在本教程中，您将学习JavaScript中可用的不同运算符，以及在示例的帮助下如何使用它们。什么是运算符？在JavaScript中，运算符是一种特殊符号，用于对运算数（值和变量）执行操作。例如，

IT王子

个人简介

我是一名优秀的程序员,十分优秀！

作者热门文章

滴滴打车优惠券免费领取

全站热门文章

首页

博学

6Ren·AI

商城