.NET 10 中的新增功能系列文章1——运行时中的新增功能

引言

随着 .NET 10 预览版6的发布，微软在运行时层面带来了一系列重要的性能改进和新功能。这些改进主要集中在JIT编译器优化、硬件指令集支持、内存管理等方面，旨在进一步提升应用程序的执行效率和资源利用率。本文将详细解析这些运行时增强功能，包括JIT编译器改进、AVX10.2支持、堆栈分配优化、NativeAOT类型预初始化器改进以及Arm64写入屏障改进等核心内容。
正文内容

JIT 编译器改进

.NET 10 中的JIT编译器引入了多项重要优化，显著提升了代码生成质量和执行效率。
结构参数代码生成优化

JIT编译器现在能够更好地处理共享寄存器的值存储。当需要将结构成员打包到单个寄存器中时，编译器可以直接将优化成员存储到共享寄存器，而无需先存储到内存再加载。以Point结构为例：

1. struct Point
2. {
3.     public long X;
4.     public long Y;
6.     public Point(long x, long y)
7.     {
8.         X = x;
9.         Y = y;
10.     }
11. }
13. [MethodImpl(MethodImplOptions.NoInlining)]
14. private static void Consume(Point p)
15. {
16.     Console.WriteLine(p.X + p.Y);
17. }
19. private static void Main()
20. {
21.     Point p = new Point(10, 20);
22.     Consume(p);
23. }

复制代码

在x64架构上，生成的汇编代码直接通过寄存器传递Point成员：

1. Program:Main() (FullOpts):
2.        mov      edi, 10
3.        mov      esi, 20
4.        tail.jmp [Program:Consume(Program+Point)]

复制代码

当Point成员改为int类型时，编译器也能直接在共享寄存器中打包参数：

1. Program:Main() (FullOpts):
2.        mov      rdi, 0x140000000A
3.        tail.jmp [Program:Consume(Program+Point)]

复制代码

这种优化消除了不必要的内存操作，显著提升了性能。
循环反转优化

JIT编译器现在采用基于图形的循环识别实现，能够更准确地处理自然循环。它将while循环转换为do-while形式：

1. if (loopCondition)
2. {
3.     do
4.     {
5.         // loop body
6.     } while (loopCondition);
7. }

复制代码

这种转换改善了代码布局，为后续的循环优化（如循环展开和克隆）创造了更好的条件。
数组接口方法反虚拟化

.NET 10扩展了JIT去虚拟化能力，现在可以处理数组接口方法。这使得以下两种代码形式能够获得相似的优化效果：

1. // 直接数组访问
2. static int Sum(int[] array)
3. {
4.     int sum = 0;
5.     for (int i = 0; i < array.Length; i++)
6.     {
7.         sum += array[i];
8.     }
9.     return sum;
10. }
12. // 通过IEnumerable接口访问
13. static int Sum(int[] array)
14. {
15.     int sum = 0;
16.     IEnumerable<int> temp = array;
17.     foreach (var num in temp)
18.     {
19.         sum += num;
20.     }
21.     return sum;
22. }

复制代码

JIT现在能够识别数组接口实现，消除虚拟调用开销，并应用内联和堆栈分配等优化。
AVX10.2 支持

.NET 10为x64处理器引入了AVX10.2指令集支持。新硬件指令可通过System.Runtime.Intrinsics.X86.Avx10v2类访问。不过目前相关硬件尚未普及，因此该功能默认处于禁用状态。AVX10.2扩展了向量处理能力，为数值计算密集型应用提供了更强大的硬件加速支持。
堆栈分配

堆栈分配是减少GC压力的重要优化手段，.NET 10在此方面有多项改进。
值类型数组堆栈分配

对于小型固定大小的值类型数组，如果其生命周期不超过父方法，JIT现在会在堆栈上分配它们：

1. static void Sum()
2. {
3.     int[] numbers = {1, 2, 3};
4.     int sum = 0;
6.     for (int i = 0; i < numbers.Length; i++)
7.     {
8.         sum += numbers[i];
9.     }
10.     Console.WriteLine(sum);
11. }

复制代码

编译器能识别numbers数组的固定大小和有限生命周期，直接在堆栈上分配。
引用类型数组堆栈分配

这一优化现在也扩展到引用类型的小型数组：

1. static void Print()
2. {
3.     string[] words = {"Hello", "World!"};
4.     foreach (var str in words)
5.     {
6.         Console.WriteLine(str);
7.     }
8. }

复制代码

当确定数组不会逃逸方法范围时，JIT会选择堆栈分配而非堆分配。
转义分析增强

.NET 10改进了转义分析，现在能正确处理结构字段引用：

1. public class Program
2. {
3.     struct GCStruct
4.     {
5.         public int[] arr;
6.     }
8.     public static void Main()
9.     {
10.         int[] x = new int[10];
11.         GCStruct y = new GCStruct() { arr = x };
12.         return y.arr[0];
13.     }
14. }

复制代码

只要结构体本身不逃逸，其字段引用的对象也不再被标记为逃逸，这使得更多对象可以堆栈分配。
委托堆栈分配

对于不会逃逸当前范围的委托，JIT现在也能进行堆栈分配：

1. public static int Main()
2. {
3.     int local = 1;
4.     int[] arr = new int[100];
5.     var func = (int x) => x + local;
6.     int sum = 0;
8.     foreach (int num in arr)
9.     {
10.         sum += func(num);
11.     }
12.     return sum;
13. }

复制代码

生成的汇编代码显示Func对象被分配在堆栈上，减少了堆分配开销。
NativeAOT 类型预初始化器改进

NativeAOT的类型预初始化器现在支持所有conv.*和neg操作码变体。这意味着包含类型转换或取反操作的方法也能进行预初始化，进一步优化AOT编译后的启动性能。这项改进使得更多类型的方法可以在编译时完成初始化工作，减少运行时开销。
Arm64 写入屏障改进

.NET 10为Arm64架构带来了写入屏障实现的重大改进。垃圾回收器使用写入屏障来跟踪代际引用，新的实现能更准确地处理GC区域：

• 动态切换：与x64类似，Arm64现在可以在不同写入屏障实现间动态切换，平衡写入速度和收集效率。
  
• 性能提升：基准测试显示，采用新的GC默认设置后，GC暂停时间改善了8%到超过20%。
  
• 区域精确性：新的默认实现更精确地处理GC区域，虽然略微影响写入吞吐量，但显著提高了收集效率。
  

来源：程序园用户自行投稿发布，如果侵权，请联系站长删除
免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！