请选择 进入手机版 | 继续访问电脑版

葡萄城产品技术社区

    注册

QQ登录

SpreadJS

纯前端控件,类似Excel,问题响应通道

ComponentOne WPF

前沿科技,针对WPF桌面,问题响应通道

C1FlexGrid视频教程

WinForm平台,功能强大的表格控件,初学者必看视频

ActiveReport视频教程

轻松搞定报表,从头开始学AR,视频教程

搜索
查看: 589|回复: 0

[原创] 是什么优化让 .NET Core 性能飙升?

[复制链接]

253

主题

254

帖子

2791

积分

超级版主

Rank: 8Rank: 8

积分
2791

微信认证勋章

发表于 2017-7-17 12:18:35 | 显示全部楼层 |阅读模式
本帖最后由 断天涯大虾 于 2017-7-17 13:46 编辑

.NET Core(开放源代码,跨平台,x-copy可部署等)有许多令人兴奋的方面,其中最值得称赞的就是其性能了。
感谢所有社区开发人员对.NET Core做出的贡献,其中的许多改进也将在接下来的几个版本中引入.NET Framework。
本文主要介绍.NET Core中的一些性能改进,特别是.NET Core 2.0中的,重点介绍各个核心库的一些示例。

集合
集合是任何应用程序的基石,同时.NET库中也有大量集合。.NET库中的一些改进是为了消除开销,例如简化操作以便更好的实现内联,减少指令数量等。例如,下面的这个使用Q<T>的例子:
  1. using System;
  2. using System.Diagnostics;
  3. using System.Collections.Generic;
  4. public class Test
  5. {
  6.     public static void Main()
  7.     {
  8.         while (true)
  9.         {
  10.             var q = new Queue<int>();
  11.             var sw = Stopwatch.StartNew();
  12.             for (int i = 0; i < 100_000_000; i++)
  13.             {
  14.                 q.Enqueue(i);
  15.                 q.Dequeue();
  16.             }
  17.             Console.WriteLine(sw.Elapsed);
  18.         }
  19.     }
  20. }
复制代码
PR dotnet/corefx #2515移除了这些操作中相对复杂的模数运算,在个人计算机,以上代码在.NET 4.7上产生如下输出:
  1. 00:00:00.9392595
  2. 00:00:00.9390453
  3. 00:00:00.9455784
  4. 00:00:00.9508294
  5. 00:00:01.0107745
复制代码
而使用.NET Core 2.0则会产生如下输出:
  1. 00:00:00.9392595
  2. 00:00:00.9390453
  3. 00:00:00.9455784
  4. 00:00:00.9508294
  5. 00:00:01.0107745
复制代码
由于这是挂钟时间所节省的,较小的值计算的更快,这也表明吞吐量增加了约2倍!

在其他情况下,通过更改操作算法的复杂性,可以更快地进行操作。编写软件时,最初编写的一个简单实现,虽然是正确的,但是这样实现往往不能表现出最佳的性能,直到特定的场景出现时,才考虑如何提高性能。例如,SortedSet <T>的ctor最初以相对简单的方式编写,由于使用O(N ^ 2)算法来处理重复项,因此不能很好地处理复杂性。该算法在PRnetnet / corefx#1955中的.NET Core中得到修复。以下简短的程序说明了修复的区别:
  1. using System;
  2. using System.Diagnostics;
  3. using System.Collections.Generic;
  4. using System.Linq;

  5. public class Test
  6. {
  7.     public static void Main()
  8.     {
  9.         var sw = Stopwatch.StartNew();
  10.         var ss = new SortedSet<int>(Enumerable.Repeat(42, 400_000));
  11.         Console.WriteLine(sw.Elapsed);
  12.     }
  13. }
复制代码
在个人电脑的.NET Framework上,这段代码需要大约7.7秒执行完成。在.NET Core 2.0上,减少到大约0.013s(改进改变了算法的复杂性,集合越大,节省的时间越多)。
或者在SortedSet <T>上考虑这个例子:
  1. public class Test
  2. {
  3.     static int s_result;

  4.     public static void Main()
  5.     {
  6.         while (true)
  7.         {
  8.             var s = new SortedSet<int>();
  9.             for (int n = 0; n < 100_000; n++)
  10.             {
  11.                 s.Add(n);
  12.             }

  13.             var sw = Stopwatch.StartNew();
  14.             for (int i = 0; i < 10_000_000; i++)
  15.             {
  16.                 s_result = s.Min;
  17.             }
  18.             Console.WriteLine(sw.Elapsed);
  19.         }
  20.     }
  21. }
复制代码
.NET 4.7中MinMax的实现遍布SortedSet <T>的整个树,但是只需要找到最小或最大值即可,因为实现可以只遍历相关的节点。PR dotnet / corefx#11968修复了.NET Core实现。在.NET 4.7中,此示例生成如下结果:
  1. 00:00:01.1427246
  2. 00:00:01.1295220
  3. 00:00:01.1350696
  4. 00:00:01.1502784
  5. 00:00:01.1677880
复制代码
而在.NET Core 2.0中,我们得到如下结果:
  1. 00:00:00.0861391
  2. 00:00:00.0861183
  3. 00:00:00.0866616
  4. 00:00:00.0848434
  5. 00:00:00.0860198
复制代码
显示出相当大的时间下降和吞吐量的增加。
即使像List <T>这样的主工作核心也有改进的空间。考虑下面的例子:
  1. using System;
  2. using System.Diagnostics;
  3. using System.Collections.Generic;
  4. public class Test
  5. {
  6.     public static void Main()
  7.     {
  8.         while (true)
  9.         {
  10.             var l = new List<int>();
  11.             var sw = Stopwatch.StartNew();
  12.             for (int i = 0; i < 100_000_000; i++)
  13.             {
  14.                 l.Add(i);
  15.                 l.RemoveAt(0);
  16.             }
  17.             Console.WriteLine(sw.Elapsed);
  18.         }
  19.     }
  20. }
复制代码
在.NET 4.7中,会得到的结果如下:
  1. 00:00:00.4434135
  2. 00:00:00.4394329
  3. 00:00:00.4496867
  4. 00:00:00.4496383
  5. 00:00:00.4515505
复制代码
和.NET Core 2.0,得到:
  1. 00:00:00.3213094
  2. 00:00:00.3211772
  3. 00:00:00.3179631
  4. 00:00:00.3198449
  5. 00:00:00.3164009
复制代码
可以肯定的是,在0.3秒内可以实现1亿次这样的添加并从列表中删除的操作,这表明操作开始并不慢。但是,通过执行一个应用程序,列表通常会添加到很多,同时也节省了总时间消耗。

这些类型的集合改进扩展不仅仅是System.Collections.Generic命名空间; System.Collections.Concurrent也有很多改进。事实上,.NET Core 2.0上的ConcurrentQueue <T>ConcurrentBag <T>完全重写了。下面看看一个基本的例子,使用ConcurrentQueue <T>但没有任何并发,例子中使用ConcurrentQueue <T>代替了Queue<T>
  1. using System;
  2. using System.Diagnostics;
  3. using System.Collections.Concurrent;

  4. public class Test
  5. {
  6.     public static void Main()
  7.     {
  8.         while (true)
  9.         {
  10.             var q = new ConcurrentQueue<int>();
  11.             var sw = Stopwatch.StartNew();
  12.             for (int i = 0; i < 100_000_000; i++)
  13.             {
  14.                 q.Enqueue(i);
  15.                 q.TryDequeue(out int _);
  16.             }
  17.             Console.WriteLine(sw.Elapsed);
  18.         }
  19.     }
  20. }
