经验首页 前端设计 程序设计 Java相关 移动开发 数据库/运维 软件/图像 大数据/云计算 其他经验
当前位置:技术经验 » 程序设计 » ASP.net » 查看文章
【译】.NET 7 中的性能改进(四)
来源:cnblogs  作者:郑子铭  时间:2023/2/24 9:08:28  对本文有异议

原文 | Stephen Toub

翻译 | 郑子铭

边界检查消除 (Bounds Check Elimination)

让.NET吸引人的地方之一是它的安全性。运行时保护对数组、字符串和跨度的访问,这样你就不会因为走到任何一端而意外地破坏内存;如果你这样做,而不是读/写任意的内存,你会得到异常。当然,这不是魔术;它是由JIT在每次对这些数据结构进行索引时插入边界检查完成的。例如,这个:

  1. [MethodImpl(MethodImplOptions.NoInlining)]
  2. static int Read0thElement(int[] array) => array[0];

结果是:

  1. G_M000_IG01: ;; offset=0000H
  2. 4883EC28 sub rsp, 40
  3. G_M000_IG02: ;; offset=0004H
  4. 83790800 cmp dword ptr [rcx+08H], 0
  5. 7608 jbe SHORT G_M000_IG04
  6. 8B4110 mov eax, dword ptr [rcx+10H]
  7. G_M000_IG03: ;; offset=000DH
  8. 4883C428 add rsp, 40
  9. C3 ret
  10. G_M000_IG04: ;; offset=0012H
  11. E8E9A0C25F call CORINFO_HELP_RNGCHKFAIL
  12. CC int3

数组在rcx寄存器中被传入这个方法,指向对象中的方法表指针,而数组的长度就存储在对象中的方法表指针之后(在64位进程中是8字节)。因此,cmp dword ptr [rcx+08H], 0指令是在读取数组的长度,并将长度与0进行比较;这是有道理的,因为长度不能是负数,而且我们试图访问第0个元素,所以只要长度不是0,数组就有足够的元素让我们访问其第0个元素。如果长度为0,代码会跳到函数的末尾,其中包含调用 CORINFO_HELP_RNGCHKFAIL;那是一个JIT辅助函数,抛出一个 IndexOutOfRangeException。然而,如果长度足够,它就会读取存储在数组数据开始处的int,在64位上,它比指针(mov eax, dword ptr [rcx+10H])多16字节(0x10)。

虽然这些边界检查本身并不昂贵,但做了很多,其成本就会增加。因此,虽然JIT需要确保 "安全 "的访问不会出界,但它也试图证明某些访问不会出界,在这种情况下,它不需要发出边界检查,因为它知道这将是多余的。在每一个.NET版本中,越来越多的案例被加入,以找到可以消除这些边界检查的地方,.NET 7也不例外。

例如,来自@anthonycaninodotnet/runtime#61662使JIT能够理解各种形式的二进制操作作为范围检查的一部分。考虑一下这个方法。

  1. [MethodImpl(MethodImplOptions.NoInlining)]
  2. private static ushort[]? Convert(ReadOnlySpan<byte> bytes)
  3. {
  4. if (bytes.Length != 16)
  5. {
  6. return null;
  7. }
  8. var result = new ushort[8];
  9. for (int i = 0; i < result.Length; i++)
  10. {
  11. result[i] = (ushort)(bytes[i * 2] * 256 + bytes[i * 2 + 1]);
  12. }
  13. return result;
  14. }

它正在验证输入跨度是16个字节,然后创建一个新的ushort[8],数组中的每个ushort结合了两个输入字节。为了做到这一点,它在输出数组上循环,并使用i * 2和i * 2 + 1作为索引进入字节数组。在.NET 6上,这些索引操作中的每一个都会导致边界检查,其汇编如下。

  1. cmp r8d,10
  2. jae short G_M000_IG04
  3. movsxd r8,r8d

