是什么优化让 .NET Core 性能飙升？

发布时间：2017-07-18 11:10:59.227作者：IT网络文摘

欢迎大家持续关注葡萄城控件技术团队博客，更多更好的原创文章尽在这里~~

.NET Core（开放源代码，跨平台，x-copy可部署等）有许多令人兴奋的方面，其中最值得称赞的就是其性能了。

感谢所有社区开发人员对.NET Core做出的贡献，其中的许多改进也将在接下来的几个版本中引入.NET Framework。

本文主要介绍.NET Core中的一些性能改进，特别是.NET Core 2.0中的，重点介绍各个核心库的一些示例。

集合

集合是任何应用程序的基石，同时.NET库中也有大量集合。.NET库中的一些改进是为了消除开销，例如简化操作以便更好的实现内联，减少指令数量等。例如，下面的这个使用Q<T>的例子：

using System;using System.Diagnostics;using System.Collections.Generic;public class Test
{    public static void Main()
    {        while (true)
        {            var q = new Queue<int>();            var sw = Stopwatch.StartNew();            for (int i = 0; i < 100_000_000; i++)
            {
                q.Enqueue(i);
                q.Dequeue();
            }
            Console.WriteLine(sw.Elapsed);
        }
    }
}

PR dotnet/corefx #2515移除了这些操作中相对复杂的模数运算，在个人计算机，以上代码在.NET 4.7上产生如下输出：

00：00：00.9392595 00：00：00.9390453 00：00：00.9455784 00：00：00.9508294 00：00：01.0107745

而使用.NET Core 2.0则会产生如下输出：

00：00：00.5514887 00：00：00.5662477 00：00：00.5627481 00：00：00.5685286 00：00：00.5262378

由于这是挂钟时间所节省的，较小的值计算的更快，这也表明吞吐量增加了约2倍！

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

using System;using System.Diagnostics;using System.Collections.Generic;using System.Linq;public class Test
{    public static void Main()
    {        var sw = Stopwatch.StartNew();        var ss = new SortedSet<int>(Enumerable.Repeat(42, 400_000));
        Console.WriteLine(sw.Elapsed);
    }
}

在个人电脑的.NET Framework上，这段代码需要大约7.7秒执行完成。在.NET Core 2.0上，减少到大约0.013s（改进改变了算法的复杂性，集合越大，节省的时间越多）。

或者在SortedSet <T>上考虑这个例子：

public class Test
{    static int s_result;    public static void Main()
    {        while (true)
        {            var s = new SortedSet<int>();            for (int n = 0; n < 100_000; n++)
            {
                s.Add(n);
            }            var sw = Stopwatch.StartNew();            for (int i = 0; i < 10_000_000; i++)
            {
                s_result = s.Min;
            }
            Console.WriteLine(sw.Elapsed);
        }
    }
}

.NET 4.7中Min和Max的实现遍布SortedSet <T>的整个树，但是只需要找到最小或最大值即可，因为实现可以只遍历相关的节点。PR dotnet / corefx＃11968修复了.NET Core实现。在.NET 4.7中，此示例生成如下结果：

00：00：01.142724600：00：01.1295220 00：00：01.1350696 00：00：01.1502784 00：00：01.1677880

而在.NET Core 2.0中，我们得到如下结果：

00：00：00.0861391 00：00：00.0861183 00：00：00.0866616 00：00：00.0848434 00：00：00.0860198

显示出相当大的时间下降和吞吐量的增加。

即使像List <T>这样的主工作核心也有改进的空间。考虑下面的例子：

using System;using System.Diagnostics;using System.Collections.Generic;public class Test
{    public static void Main()
    {        while (true)
        {            var l = new List<int>();            var sw = Stopwatch.StartNew();            for (int i = 0; i < 100_000_000; i++)
            {
                l.Add(i);
                l.RemoveAt(0);
            }
            Console.WriteLine(sw.Elapsed);
        }
    }
}

在.NET 4.7中，会得到的结果如下：