复制代码
在个人电脑上,.NET 4.7产生的输出如下:
  1. 00:00:02.6485174
  2. 00:00:02.6144919
  3. 00:00:02.6699958
  4. 00:00:02.6441047
  5. 00:00:02.6255135
复制代码
显然,.NET 4.7上的ConcurrentQueue <T>示例比.NET 4.7中的Queue <T>版本慢,因为ConcurrentQueue <T>需要采用同步来确保是否安全使用。但是,更有趣的比较是当在.NET Core 2.0上运行相同的代码时会发生什么:
  1. 00:00:01.7700190
  2. 00:00:01.8324078
  3. 00:00:01.7552966
  4. 00:00:01.7518632
  5. 00:00:01.7560811
复制代码
这表明当将.NET Core 2.0切换到30%时,ConcurrentQueue <T>的吞吐量没有任何并发​​性提高。但是实施中的变化提高了序列化的吞吐量,甚至更多地减少了使用队列的生产和消耗之间的同步,这可能对吞吐量有更明显的影响。请考虑以下代码:
  1. using System;
  2. using System.Diagnostics;
  3. using System.Collections.Concurrent;
  4. using System.Threading.Tasks;
  5. public class Test
  6. {
  7.     public static void Main()
  8.     {
  9.         while (true)
  10.         {
  11.             const int Items = 100_000_000;
  12.             var q = new ConcurrentQueue<int>();
  13.             var sw = Stopwatch.StartNew();

  14.             Task consumer = Task.Run(() =>
  15.             {
  16.                 int total = 0;
  17.                 while (total < Items) if (q.TryDequeue(out int _)) total++;
  18.             });
  19.             for (int i = 0; i < Items; i++) q.Enqueue(i);
  20.             consumer.Wait();

  21.             Console.WriteLine(sw.Elapsed);
  22.         }
  23.     }
  24. }
复制代码
在.NET 4.7中,个人计算机输出如下结果:
  1. 00:00:06.1366044
  2. 00:00:05.7169339
  3. 00:00:06.3870274
  4. 00:00:05.5487718
  5. 00:00:06.6069291
复制代码
而使用.NET Core 2.0,会得到以下结果:
  1. 00:00:01.2052460
  2. 00:00:01.5269184
  3. 00:00:01.4638793
  4. 00:00:01.4963922
  5. 00:00:01.4927520