其中 G_M000_IG04 是我们现在熟悉的 CORINFO_HELP_RNGCHKFAIL 的调用。但在.NET 7上,我们得到这个方法的汇编。

  1. G_M000_IG01: ;; offset=0000H
  2. 56 push rsi
  3. 4883EC20 sub rsp, 32
  4. G_M000_IG02: ;; offset=0005H
  5. 488B31 mov rsi, bword ptr [rcx]
  6. 8B4908 mov ecx, dword ptr [rcx+08H]
  7. 83F910 cmp ecx, 16
  8. 754C jne SHORT G_M000_IG05
  9. 48B9302F542FFC7F0000 mov rcx, 0x7FFC2F542F30
  10. BA08000000 mov edx, 8
  11. E80C1EB05F call CORINFO_HELP_NEWARR_1_VC
  12. 33D2 xor edx, edx
  13. align [0 bytes for IG03]
  14. G_M000_IG03: ;; offset=0026H
  15. 8D0C12 lea ecx, [rdx+rdx]
  16. 448BC1 mov r8d, ecx
  17. FFC1 inc ecx
  18. 458BC0 mov r8d, r8d
  19. 460FB60406 movzx r8, byte ptr [rsi+r8]
  20. 41C1E008 shl r8d, 8
  21. 8BC9 mov ecx, ecx
  22. 0FB60C0E movzx rcx, byte ptr [rsi+rcx]
  23. 4103C8 add ecx, r8d
  24. 0FB7C9 movzx rcx, cx
  25. 448BC2 mov r8d, edx
  26. 6642894C4010 mov word ptr [rax+2*r8+10H], cx
  27. FFC2 inc edx
  28. 83FA08 cmp edx, 8
  29. 7CD0 jl SHORT G_M000_IG03
  30. G_M000_IG04: ;; offset=0056H
  31. 4883C420 add rsp, 32
  32. 5E pop rsi
  33. C3 ret
  34. G_M000_IG05: ;; offset=005CH
  35. 33C0 xor rax, rax
  36. G_M000_IG06: ;; offset=005EH
  37. 4883C420 add rsp, 32
  38. 5E pop rsi
  39. C3 ret
  40. ; Total bytes of code 100

没有边界检查,这一点最容易从方法结尾处没有提示性的调用 CORINFO_HELP_RNGCHKFAIL 看出来。有了这个PR,JIT能够理解某些乘法和移位操作的影响以及它们与数据结构的边界的关系。因为它可以看到结果数组的长度是8,并且循环从0到那个独占的上界进行迭代,它知道i总是在[0, 7]范围内,这意味着i * 2总是在[0, 14]范围内,i * 2 + 1总是在[0, 15]范围内。因此,它能够证明边界检查是不需要的。

dotnet/runtime#61569dotnet/runtime#62864也有助于在处理从RVA静态字段("相对虚拟地址 (Relative Virtual Address)"静态字段,基本上是住在模块数据部分的静态字段)初始化的常量字符串和跨度时消除边界检查。例如,考虑这个基准。

  1. [Benchmark]
  2. [Arguments(1)]
  3. public char GetChar(int i)
  4. {
  5. const string Text = "hello";
  6. return (uint)i < Text.Length ? Text[i] : '\0';
  7. }

在.NET 6上,我们得到这个程序集:

  1. ; Program.GetChar(Int32)
  2. sub rsp,28
  3. mov eax,edx
  4. cmp rax,5
  5. jl short M00_L00
  6. xor eax,eax
  7. add rsp,28
  8. ret
  9. M00_L00:
  10. cmp edx,5
  11. jae short M00_L01
  12. mov rax,2278B331450
  13. mov rax,[rax]
  14. movsxd rdx,edx
  15. movzx eax,word ptr [rax+rdx*2+0C]
  16. add rsp,28
  17. ret
  18. M00_L01:
  19. call CORINFO_HELP_RNGCHKFAIL
  20. int 3
  21. ; Total bytes of code 56