00：00：00.4434135 00：00：00.4394329 00：00：00.4496867 00：00：00.4496383 00：00：00.4515505

和.NET Core 2.0，得到：

00：00：00.3213094 00：00：00.3211772 00：00：00.3179631 00：00：00.3198449 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>：

using System;using System.Diagnostics;using System.Collections.Concurrent;public class Test
{    public static void Main()
    {        while (true)
        {            var q = new ConcurrentQueue<int>();            var sw = Stopwatch.StartNew();            for (int i = 0; i < 100_000_000; i++)
            {
                q.Enqueue(i);
                q.TryDequeue(out int _);
            }
            Console.WriteLine(sw.Elapsed);
        }
    }
}

在个人电脑上，.NET 4.7产生的输出如下：

00：00：02.648517400：00：02.6144919 00：00：02.6699958 00：00：02.6441047 00：00：02.6255135

显然，.NET 4.7上的ConcurrentQueue <T>示例比.NET 4.7中的Queue <T>版本慢，因为ConcurrentQueue <T>需要采用同步来确保是否安全使用。但是，更有趣的比较是当在.NET Core 2.0上运行相同的代码时会发生什么：

00：00：01.7700190 00：00：01.8324078 00：00：01.7552966 00：00：01.7518632 00：00：01.7560811

这表明当将.NET Core 2.0切换到30％时，ConcurrentQueue <T>的吞吐量没有任何并发性提高。但是实施中的变化提高了序列化的吞吐量，甚至更多地减少了使用队列的生产和消耗之间的同步，这可能对吞吐量有更明显的影响。请考虑以下代码：

using System;using System.Diagnostics;using System.Collections.Concurrent;using System.Threading.Tasks;public class Test
{    public static void Main()
    {        while (true)
        {            const int Items = 100_000_000;            var q = new ConcurrentQueue<int>();            var sw = Stopwatch.StartNew();

            Task consumer = Task.Run(() =>
            {                int total = 0;                while (total < Items) if (q.TryDequeue(out int _)) total++;
            });            for (int i = 0; i < Items; i++) q.Enqueue(i);
            consumer.Wait();

            Console.WriteLine(sw.Elapsed);
        }
    }
}

在.NET 4.7中，个人计算机输出如下结果：

00：00：06.136604400：00：05.7169339 00：00：06.3870274 00：00：05.5487718 00：00：06.6069291

而使用.NET Core 2.0，会得到以下结果：

00：00：01.2052460 00：00：01.5269184 00：00：01.4638793 00：00：01.4963922 00：00：01.4927520

这是一个3.5倍的吞吐量的增长。不但CPU效率提高了，而且内存分配也大大减少。下面的例子主要观察GC集合的数量，而不是挂钟时间：

using System;using System.Diagnostics;using System.Collections.Concurrent;public class Test
{    public static void Main()
    {        while (true)
        {            var q = new ConcurrentQueue<int>();            int gen0 = GC.CollectionCount(0), gen1 = GC.CollectionCount(1), gen2 = GC.CollectionCount(2);            for (int i = 0; i < 100_000_000; i++)
            {
                q.Enqueue(i);
                q.TryDequeue(out int _);
            }
            Console.WriteLine($"Gen0={GC.CollectionCount(0) - gen0} Gen1={GC.CollectionCount(1) - gen1} Gen2={GC.CollectionCount(2) - gen2}");
        }
    }
}

在.NET 4.7中，得到以下输出：

Gen0 = 162 Gen1 = 80 Gen2 = 0 Gen0 = 162 Gen1 = 81 Gen2 = 0 Gen0 = 162 Gen1 = 81 Gen2 = 0 Gen0 = 162 Gen1 = 81 Gen2 = 0 Gen0 = 162 Gen1 = 81 Gen2 = 0

而使用.NET Core 2.0，会得到如下输出：

Gen0 = 0 Gen1 = 0 Gen2 = 0 Gen0 = 0 Gen1 = 0 Gen2 = 0 Gen0 = 0 Gen1 = 0 Gen2 = 0 Gen0 = 0 Gen1 = 0 Gen2 = 0 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中，这些队列是数组，这意味着除了增加阵列所涉及的均摊成本之外，增加的还是无需配置的。以下可以看出：