复制代码
这是一个3.5倍的吞吐量的增长。不但CPU效率提高了, 而且内存分配也大大减少。下面的例子主要观察GC集合的数量,而不是挂钟时间:
  1. using System;
  2. using System.Diagnostics;
  3. using System.Collections.Concurrent;
  4. public class Test
  5. {
  6.     public static void Main()
  7.     {
  8.         while (true)
  9.         {
  10.             var q = new ConcurrentQueue<int>();
  11.             int gen0 = GC.CollectionCount(0), gen1 = GC.CollectionCount(1), gen2 = GC.CollectionCount(2);
  12.             for (int i = 0; i < 100_000_000; i++)
  13.             {
  14.                 q.Enqueue(i);
  15.                 q.TryDequeue(out int _);
  16.             }
  17.             Console.WriteLine([        DISCUZ_CODE_16        ]quot;Gen0={GC.CollectionCount(0) - gen0} Gen1={GC.CollectionCount(1) - gen1} Gen2={GC.CollectionCount(2) - gen2}");
  18.         }
  19.     }
  20. }
复制代码
在.NET 4.7中,得到以下输出:
  1. Gen0 = 162 Gen1 = 80 Gen2 = 0
  2. Gen0 = 162 Gen1 = 81 Gen2 = 0
  3. Gen0 = 162 Gen1 = 81 Gen2 = 0
  4. Gen0 = 162 Gen1 = 81 Gen2 = 0
  5. Gen0 = 162 Gen1 = 81 Gen2 = 0
复制代码
而使用.NET Core 2.0,会得到如下输出:
  1. Gen0 = 0 Gen1 = 0 Gen2 = 0
  2. Gen0 = 0 Gen1 = 0 Gen2 = 0
  3. Gen0 = 0 Gen1 = 0 Gen2 = 0
  4. Gen0 = 0 Gen1 = 0 Gen2 = 0
  5. Gen0 = 0 Gen1 = 0 Gen2 = 0
复制代码
.NET 4.7中的实现使用了固定大小的数组链表,一旦固定数量的元素被添加到每个数组中,就会被丢弃, 这有助于简化实现,但也会导致生成大量垃圾。在.NET Core 2.0中,新的实现仍然使用链接在一起的链接列表,但是随着新的片段的添加,这些片段的大小会增加,更重要的是使用循环缓冲区,只有在前一个片段完全结束时,新片段才会增加。这种分配的减少可能对应用程序的整体性能产生相当大的影响。

ConcurrentBag <T>也有类似改进。ConcurrentBag <T>维护thread-local work-stealing队列,使得添加到的每个线程都有自己的队列。在.NET 4.7中,这些队列被实现为每个元素占据一个节点的链接列表,这意味着对该包的任何添加都会导致分配。在.NET Core 2.0中,这些队列是数组,这意味着除了增加阵列所涉及的均摊成本之外,增加的还是无需配置的。以下可以看出:
  1. using System;
  2. using System.Diagnostics;
  3. using System.Collections.Concurrent;
  4. public class Test
  5. {
  6.     public static void Main()
  7.     {
  8.         while (true)
  9.         {
  10.             var q = new ConcurrentBag<int>() { 1, 2 };
  11.             var sw = new Stopwatch();

  12.             int gen0 = GC.CollectionCount(0), gen1 = GC.CollectionCount(1), gen2 = GC.CollectionCount(2);
  13.             sw.Start();

  14.             for (int i = 0; i < 100_000_000; i++)
  15.             {
  16.                 q.Add(i);
  17.                 q.TryTake(out int _);
  18.             }

  19.             sw.Stop();
  20.             Console.WriteLine([        DISCUZ_CODE_19        ]quot;Elapsed={sw.Elapsed} Gen0={GC.CollectionCount(0) - gen0} Gen1={GC.CollectionCount(1) - gen1} Gen2={GC.CollectionCount(2) - gen2}");
  21.         }
  22.     }
  23. }
复制代码
在.NET 4.7中,个人计算机上产生以下输出:
  1. Elapsed=00:00:06.5672723 Gen0=953 Gen1=0 Gen2=0
  2. Elapsed=00:00:06.4829793 Gen0=954 Gen1=1 Gen2=0
  3. Elapsed=00:00:06.9008532 Gen0=954 Gen1=0 Gen2=0
  4. Elapsed=00:00:06.6485667 Gen0=953 Gen1=1 Gen2=0
  5. Elapsed=00:00:06.4671746 Gen0=954 Gen1=1 Gen2=0
复制代码
而使用.NET Core 2.0,会得到:
  1. Elapsed=00:00:04.3377355 Gen0=0 Gen1=0 Gen2=0
  2. Elapsed=00:00:04.2892791 Gen0=0 Gen1=0 Gen2=0
  3. Elapsed=00:00:04.3101593 Gen0=0 Gen1=0 Gen2=0
  4. Elapsed=00:00:04.2652497 Gen0=0 Gen1=0 Gen2=0
  5. Elapsed=00:00:04.2808077 Gen0=0 Gen1=0 Gen2=0
复制代码
吞吐量提高了约30%,并且分配和完成的垃圾收集量减少了。

LINQ
在应用程序代码中,集合通常与语言集成查询(LINQ)紧密相连,该查询已经有了更多的改进。LINQ中的许多运算符已经完全重写为.NET Core,以便减少分配的数量和大小,降低算法复杂度,并且消除不必要的工作。

例如,Enumerable.Concat方法用于创建一个单一的IEnumerable <T>,它首先产生first域可枚举的所有元素,然后再生成second域所有的元素。它在.NET 4.7中的实现是简单易懂的,下面的代码正好反映了这种行为表述:
  1. static IEnumerable<TSource> ConcatIterator<TSource>(IEnumerable<TSource> first, IEnumerable<TSource> second) {
  2.     foreach (TSource element in first) yield return element;
  3.     foreach (TSource element in second) yield return element;
  4. }
复制代码
当两个序列是简单的枚举,如C#中的迭代器生成的,这种过程会执行的很好。但是如果应用程序代码具有如下代码呢?
  1. first.Concat(second.Concat(third.Concat(fourth)));
复制代码
每次我们从迭代器中退出时,则会返回到枚举器的MoveNext方法。这意味着如果你从另一个迭代器中枚举产生一个元素,则会返回两个MoveNext方法,并移动到下一个需要调用这两个MoveNext方法的元素。你调用的枚举器越多,操作所需的时间越长,特别是这些操作中的每一个都涉及多个接口调用(MoveNextCurrent)。这意味着连接多个枚举会以指数方式增长,而不是呈线性增长。PR dotnet / corefx#6131修正了这个问题,在下面的例子中,区别是显而易见的:
  1. using System;
  2. using System.Collections.Generic;
  3. using System.Diagnostics;
  4. using System.Linq;
  5. public class Test
  6. {
  7.     public static void Main()
  8.     {
  9.         IEnumerable<int> zeroToTen = Enumerable.Range(0, 10);
  10.         IEnumerable<int> result = zeroToTen;
  11.         for (int i = 0; i < 10_000; i++)
  12.         {
  13.             result = result.Concat(zeroToTen);
  14.         }

  15.         var sw = Stopwatch.StartNew();
  16.         foreach (int i in result) { }
  17.         Console.WriteLine(sw.Elapsed);
  18.     }
  19. }
复制代码
在个人计算机上,.NET 4.7需要大约4.12秒。但在.NET Core 2.0中,这只需要约0.14秒,提高了30倍。
通过消除多个运算器同时使用时的消耗,运算器也得到了大大的提升。例如下面的例子:
  1. using System;
  2. using System.Collections.Generic;
  3. using System.Diagnostics;
  4. using System.Linq;
  5. public class Test
  6. {
  7.     public static void Main()
  8.     {
  9.         IEnumerable<int> tenMillionToZero = Enumerable.Range(0, 10_000_000).Reverse();
  10.         while (true)
  11.         {
  12.             var sw = Stopwatch.StartNew();
  13.             int fifth = tenMillionToZero.OrderBy(i => i).Skip(4).First();
  14.             Console.WriteLine(sw.Elapsed);
  15.         }
  16.     }
  17. }
复制代码
在这里,我们创建一个可以从10,000,000下降到0的数字,然后再等待一会来排序它们上升,跳过排序结果中的前4个元素,并抓住第五个。在个人计算机上的NET 4.7中得到如下输出:
  1. 00:00:01.3879042
  2. 00:00:01.3438509
  3. 00:00:01.4141820
  4. 00:00:01.4248908
  5. 00:00:01.3548279
复制代码
而使用.NET Core 2.0,会得到如下输出:
  1. 00:00:00.1776617
  2. 00:00:00.1787467
  3. 00:00:00.1754809
  4. 00:00:00.1765863
  5. 00:00:00.1735489
复制代码
这是一个巨大的改进(〜8x),避免了大部分的开销。

类似地,来自justinvp的 PR dotnet / corefx#3429对常用的ToList方法添加了优化,为已知长度的源,提供了优化的路径,并且通过像Select这样的操作器来管理。在以下简单测试中,这种影响是显而易见的:
  1. using System;
  2. using System.Collections.Generic;
  3. using System.Diagnostics;
  4. using System.Linq;
  5. public class Test
  6. {
  7.     public static void Main()
  8.     {
  9.         IEnumerable<int> tenMillionToZero = Enumerable.Range(0, 10_000_000).Reverse();
  10.         while (true)
  11.         {
  12.             var sw = Stopwatch.StartNew();
  13.             int fifth = tenMillionToZero.OrderBy(i => i).Skip(4).First();
  14.             Console.WriteLine(sw.Elapsed);
  15.         }
  16.     }
  17. }
复制代码
在.NET 4.7中,会得到如下结果:
  1. 00:00:00.1308687
  2. 00:00:00.1228546
  3. 00:00:00.1268445
  4. 00:00:00.1247647
  5. 00:00:00.1503511
复制代码
而在.NET Core 2.0中,得到如下结果:
  1. 00:00:00.0386857
  2. 00:00:00.0337234
  3. 00:00:00.0346344
  4. 00:00:00.0345419
  5. 00:00:00.0355355
复制代码
显示吞吐量增加约4倍。
在其他情况下,性能优势来自于简化实施,以避免开销,例如减少分配,避免委托分配,避免接口调用,最小化字段读取和写入,避免拷贝等。例如,jamesqo为PR dotnet / corefx#11208做出的贡献,大大地减少了Enumerable.ToArray涉及的开销。请看下面的例子:
  1. using System;
  2. using System.Collections.Generic;
  3. using System.Diagnostics;
  4. using System.Linq;
  5. public class Test
  6. {
  7.     public static void Main()
  8.     {
  9.         IEnumerable<int> zeroToTenMillion = Enumerable.Range(0, 10_000_000).ToArray();
  10.         while (true)
  11.         {
  12.             var sw = Stopwatch.StartNew();
  13.             zeroToTenMillion.Select(i => i).ToList();
  14.             Console.WriteLine(sw.Elapsed);
  15.         }
  16.     }
  17. }
复制代码
在.NET 4.7中,会得到如下的结果:
  1. Elapsed=00:00:01.0548794 Gen0=2 Gen1=2 Gen2=2
  2. Elapsed=00:00:01.1147146 Gen0=2 Gen1=2 Gen2=2
  3. Elapsed=00:00:01.0709146 Gen0=2 Gen1=2 Gen2=2
  4. Elapsed=00:00:01.0706030 Gen0=2 Gen1=2 Gen2=2
  5. Elapsed=00:00:01.0620943 Gen0=2 Gen1=2 Gen2=2
复制代码

而.NET Core 2.0的结果如下:
  1. Elapsed=00:00:00.1716550 Gen0=1 Gen1=1 Gen2=1
  2. Elapsed=00:00:00.1720829 Gen0=1 Gen1=1 Gen2=1
  3. Elapsed=00:00:00.1717145 Gen0=1 Gen1=1 Gen2=1
  4. Elapsed=00:00:00.1713335 Gen0=1 Gen1=1 Gen2=1
  5. Elapsed=00:00:00.1705285 Gen0=1 Gen1=1 Gen2=1
复制代码
这个例子中提高了6倍,但是垃圾收集却只有一半。
LINQ有一百多个运算器,本文只提到了几个,其它的很多也都有所改进。

压缩
前面所展示的集合和LINQ的例子都是处理内存中的数据,当然还有许多其他形式的数据处理,包括大量CPU计算和逻辑判断,这些运算也在得到提升。

一个关键的例子是压缩,例如使用DeflateStream,性能方面也有一些重大的性能改进。例如,在.NET 4.7中,zlib(本地压缩库)用于压缩数据,但是相对未优化的托管实现了用于解压缩的数据; PR dotnet / corefx#2906添加了.NET Core支持,以便使用zlib进行解压缩。来自bjjones的 PR dotnet / corefx#5674使用英特尔生产的zlib这个更优化的版本。这些结合产生了非常棒的效果。下面的例子,创建一个大量的数据:
  1. using System;
  2. using System.IO;
  3. using System.IO.Compression;
  4. using System.Diagnostics;
  5. public class Test
  6. {
  7.     public static void Main()
  8.     {
  9.         // Create some fairly compressible data
  10.         byte[] raw = new byte[100 * 1024 * 1024];
  11.         for (int i = 0; i < raw.Length; i++) raw[i] = (byte)i;
  12.         var sw = Stopwatch.StartNew();

  13.         // Compress it
  14.         var compressed = new MemoryStream();
  15.         using (DeflateStream ds = new DeflateStream(compressed, CompressionMode.Compress, true))
  16.         {
  17.             ds.Write(raw, 0, raw.Length);
  18.         }
  19.         compressed.Position = 0;

  20.         // Decompress it
  21.         var decompressed = new MemoryStream();
  22.         using (DeflateStream ds = new DeflateStream(compressed, CompressionMode.Decompress))
  23.         {
  24.             ds.CopyTo(decompressed);
  25.         }
  26.         decompressed.Position = 0;

  27.         Console.WriteLine(sw.Elapsed);
  28.     }
  29. }
复制代码
在.NET 4.7中,这一个压缩/解压缩操作,会得到如下结果:
00:00:00.7977190
而使用.NET Core 2.0,会得到如下结果:
00:00:00.1926701

加密
.NET应用程序中另一个常见的计算源是使用加密操作,在这方面.NET Core也有改进。例如,在.NET 4.7中,SHA256.Create返回在管理代码中实现的SHA256类型,而管理代码可以运行得非常快,但是对于运算量非常大的计算,这仍然难以与原始吞吐量和编译器优化竞争。相反,对于.NET Core 2.0,SHA256.Create返回基于底层操作系统的实现,例如在Windows上使用CNG或在Unix上使用OpenSSL。从下面这个简单的例子可以看出,它散列着一个100MB的字节数组:
  1. using System;
  2. using System.Diagnostics;
  3. using System.Security.Cryptography;

  4. public class Test
  5. {
  6.     public static void Main()
  7.     {
  8.         byte[] raw = new byte[100 * 1024 * 1024];
  9.         for (int i = 0; i < raw.Length; i++) raw[i] = (byte)i;

  10.         using (var sha = SHA256.Create())
  11.         {
  12.             var sw = Stopwatch.StartNew();
  13.             sha.ComputeHash(raw);
  14.             Console.WriteLine(sw.Elapsed);
  15.         }
  16.     }
  17. }
复制代码
在.NET 4.7中,会得到:
00:00:00.7576808
而使用.NET Core 2.0,会得到:
00:00:00.4032290
零代码更改的一个很好提升。

数学运算
数学运算也是一个很大的计算量,特别是处理大量数据时。通过像dotnet / corefx#2182这样的PR ,axelheerBigInteger的各种操作做了一些实质的改进。请考虑以下示例:
  1. using System;
  2. using System.Diagnostics;
  3. using System.Numerics;

  4. public class Test
  5. {
  6.     public static void Main()
  7.     {
  8.         var rand = new Random(42);
  9.         BigInteger a = Create(rand, 8192);
  10.         BigInteger b = Create(rand, 8192);
  11.         BigInteger c = Create(rand, 8192);

  12.         var sw = Stopwatch.StartNew();
  13.         BigInteger.ModPow(a, b, c);
  14.         Console.WriteLine(sw.Elapsed);
  15.     }

  16.     private static BigInteger Create(Random rand, int bits)
  17.     {
  18.         var value = new byte[(bits + 7) / 8 + 1];
  19.         rand.NextBytes(value);
  20.         value[value.Length - 1] = 0;
  21.         return new BigInteger(value);
  22.     }
  23. }
复制代码
在.NET 4.7中,会得到以下输出结果:
00:00:05.6024158
.NET Core 2.0上的相同代码会得到输出结果如下:
00:00:01.2707089
这是开发人员只关注.NET的某个特定领域的一个很好的例子,开发人员使得这种改进更好的满足了自己的需求,同时也满足了可能会用到这方面功能的其他开发人员的需求。
一些核心的整型类型的数学运算也得到了改进。例如:
  1. using System;
  2. using System.Diagnostics;
  3. public class Test
  4. {
  5.     private static long a = 99, b = 10, div, rem;

  6.     public static void Main()
  7.     {
  8.         var sw = Stopwatch.StartNew();
  9.         for (int i = 0; i < 100_000_000; i++)
  10.         {
  11.             div = Math.DivRem(a, b, out rem);
  12.         }
  13.         Console.WriteLine(sw.Elapsed);
  14.     }
  15. }
复制代码
PR dotnet / coreclr#8125用更快的实现取代了DivRem,在.NET 4.7中会得到的如下结果:
00:00:01.4143100
并在.NET Core 2.0上得到如下结果:
00:00:00.7469733
吞吐量提高约2倍。

序列化
二进制序列化是.NET的另一个领域。BinaryFormatter最初并不是.NET Core中的一个组件,但是它包含在.NET Core 2.0中。该组件在性能方面有比较巧妙的修复。例如,PR dotnet / corefx#17949是一种单行修复,可以增加允许增长的最大大小的特定数组,但是这一变化可能对吞吐量产生重大影响,通过O(N)算法比以前的O(N ^ 2)算法要话费更长的操作时间。以下代码示例,明显的展示了这一点:
  1. using System;
  2. using System.Collections.Generic;
  3. using System.Diagnostics;
  4. using System.IO;
  5. using System.Runtime.Serialization.Formatters.Binary;
  6. class Test
  7. {
  8.     static void Main()
  9.     {
  10.         var books = new List<Book>();
  11.         for (int i = 0; i < 1_000_000; i++)
  12.         {
  13.             string id = i.ToString();
  14.             books.Add(new Book { Name = id, Id = id });
  15.         }

  16.         var formatter = new BinaryFormatter();
  17.         var mem = new MemoryStream();
  18.         formatter.Serialize(mem, books);
  19.         mem.Position = 0;

  20.         var sw = Stopwatch.StartNew();
  21.         formatter.Deserialize(mem);
  22.         sw.Stop();

  23.         Console.WriteLine(sw.Elapsed.TotalSeconds);
  24.     }

  25.     [Serializable]
  26.     private class Book
  27.     {
  28.         public string Name;
  29.         public string Id;
  30.     }
  31. }
复制代码
在.NET 4.7中,代码输出如下结果:
76.677144
而在.NET Core 2.0中,会输出如下结果:
6.4044694
在这种情况下显示出了12倍的吞吐量提高。换句话说,它能够更有效地处理巨大的序列化输入。

文字处理
.NET应用程序中另一种很常见的计算形式就是处理文本,文字处理在堆栈的各个层次上都有大量的改进。
对于正则表达式,通常用于验证和解析输入文本中的数据。以下是使用Regex.IsMatch重复匹配电话号码的示例:
  1. using System;
  2. using System.Diagnostics;
  3. using System.Text.RegularExpressions;
  4. public class Test
  5. {
  6.     public static void Main()
  7.     {
  8.         var sw = new Stopwatch();
  9.         int gen0 = GC.CollectionCount(0);
  10.         sw.Start();

  11.         for (int i = 0; i < 10_000_000; i++)
  12.         {
  13.             Regex.IsMatch("555-867-5309", @"^\d{3}-\d{3}-\d{4}[        DISCUZ_CODE_39        ]quot;);
  14.         }

  15.         Console.WriteLine([        DISCUZ_CODE_39        ]quot;Elapsed={sw.Elapsed} Gen0={GC.CollectionCount(0) - gen0}");
  16.     }
  17. }
复制代码
在个人计算机上,.NET 4.7会得到的如下结果:
  1. Elapsed=00:00:05.4367262 Gen0=820 Gen1=0 Gen2=0
复制代码
而使用.NET Core 2.0会得到如下结果:
  1. Elapsed=00:00:04.0231373 Gen0=248
复制代码
由于PR dotnet / corefx#231的变化很小,这些修改有助于缓存一部分数据,因此吞吐量提高了25%,分配/垃圾收集减少了70%。

文本处理的另一个例子是各种形式的编码和解码,例如通过WebUtility.UrlDecode进行URL解码。在这种解码方法中,通常情况下输入不需要任何解码,但是如果输入经过了解码器,则输入仍然可以通过。感谢来自hughbe的 PR dotnet / corefx#7671,这种情况已经被优化了。例如下面这段程序:
  1. using System;
  2. using System.Diagnostics;
  3. using System.Net;
  4. public class Test
  5. {
  6.     public static void Main()
  7.     {
  8.         var sw = new Stopwatch();
  9.         int gen0 = GC.CollectionCount(0);
  10.         sw.Start();

  11.         for (int i = 0; i < 10_000_000; i++)
  12.         {
  13.             WebUtility.UrlDecode("abcdefghijklmnopqrstuvwxyz");
  14.         }

  15.         Console.WriteLine([        DISCUZ_CODE_42        ]quot;Elapsed={sw.Elapsed} Gen0={GC.CollectionCount(0) - gen0}");
  16.     }
  17. }
复制代码
在.NET 4.7中,会得到以下输出:
  1. Elapsed=00:00:01.6742583 Gen0=648
复制代码
而在.NET Core 2.0中,输出如下:
  1. Elapsed=00:00:01.2255288 Gen0=133
复制代码
其他形式的编码和解码也得到了改进。例如,dotnet / coreclr#10124优化了使用一些内置Encoding -derived类型的循环。例如下面的示例:
  1. using System;
  2. using System.Diagnostics;
  3. using System.Linq;
  4. using System.Text;
  5. public class Test
  6. {
  7.     public static void Main()
  8.     {
  9.         string s = new string(Enumerable.Range(0, 1024).Select(i => (char)('a' + i)).ToArray());
  10.         while (true)
  11.         {
  12.             var sw = Stopwatch.StartNew();
  13.             for (int i = 0; i < 1_000_000; i++)
  14.             {
  15.                 byte[] data = Encoding.UTF8.GetBytes(s);
  16.             }
  17.             Console.WriteLine(sw.Elapsed);
  18.         }
  19.     }
  20. }
复制代码
在.NET 4.7中得到以下输出,如:
  1. 00:00:02.4028829
  2. 00:00:02.3743152
  3. 00:00:02.3401392
  4. 00:00:02.4024785
  5. 00:00:02.3550876
复制代码
而.NET Core 2.0等到如下输出:
  1. 00:00:01.6133550
  2. 00:00:01.5915718
  3. 00:00:01.5759625
  4. 00:00:01.6070851
  5. 00:00:01.6070767
复制代码
这些改进也适用于字符串和其它类型之间转换,例如.NET中生成Parse和ToString方法。使用枚举来表示各种状态是相当普遍的,例如使用Enum.Parse将字符串解析为相应的枚举。PR dotnet / coreclr#2933改善了这一点。请查看以下的代码:
  1. using System;
  2. using System.Diagnostics;
  3. public class Test
  4. {
  5.     public static void Main()
  6.     {
  7.         while (true)
  8.         {
  9.             var sw = new Stopwatch();
  10.             int gen0 = GC.CollectionCount(0);
  11.             sw.Start();

  12.             for (int i = 0; i < 2_000_000; i++)
  13.             {
  14.                 Enum.Parse(typeof(Colors), "Red, Orange, Yellow, Green, Blue");
  15.             }

  16.             Console.WriteLine([        DISCUZ_CODE_48        ]quot;Elapsed={sw.Elapsed} Gen0={GC.CollectionCount(0) - gen0}");
  17.         }
  18.     }

  19.     [Flags]
  20.     private enum Colors
  21.     {
  22.         Red = 0x1,
  23.         Orange = 0x2,
  24.         Yellow = 0x4,
  25.         Green = 0x8,
  26.         Blue = 0x10
  27.     }
  28. }
复制代码
在.NET 4.7中,会得到的以下结果:
  1. Elapsed=00:00:00.9529354 Gen0=293
  2. Elapsed=00:00:00.9422960 Gen0=294
  3. Elapsed=00:00:00.9419024 Gen0=294
  4. Elapsed=00:00:00.9417014 Gen0=294
  5. Elapsed=00:00:00.9514724 Gen0=293
复制代码
在.NET Core 2.0上,会得到以下结果:
  1. Elapsed=00:00:00.6448327 Gen0=11
  2. Elapsed=00:00:00.6438907 Gen0=11
  3. Elapsed=00:00:00.6285656 Gen0=12
  4. Elapsed=00:00:00.6286561 Gen0=11
  5. Elapsed=00:00:00.6294286 Gen0=12
复制代码
不但吞吐量提高了约33%,而且分配和相关垃圾收集也减少了约25倍。

当然,在.NET应用程序中需要进行大量的自定义文本处理,除了使用像Regex / Encoding这样的内置类型和Parse和ToString这样的内置操作之外,文本操作通常都是直接构建在字符串之上,并且大量的改进已经引入到了操作on String之上。

例如,String.IndexOf很擅长于查找字符串中的字符。IndexOfbnetyersmyth的dotnet / coreclr#5327中得到改进,他们为String实现了一系列的性能改进。正如下面的例子:
  1. using System;
  2. using System.Diagnostics;
  3. public class Test
  4. {
  5.     public static void Main()
  6.     {
  7.         var dt = DateTime.Now;
  8.         while (true)
  9.         {
  10.             var sw = new Stopwatch();
  11.             int gen0 = GC.CollectionCount(0);
  12.             sw.Start();

  13.             for (int i = 0; i < 2_000_000; i++)
  14.             {
  15.                 dt.ToString("o");
  16.                 dt.ToString("r");
  17.             }

  18.             Console.WriteLine([        DISCUZ_CODE_51        ]quot;Elapsed={sw.Elapsed} Gen0={GC.CollectionCount(0) - gen0}");
  19.         }
  20.     }
  21. }
复制代码
在.NET 4.7上,会得到如下结果:
  1. 00:00:05.9718129
  2. 00:00:05.9199793
  3. 00:00:06.0203108
  4. 00:00:05.9458049
  5. 00:00:05.9622262
复制代码
而在.NET Core 2.0中,会得到如下结果:
  1. 00:00:03.1283763
  2. 00:00:03.0925150
  3. 00:00:02.9778923
  4. 00:00:03.0782851
复制代码
吞吐量提高约2倍。
下面是比较字符串部分。这是一个使用String.StartsWith和序数比较的例子:
  1. using System;
  2. using System.Diagnostics;
  3. using System.Linq;
  4. public class Test
  5. {
  6.     public static void Main()
  7.     {
  8.         string s = string.Concat(Enumerable.Repeat("a", 100)) + "b";
  9.         while (true)
  10.         {
  11.             var sw = Stopwatch.StartNew();
  12.             for (int i = 0; i < 100_000_000; i++)
  13.             {
  14.                 s.IndexOf('b');
  15.             }
  16.             Console.WriteLine(sw.Elapsed);
  17.         }
  18.     }
  19. }
复制代码
在.NET 4.7上会得到如下结果:
  1. 00:00:01.3097317
  2. 00:00:01.3072381
  3. 00:00:01.3045015
  4. 00:00:01.3068244
  5. 00:00:01.3210207
复制代码
.NET Core 2.0会得到如下结果:
  1. 00:00:00.6239002
  2. 00:00:00.6150021
  3. 00:00:00.6147173
  4. 00:00:00.6129136
  5. 00:00:00.6099822
复制代码
String的改进,也让我们看到对于其它方面进行更多改进的可能性,这是非常有趣的。

文件系统
到目前为止,本文一直专注于内存中操纵数据的各种改进。但是.NET Core的许多更改都是​​关于I / O的。
下面从文件开始介绍。这是一个从文件中异步读取所有数据并将其写入另一个文件的示例:
  1. using System;
  2. using System.Diagnostics;
  3. using System.IO;
  4. using System.Threading.Tasks;
  5. class Test
  6. {
  7.     static void Main() => MainAsync().GetAwaiter().GetResult();
  8.     static async Task MainAsync()
  9.     {
  10.         string inputPath = Path.GetTempFileName(), outputPath = Path.GetTempFileName();
  11.         byte[] data = new byte[50_000_000];
  12.         new Random().NextBytes(data);
  13.         File.WriteAllBytes(inputPath, data);

  14.         var sw = new Stopwatch();
  15.         int gen0 = GC.CollectionCount(0), gen1 = GC.CollectionCount(1), gen2 = GC.CollectionCount(2);
  16.         sw.Start();

  17.         for (int i = 0; i < 100; i++)
  18.         {
  19.             using (var input = new FileStream(inputPath, FileMode.Open, FileAccess.Read, FileShare.Read, 0x1000, useAsync: true))
  20.             using (var output = new FileStream(outputPath, FileMode.Create, FileAccess.ReadWrite, FileShare.None, 0x1000, useAsync: true))
  21.             {
  22.                 await input.CopyToAsync(output);
  23.             }
  24.         }

  25.         Console.WriteLine([        DISCUZ_CODE_57        ]quot;Elapsed={sw.Elapsed} Gen0={GC.CollectionCount(0) - gen0} Gen1={GC.CollectionCount(1) - gen1} Gen2={GC.CollectionCount(2) - gen2}");
  26.     }
  27. }
复制代码
FileStream中的开销也在进一步减少,例如DOTNET / corefx#11569增加了一个专门的CopyToAsync实现,dotnet/ corefx#2929也改进了异步写入的处理,.NET 4.7会得到如下结果:
  1. Elapsed=00:00:09.4070345 Gen0=14 Gen1=7 Gen2=1
复制代码
.NET Core 2.0会得到如下结果:
  1. Elapsed=00:00:06.4286604 Gen0=4 Gen1=1 Gen2=1
复制代码


网络
网络是值得关注的部分,这部分也将取得很大的改进。目前正在付出很大的努力来优化和调整低等级的网络堆栈,以便高效地构建更高级别的组件。
这种改变带来的一个很大的影响是PR dotnet / corefx#15141SocketAsyncEventArgsSocket上大量异步操作的核心,它支持同步完成模型,因此异步操作实际完成了同步操作,这样避免了异步操作的分配消耗。但是,.NET 4.7中的同步操作运算是失败的, PR修复了上述的实现问题,允许在socket上进行所有异步操作的同步完成。这样的提升在以下代码中变现的非常明显:
  1. using System;
  2. using System.Diagnostics;
  3. using System.Net;
  4. using System.Net.Sockets;
  5. using System.Threading;
  6. using System.Threading.Tasks;
  7. class Test
  8. {
  9.     static void Main()
  10.     {
  11.         using (Socket listener = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp))
  12.         using (Socket client = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp))
  13.         {
  14.             listener.Bind(new IPEndPoint(IPAddress.Loopback, 0));
  15.             listener.Listen(1);

  16.             Task connectTask = Task.Run(() => client.Connect(listener.LocalEndPoint));
  17.             using (Socket server = listener.Accept())
  18.             {
  19.                 connectTask.Wait();

  20.                 using (var clientAre = new AutoResetEvent(false))
  21.                 using (var clientSaea = new SocketAsyncEventArgs())
  22.                 using (var serverAre = new AutoResetEvent(false))
  23.                 using (var serverSaea = new SocketAsyncEventArgs())
  24.                 {
  25.                     byte[] sendBuffer = new byte[1000];
  26.                     clientSaea.SetBuffer(sendBuffer, 0, sendBuffer.Length);
  27.                     clientSaea.Completed += delegate { clientAre.Set(); };

  28.                     byte[] receiveBuffer = new byte[1000];
  29.                     serverSaea.SetBuffer(receiveBuffer, 0, receiveBuffer.Length);
  30.                     serverSaea.Completed += delegate { serverAre.Set(); };

  31.                     var sw = new Stopwatch();
  32.                     int gen0 = GC.CollectionCount(0), gen1 = GC.CollectionCount(1), gen2 = GC.CollectionCount(2);
  33.                     sw.Start();

  34.                     for (int i = 0; i < 1_000_000; i++)
  35.                     {
  36.                         if (client.SendAsync(clientSaea)) clientAre.WaitOne();
  37.                         if (clientSaea.SocketError != SocketError.Success) throw new SocketException((int)clientSaea.SocketError);

  38.                         if (server.ReceiveAsync(serverSaea)) serverAre.WaitOne();
  39.                         if (serverSaea.SocketError != SocketError.Success) throw new SocketException((int)clientSaea.SocketError);
  40.                     }

  41.                     Console.WriteLine([        DISCUZ_CODE_60        ]quot;Elapsed={sw.Elapsed} Gen0={GC.CollectionCount(0) - gen0} Gen1={GC.CollectionCount(1) - gen1} Gen2={GC.CollectionCount(2) - gen2}");
  42.                 }
  43.             }
  44.         }
  45.     }
  46. }
复制代码
该程序创建两个连接的socket,然后向socket写入1000次,并且在案例中使用异步方法接收,但绝大多数操作将同步完成。在.NET 4.7中会得到如下结果:

在.NET Core 2.0中,大多数操作能够同步完成,得到如下结果:
Elapsed=00:00:05.6197060 Gen0=0 Gen1=0 Gen2=0
不仅仅是直接使用socket来实现组件的这种改进,而且还通过更高级别的组件来间接使用socket,其他PR的结果是更高级别组件(如NetworkStream)的额外性能提升。例如,PR dotnet / corefx#16502在SocketAsyncEventArgs上重新实现了基于Socket的SendAsync和ReceiveAsync操作,并且允许它们在NetworkStream中使用Read / WriteAsync和PR dotnet / corefx#12664添加了一个专门的CopyToAsync重写,以便更有效地从NetworkStream读取数据并将其复制到其他流中。这些变化对NetworkStream吞吐量和分配有非常大的影响。看看下面这个例子:
  1. using System;
  2. using System.Diagnostics;
  3. using System.Net;
  4. using System.Net.Sockets;
  5. using System.Threading;
  6. using System.Threading.Tasks;
  7. class Test
  8. {
  9.     static void Main()
  10.     {
  11.         using (Socket listener = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp))
  12.         using (Socket client = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp))
  13.         {
  14.             listener.Bind(new IPEndPoint(IPAddress.Loopback, 0));
  15.             listener.Listen(1);

  16.             Task connectTask = Task.Run(() => client.Connect(listener.LocalEndPoint));
  17.             using (Socket server = listener.Accept())
  18.             {
  19.                 connectTask.Wait();

  20.                 using (var clientAre = new AutoResetEvent(false))
  21.                 using (var clientSaea = new SocketAsyncEventArgs())
  22.                 using (var serverAre = new AutoResetEvent(false))
  23.                 using (var serverSaea = new SocketAsyncEventArgs())
  24.                 {
  25.                     byte[] sendBuffer = new byte[1000];
  26.                     clientSaea.SetBuffer(sendBuffer, 0, sendBuffer.Length);
  27.                     clientSaea.Completed += delegate { clientAre.Set(); };

  28.                     byte[] receiveBuffer = new byte[1000];
  29.                     serverSaea.SetBuffer(receiveBuffer, 0, receiveBuffer.Length);
  30.                     serverSaea.Completed += delegate { serverAre.Set(); };

  31.                     var sw = new Stopwatch();
  32.                     int gen0 = GC.CollectionCount(0), gen1 = GC.CollectionCount(1), gen2 = GC.CollectionCount(2);
  33.                     sw.Start();

  34.                     for (int i = 0; i < 1_000_000; i++)
  35.                     {
  36.                         if (client.SendAsync(clientSaea)) clientAre.WaitOne();
  37.                         if (clientSaea.SocketError != SocketError.Success) throw new SocketException((int)clientSaea.SocketError);

  38.                         if (server.ReceiveAsync(serverSaea)) serverAre.WaitOne();
  39.                         if (serverSaea.SocketError != SocketError.Success) throw new SocketException((int)clientSaea.SocketError);
  40.                     }

  41.                     Console.WriteLine([        DISCUZ_CODE_61        ]quot;Elapsed={sw.Elapsed} Gen0={GC.CollectionCount(0) - gen0} Gen1={GC.CollectionCount(1) - gen1} Gen2={GC.CollectionCount(2) - gen2}");
  42.                 }
  43.             }
  44.         }
  45.     }
  46. }
复制代码
与之前的Socket一样,下面我们创建两个连接的socket,然后把它们包含在NetworkStream中。在其中一个流中,我们将1K数据写入一百万次,而另一个流则通过CopyToAsync操作读出所有数据。在.NET 4.7中,会得到如下输出:
  1. Elapsed = 00:00:24.7827947 Gen0 = 220 Gen1 = 3 Gen2 = 0
复制代码
而在.NET Core 2.0中,时间减少了5倍,垃圾回收有效地减少到零:
  1. Elapsed=00:00:05.6456073 Gen0=74 Gen1=0 Gen2=0
复制代码
其它网络相关组件也将得到进一步优化。例如SslStream通常将围绕在NetworkStream中,以便向连接中添加SSL。下面的示例将看到这种影响,这个示例将在NetworkStream之上添加SslStream的用法:
  1. using System;
  2. using System.Diagnostics;
  3. using System.IO;
  4. using System.Net;
  5. using System.Net.Sockets;
  6. using System.Threading;
  7. using System.Threading.Tasks;
  8. class Test
  9. {
  10.     static void Main() => MainAsync().GetAwaiter().GetResult();
  11.     static async Task MainAsync()
  12.     {
  13.         using (Socket listener = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp))
  14.         using (Socket client = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp))
  15.         {
  16.             listener.Bind(new IPEndPoint(IPAddress.Loopback, 0));
  17.             listener.Listen(1);

  18.             Task connectTask = Task.Run(() => client.Connect(listener.LocalEndPoint));
  19.             using (Socket server = listener.Accept())
  20.             {
  21.                 await connectTask;

  22.                 using (var serverStream = new NetworkStream(server))
  23.                 using (var clientStream = new NetworkStream(client))
  24.                 {
  25.                     Task serverCopyAll = serverStream.CopyToAsync(Stream.Null);

  26.                     byte[] data = new byte[1024];
  27.                     new Random().NextBytes(data);

  28.                     var sw = new Stopwatch();
  29.                     int gen0 = GC.CollectionCount(0), gen1 = GC.CollectionCount(1), gen2 = GC.CollectionCount(2);
  30.                     sw.Start();

  31.                     for (int i = 0; i < 1_000_000; i++)
  32.                     {
  33.                         await clientStream.WriteAsync(data, 0, data.Length);
  34.                     }
  35.                     client.Shutdown(SocketShutdown.Send);
  36.                     serverCopyAll.Wait();
  37.                     sw.Stop();

  38.                     Console.WriteLine([        DISCUZ_CODE_64        ]quot;Elapsed={sw.Elapsed} Gen0={GC.CollectionCount(0) - gen0} Gen1={GC.CollectionCount(1) - gen1} Gen2={GC.CollectionCount(2) - gen2}");
  39.                 }
  40.             }
  41.         }
  42.     }
  43. }
复制代码
在.NET 4.7中,会得到如下结果:
  1. Elapsed=00:00:21.1171962 Gen0=470 Gen1=3 Gen2=1
复制代码
.NET Core 2.0包含了诸如dotnet / corefx#12935dotnet / corefx#13274等PR的改进,这两者都将大大减少了使用SslStream所涉及的分配。在.NET Core 2.0上运行相同的代码时,会得到如下结果:
  1. Elapsed=00:00:05.6456073 Gen0=74 Gen1=0 Gen2=0
复制代码
85%的垃圾收集已被删除!

并发
对于并发和并行性相关的原始化和基础部分,也得到了许多改进。
这里的一个关键点是ThreadPool,它是执行许多.NET应用程序的核心。例如,PR dotnet / coreclr#3157减少了QueueUserWorkItem中涉及的某些对象的大小,PR dotnet / coreclr#9234使用了ConcurrentQueue <T>重写来替换ThreadPool的全局队列,其中会用到较少的同步和分配。从以下的示例中,会看到最终结果:
  1. using System;
  2. using System.Diagnostics;
  3. using System.Threading;
  4. class Test
  5. {
  6.     static void Main()
  7.     {
  8.         while (true)
  9.         {
  10.             int remaining = 20_000_000;
  11.             var mres = new ManualResetEventSlim();
  12.             WaitCallback wc = null;
  13.             wc = delegate
  14.             {
  15.                 if (Interlocked.Decrement(ref remaining) <= 0) mres.Set();
  16.                 else ThreadPool.QueueUserWorkItem(wc);
  17.             };

  18.             var sw = new Stopwatch();
  19.             int gen0 = GC.CollectionCount(0), gen1 = GC.CollectionCount(1), gen2 = GC.CollectionCount(2);
  20.             sw.Start();

  21.             for (int i = 0; i < Environment.ProcessorCount; i++) ThreadPool.QueueUserWorkItem(wc);
  22.             mres.Wait();

  23.             Console.WriteLine([        DISCUZ_CODE_67        ]quot;Elapsed={sw.Elapsed} Gen0={GC.CollectionCount(0) - gen0} Gen1={GC.CollectionCount(1) - gen1} Gen2={GC.CollectionCount(2) - gen2}");
  24.         }
  25.     }
  26. }
复制代码
在.NET 4.7中,会等到如下结果:
  1. Elapsed=00:00:03.6263995 Gen0=225 Gen1=51 Gen2=16
  2. Elapsed=00:00:03.6304345 Gen0=231 Gen1=62 Gen2=17
  3. Elapsed=00:00:03.6142323 Gen0=225 Gen1=53 Gen2=16
  4. Elapsed=00:00:03.6565384 Gen0=232 Gen1=62 Gen2=16
  5. Elapsed=00:00:03.5999892 Gen0=228 Gen1=62 Gen2=17
复制代码
而在.NET Core 2.0中,会得到如下结果:
  1. Elapsed=00:00:02.1797508 Gen0=153 Gen1=0 Gen2=0
  2. Elapsed=00:00:02.1188833 Gen0=154 Gen1=0 Gen2=0
  3. Elapsed=00:00:02.1000003 Gen0=153 Gen1=0 Gen2=0
  4. Elapsed=00:00:02.1024852 Gen0=153 Gen1=0 Gen2=0
  5. Elapsed=00:00:02.1044461 Gen0=154 Gen1=1 Gen2=0
复制代码
这是一个巨大的吞吐量的改善,并且这样一个核心组件的垃圾量也将大幅减少。
同步原语也在.NET Core中得到提升。例如,低级并发代码通常使用SpinLock来尝试避免分配锁定对象或最小化竞争锁所花费的时间。PR dotnet / coreclr#6952改进了失败的快速路径,以下测试会得到显而易见的结果:
  1. using System;
  2. using System.Diagnostics;
  3. using System.Threading;
  4. class Test
  5. {
  6.     static void Main()
  7.     {
  8.         while (true)
  9.         {
  10.             bool taken = false;
  11.             var sl = new SpinLock(false);
  12.             sl.Enter(ref taken);

  13.             var sw = Stopwatch.StartNew();
  14.             for (int i = 0; i < 100_000_000; i++)
  15.             {
  16.                 taken = false;
  17.                 sl.TryEnter(0, ref taken);
  18.             }
  19.             Console.WriteLine(sw.Elapsed);
  20.         }
  21.     }
  22. }
复制代码
在.NET 4.7中,会得到如下结果:
  1. 00:00:02.3276463
  2. 00:00:02.3174042
  3. 00:00:02.3022212
  4. 00:00:02.3015542
  5. 00:00:02.2974777
复制代码
而在.NET Core 2.0中,会得到如下结果:
  1. 00:00:00.3915327
  2. 00:00:00.3953084
  3. 00:00:00.3875121
  4. 00:00:00.3980009
  5. 00:00:00.3886977
复制代码
吞吐量的这种差异可能会对运行这种锁的热路径产生很大的影响。
这只是众多例子中的一个。另一个例子围绕着Lazy<T>,它被PR dotnet / coreclr#8963manofstick重写,以便提高访问初始化过的Lazy <T>的效率。这样的提升效果从下面的示例中清晰可见:
  1. using System;
  2. using System.Diagnostics;
  3. class Test
  4. {
  5.     static int s_result;

  6.     static void Main()
  7.     {
  8.         while (true)
  9.         {
  10.             var lazy = new Lazy<int>(() => 42);
  11.             s_result = lazy.Value;

  12.             var sw = Stopwatch.StartNew();
  13.             for (int i = 0; i < 1_000_000_000; i++)
  14.             {
  15.                 s_result = lazy.Value;
  16.             }
  17.             Console.WriteLine(sw.Elapsed);
  18.         }
  19.     }
  20. }
复制代码
在.NET 4.7中,会得到的结果如下:
  1. 00:00:02.6769712
  2. 00:00:02.6789140
  3. 00:00:02.6535493
  4. 00:00:02.6911146
  5. 00:00:02.7253927
复制代码
而在.NET Core 2.0中,会得到的结果如下:
  1. 00:00:00.5278348
  2. 00:00:00.5594950
  3. 00:00:00.5458245
  4. 00:00:00.5381743
  5. 00:00:00.5502970
复制代码
吞吐量增加约5倍。

下一步是什么
本文只涉及了部分.NET Core的性能改进。在dotnet / corefxdotnet / coreclr repos 中的pull请求中搜索“perf”或“performance”,你会发现接近一千个合并的PR改进。其中一些是比较大的同时也很有影响力的改进,而另一些则主要减少了库和运行时的消耗,这些变化一起起作用,保证了能够在.NET Core上更快的运行应用程序。展望未来,性能将成为关注的重点,无论是以性能改进为目标的API还是现有库的性能的改进。

欢迎大家深入了解.NET Core代码库,以便找到影响自己的应用程序和库的瓶颈,并提交PR来修复它们。如果你的问题得到修复,也请将修复程序分享给所有需要的人。
转载请注明出自:葡萄城控件
   
关于葡萄城:全球最大的控件提供商,世界领先的企业应用定制工具、企业报表和商业智能解决方案提供商,为超过75%的全球财富500强企业提供服务。
回复

使用道具 举报

*滑动验证:
您需要登录后才可以回帖 登录 | 立即注册

本版积分规则

欢迎关注葡萄城控件

小黑屋|手机版|Archiver|葡萄城控件官网 ( 沪ICP备05020274号

GMT+8, 2017-9-23 01:10 , Processed in 1.134693 second(s), 31 queries .

Powered by Discuz! X3.2

© 2001-2013 Comsenz Inc.

快速回复 返回顶部 返回列表