这开始是有意义的:JIT显然能够看到Text的长度是5,所以它通过做cmp rax,5来实现(uint)i < Text.Length的检查,如果i作为一个无符号值大于或等于5,它就把返回值清零(返回'\0')并退出。如果长度小于5(在这种情况下,由于无符号比较,它也至少是0),它就会跳到M00_L00,从字符串中读取值......但是我们又看到了另一个与5的cmp,这次是作为范围检查的一部分。因此,即使JIT知道索引在边界内,它也无法移除边界检查。现在是这样;在.NET 7中,我们得到这样的结果。

  1. ; Program.GetChar(Int32)
  2. cmp edx,5
  3. jb short M00_L00
  4. xor eax,eax
  5. ret
  6. M00_L00:
  7. mov rax,2B0AF002530
  8. mov rax,[rax]
  9. mov edx,edx
  10. movzx eax,word ptr [rax+rdx*2+0C]
  11. ret
  12. ; Total bytes of code 29

好多了。

dotnet/runtime#67141是一个很好的例子,说明不断发展的生态系统需求是如何促使特定的优化进入JIT的。Regex编译器和源码生成器通过使用存储在字符串中的位图查找来处理正则表达式字符类的一些情况。例如,为了确定一个char c是否属于字符类"[A-Za-z0-9_]"(这将匹配下划线或任何ASCII字母或数字),该实现最终会生成一个类似以下方法主体的表达式。

  1. [Benchmark]
  2. [Arguments('a')]
  3. public bool IsInSet(char c) =>
  4. c < 128 && ("\0\0\0\u03FF\uFFFE\u87FF\uFFFE\u07FF"[c >> 4] & (1 << (c & 0xF))) != 0;

这个实现是把一个8个字符的字符串当作一个128位的查找表。如果已知该字符在范围内(比如它实际上是一个7位的值),那么它就用该值的前3位来索引字符串的8个元素,用后4位来选择该元素中的16位之一,给我们一个答案,即这个输入字符是否在该集合中。在.NET 6中,即使我们知道这个字符在字符串的范围内,JIT也无法看穿长度比较或位移。

  1. ; Program.IsInSet(Char)
  2. sub rsp,28
  3. movzx eax,dx
  4. cmp eax,80
  5. jge short M00_L00
  6. mov edx,eax
  7. sar edx,4
  8. cmp edx,8
  9. jae short M00_L01
  10. mov rcx,299835A1518
  11. mov rcx,[rcx]
  12. movsxd rdx,edx
  13. movzx edx,word ptr [rcx+rdx*2+0C]
  14. and eax,0F
  15. bt edx,eax
  16. setb al
  17. movzx eax,al
  18. add rsp,28
  19. ret
  20. M00_L00:
  21. xor eax,eax
  22. add rsp,28
  23. ret
  24. M00_L01:
  25. call CORINFO_HELP_RNGCHKFAIL
  26. int 3
  27. ; Total bytes of code 75

前面提到的PR处理了长度检查的问题。而这个PR则负责处理位的移动。所以在.NET 7中,我们得到了这个可爱的东西。

  1. ; Program.IsInSet(Char)
  2. movzx eax,dx
  3. cmp eax,80
  4. jge short M00_L00
  5. mov edx,eax
  6. sar edx,4
  7. mov rcx,197D4800608
  8. mov rcx,[rcx]
  9. mov edx,edx
  10. movzx edx,word ptr [rcx+rdx*2+0C]
  11. and eax,0F
  12. bt edx,eax
  13. setb al
  14. movzx eax,al
  15. ret
  16. M00_L00:
  17. xor eax,eax
  18. ret
  19. ; Total bytes of code 51

请注意,明显缺乏对 CORINFO_HELP_RNGCHKFAIL 的调用。正如你可能猜到的那样,这种检查在 Regex 中可能会发生很多,这使得它成为一个非常有用的补充。

当谈及数组访问时,边界检查是一个明显的开销来源,但它们不是唯一的。还有就是要尽可能地使用最便宜的指令。在.NET 6中,有一个方法,比如:

  1. [MethodImpl(MethodImplOptions.NoInlining)]
  2. private static int Get(int[] values, int i) => values[i];