using System;using System.Diagnostics;using System.Collections.Concurrent;public class Test
{    public static void Main()
    {        while (true)
        {            var q = new ConcurrentBag<int>() { 1, 2 };            var sw = new Stopwatch();            int gen0 = GC.CollectionCount(0), gen1 = GC.CollectionCount(1), gen2 = GC.CollectionCount(2);
            sw.Start();            for (int i = 0; i < 100_000_000; i++)
            {
                q.Add(i);
                q.TryTake(out int _);
            }

            sw.Stop();
            Console.WriteLine($"Elapsed={sw.Elapsed} Gen0={GC.CollectionCount(0) - gen0} Gen1={GC.CollectionCount(1) - gen1} Gen2={GC.CollectionCount(2) - gen2}");
        }
    }
}

在.NET 4.7中，个人计算机上产生以下输出：

Elapsed=00:00:06.5672723 Gen0=953 Gen1=0 Gen2=0Elapsed=00:00:06.4829793 Gen0=954 Gen1=1 Gen2=0Elapsed=00:00:06.9008532 Gen0=954 Gen1=0 Gen2=0Elapsed=00:00:06.6485667 Gen0=953 Gen1=1 Gen2=0Elapsed=00:00:06.4671746 Gen0=954 Gen1=1 Gen2=0

而使用.NET Core 2.0，会得到：

Elapsed=00:00:04.3377355 Gen0=0 Gen1=0 Gen2=0Elapsed=00:00:04.2892791 Gen0=0 Gen1=0 Gen2=0Elapsed=00:00:04.3101593 Gen0=0 Gen1=0 Gen2=0Elapsed=00:00:04.2652497 Gen0=0 Gen1=0 Gen2=0Elapsed=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中的实现是简单易懂的，下面的代码正好反映了这种行为表述：

static IEnumerable<TSource> ConcatIterator<TSource>(IEnumerable<TSource> first, IEnumerable<TSource> second) {    foreach (TSource element in first) yield return element;    foreach (TSource element in second) yield return element;
}

当两个序列是简单的枚举，如C＃中的迭代器生成的，这种过程会执行的很好。但是如果应用程序代码具有如下代码呢？

first.Concat(second.Concat(third.Concat(fourth)));

每次我们从迭代器中退出时，则会返回到枚举器的MoveNext方法。这意味着如果你从另一个迭代器中枚举产生一个元素，则会返回两个MoveNext方法，并移动到下一个需要调用这两个MoveNext方法的元素。你调用的枚举器越多，操作所需的时间越长，特别是这些操作中的每一个都涉及多个接口调用（MoveNext和Current）。这意味着连接多个枚举会以指数方式增长，而不是呈线性增长。PR dotnet / corefx＃6131修正了这个问题，在下面的例子中，区别是显而易见的：

using System;using System.Collections.Generic;using System.Diagnostics;using System.Linq;public class Test
{    public static void Main()
    {
        IEnumerable<int> zeroToTen = Enumerable.Range(0, 10);
        IEnumerable<int> result = zeroToTen;        for (int i = 0; i < 10_000; i++)
        {
            result = result.Concat(zeroToTen);
        }        var sw = Stopwatch.StartNew();        foreach (int i in result) { }
        Console.WriteLine(sw.Elapsed);
    }
}

在个人计算机上，.NET 4.7需要大约4.12秒。但在.NET Core 2.0中，这只需要约0.14秒，提高了30倍。

通过消除多个运算器同时使用时的消耗，运算器也得到了大大的提升。例如下面的例子：

using System;using System.Collections.Generic;using System.Diagnostics;using System.Linq;public class Te

转载请注明出自：葡萄城控件

http://www.cnblogs.com/powertoolsteam/p/net_core_2.html

分类导航

是什么优化让 .NET Core 性能飙升？

集合

LINQ

网友评论

更多精彩分享