将会生成如下的汇编代码:

  1. ; Program.Get(Int32[], Int32)
  2. sub rsp,28
  3. cmp edx,[rcx+8]
  4. jae short M01_L00
  5. movsxd rax,edx
  6. mov eax,[rcx+rax*4+10]
  7. add rsp,28
  8. ret
  9. M01_L00:
  10. call CORINFO_HELP_RNGCHKFAIL
  11. int 3
  12. ; Total bytes of code 27

这在我们之前的讨论中应该很熟悉;JIT正在加载数组的长度([rcx+8])并与i的值(在edx中)进行比较,然后跳转到最后,如果i出界就抛出异常。在跳转之后,我们看到一条movsxd rax, edx指令,它从edx中获取i的32位值并将其移动到64位寄存器rax中。作为移动的一部分,它对其进行了符号扩展;这就是指令名称中的 "sxd "部分(符号扩展意味着新的64位值的前32位将被设置为32位值的前一位的值,这样数字就保留了其符号值)。但有趣的是,我们知道数组和跨度的长度是非负的,而且由于我们刚刚用长度对i进行了边界检查,我们也知道i是非负的。这使得这种符号扩展毫无用处,因为上面的位被保证为0。而这正是@pentpdotnet/runtime#57970对数组和跨度的作用(dotnet/runtime#70884也同样避免了其他情况下的一些有符号转换)。现在在.NET 7上,我们得到了这个。

  1. ; Program.Get(Int32[], Int32)
  2. sub rsp,28
  3. cmp edx,[rcx+8]
  4. jae short M01_L00
  5. mov eax,edx
  6. mov eax,[rcx+rax*4+10]
  7. add rsp,28
  8. ret
  9. M01_L00:
  10. call CORINFO_HELP_RNGCHKFAIL
  11. int 3
  12. ; Total bytes of code 26

不过,这并不是数组访问的唯一开销来源。事实上,有一类非常大的数组访问开销一直存在,但这是众所周知的,甚至有老的FxCop规则和新的Roslyn分析器都警告它:多维数组访问。多维数组的开销不仅仅是在每个索引操作上的额外分支,或者计算元素位置所需的额外数学运算,而是它们目前通过JIT的优化阶段时基本没有修改。dotnet/runtime#70271改善了世界上的现状,在JIT的管道早期对多维数组访问进行扩展,这样以后的优化阶段可以像改善其他代码一样改善多维访问,包括CSE和循环不变量提升。这方面的影响在一个简单的基准中可以看到,这个基准是对一个多维数组的所有元素进行求和。

  1. private int[,] _square;
  2. [Params(1000)]
  3. public int Size { get; set; }
  4. [GlobalSetup]
  5. public void Setup()
  6. {
  7. int count = 0;
  8. _square = new int[Size, Size];
  9. for (int i = 0; i < Size; i++)
  10. {
  11. for (int j = 0; j < Size; j++)
  12. {
  13. _square[i, j] = count++;
  14. }
  15. }
  16. }
  17. [Benchmark]
  18. public int Sum()
  19. {
  20. int[,] square = _square;
  21. int sum = 0;
  22. for (int i = 0; i < Size; i++)
  23. {
  24. for (int j = 0; j < Size; j++)
  25. {
  26. sum += square[i, j];
  27. }
  28. }
  29. return sum;
  30. }
方法 运行时 平均值 比率
Sum .NET 6.0 964.1 us 1.00
Sum .NET 7.0 674.7 us 0.70

前面的例子假设你知道多维数组中每个维度的大小(它在循环中直接引用了Size)。显然,这并不总是(甚至可能很少)的情况。在这种情况下,你更可能使用Array.GetUpperBound方法,而且因为多维数组可以有一个非零的下限,所以使用Array.GetLowerBound。这将导致这样的代码。

  1. private int[,] _square;
  2. [Params(1000)]
  3. public int Size { get; set; }
  4. [GlobalSetup]
  5. public void Setup()
  6. {
  7. int count = 0;
  8. _square = new int[Size, Size];
  9. for (int i = 0; i < Size; i++)
  10. {
  11. for (int j = 0; j < Size; j++)
  12. {
  13. _square[i, j] = count++;
  14. }
  15. }
  16. }
  17. [Benchmark]
  18. public int Sum()
  19. {
  20. int[,] square = _square;
  21. int sum = 0;
  22. for (int i = square.GetLowerBound(0); i < square.GetUpperBound(0); i++)
  23. {
  24. for (int j = square.GetLowerBound(1); j < square.GetUpperBound(1); j++)
  25. {
  26. sum += square[i, j];
  27. }
  28. }
  29. return sum;
  30. }

在.NET 7中,由于dotnet/runtime#60816,那些GetLowerBound和GetUpperBound的调用成为JIT的内在因素。对于编译器来说,"内在的 "是指编译器拥有内在的知识,这样就不会仅仅依赖一个方法的定义实现(如果它有的话),编译器可以用它认为更好的东西来替代。在.NET中,有数以千计的方法以这种方式为JIT所知,其中GetLowerBound和GetUpperBound是最近的两个。现在,作为本征,当它们被传递一个常量值时(例如,0代表第0级),JIT可以替代必要的汇编指令,直接从存放边界的内存位置读取。下面是这个基准的汇编代码在.NET 6中的样子;这里主要看到的是对GetLowerBound和GetUpperBound的所有调用。

  1. ; Program.Sum()
  2. push rdi
  3. push rsi
  4. push rbp
  5. push rbx
  6. sub rsp,28
  7. mov rsi,[rcx+8]
  8. xor edi,edi
  9. mov rcx,rsi
  10. xor edx,edx
  11. cmp [rcx],ecx
  12. call System.Array.GetLowerBound(Int32)
  13. mov ebx,eax
  14. mov rcx,rsi
  15. xor edx,edx
  16. call System.Array.GetUpperBound(Int32)
  17. cmp eax,ebx
  18. jle short M00_L03
  19. M00_L00:
  20. mov rcx,[rsi]
  21. mov ecx,[rcx+4]
  22. add ecx,0FFFFFFE8
  23. shr ecx,3
  24. cmp ecx,1
  25. jbe short M00_L05
  26. lea rdx,[rsi+10]
  27. inc ecx
  28. movsxd rcx,ecx
  29. mov ebp,[rdx+rcx*4]
  30. mov rcx,rsi
  31. mov edx,1
  32. call System.Array.GetUpperBound(Int32)
  33. cmp eax,ebp
  34. jle short M00_L02
  35. M00_L01:
  36. mov ecx,ebx
  37. sub ecx,[rsi+18]
  38. cmp ecx,[rsi+10]
  39. jae short M00_L04
  40. mov edx,ebp
  41. sub edx,[rsi+1C]
  42. cmp edx,[rsi+14]
  43. jae short M00_L04
  44. mov eax,[rsi+14]
  45. imul rax,rcx
  46. mov rcx,rdx
  47. add rcx,rax
  48. add edi,[rsi+rcx*4+20]
  49. inc ebp
  50. mov rcx,rsi
  51. mov edx,1
  52. call System.Array.GetUpperBound(Int32)
  53. cmp eax,ebp
  54. jg short M00_L01
  55. M00_L02:
  56. inc ebx
  57. mov rcx,rsi
  58. xor edx,edx
  59. call System.Array.GetUpperBound(Int32)
  60. cmp eax,ebx
  61. jg short M00_L00
  62. M00_L03:
  63. mov eax,edi
  64. add rsp,28
  65. pop rbx
  66. pop rbp
  67. pop rsi
  68. pop rdi
  69. ret
  70. M00_L04:
  71. call CORINFO_HELP_RNGCHKFAIL
  72. M00_L05:
  73. mov rcx,offset MT_System.IndexOutOfRangeException
  74. call CORINFO_HELP_NEWSFAST
  75. mov rsi,rax
  76. call System.SR.get_IndexOutOfRange_ArrayRankIndex()
  77. mov rdx,rax
  78. mov rcx,rsi
  79. call System.IndexOutOfRangeException..ctor(System.String)
  80. mov rcx,rsi
  81. call CORINFO_HELP_THROW
  82. int 3
  83. ; Total bytes of code 219

现在,对于.NET 7来说,这里是它的内容:

  1. ; Program.Sum()
  2. push r14
  3. push rdi
  4. push rsi
  5. push rbp
  6. push rbx
  7. sub rsp,20
  8. mov rdx,[rcx+8]
  9. xor eax,eax
  10. mov ecx,[rdx+18]
  11. mov r8d,ecx
  12. mov r9d,[rdx+10]
  13. lea ecx,[rcx+r9+0FFFF]
  14. cmp ecx,r8d
  15. jle short M00_L03
  16. mov r9d,[rdx+1C]
  17. mov r10d,[rdx+14]
  18. lea r10d,[r9+r10+0FFFF]
  19. M00_L00:
  20. mov r11d,r9d
  21. cmp r10d,r11d
  22. jle short M00_L02
  23. mov esi,r8d
  24. sub esi,[rdx+18]
  25. mov edi,[rdx+10]
  26. M00_L01:
  27. mov ebx,esi
  28. cmp ebx,edi
  29. jae short M00_L04
  30. mov ebp,[rdx+14]
  31. imul ebx,ebp
  32. mov r14d,r11d
  33. sub r14d,[rdx+1C]
  34. cmp r14d,ebp
  35. jae short M00_L04
  36. add ebx,r14d
  37. add eax,[rdx+rbx*4+20]
  38. inc r11d
  39. cmp r10d,r11d
  40. jg short M00_L01
  41. M00_L02:
  42. inc r8d
  43. cmp ecx,r8d
  44. jg short M00_L00
  45. M00_L03:
  46. add rsp,20
  47. pop rbx
  48. pop rbp
  49. pop rsi
  50. pop rdi
  51. pop r14
  52. ret
  53. M00_L04:
  54. call CORINFO_HELP_RNGCHKFAIL
  55. int 3
  56. ; Total bytes of code 130

重要的是,注意没有更多的调用(除了最后的边界检查异常)。例如,代替第一次的GetUpperBound调用。

  1. call System.Array.GetUpperBound(Int32)

我们得到了:

  1. mov r9d,[rdx+1C]
  2. mov r10d,[rdx+14]
  3. lea r10d,[r9+r10+0FFFF]

而且最后会快得多:

方法 运行时 平均值 比率
Sum .NET 6.0 2,657.5 us 1.00
Sum .NET 7.0 676.3 us 0.25

原文链接

Performance Improvements in .NET 7

知识共享许可协议

本作品采用知识共享署名-非商业性使用-相同方式共享 4.0 国际许可协议进行许可。

欢迎转载、使用、重新发布,但务必保留文章署名 郑子铭 (包含链接: http://www.cnblogs.com/MingsonZheng/ ),不得用于商业目的,基于本文修改后的作品务必以相同的许可发布。

如有任何疑问,请与我联系 (MingsonZheng@outlook.com)

原文链接:https://www.cnblogs.com/MingsonZheng/p/17146237.html

 友情链接:直通硅谷  点职佳  北美留学生论坛

本站QQ群:前端 618073944 | Java 606181507 | Python 626812652 | C/C++ 612253063 | 微信 634508462 | 苹果 692586424 | C#/.net 182808419 | PHP 305140648 | 运维 608723728

W3xue 的所有内容仅供测试,对任何法律问题及风险不承担任何责任。通过使用本站内容随之而来的风险与本站无关。
关于我们  |  意见建议  |  捐助我们  |  报错有奖  |  广告合作、友情链接(目前9元/月)请联系QQ:27243702 沸活量
皖ICP备17017327号-2 皖公网安备34020702000426号