BenchmarkDotNet 基准测试 .NET 库

BenchmarkDotNet：功能强大的用于基准测试 .NET 库

出处：https://www.cnblogs.com/xueweihan/p/11745280.html

=======================================================================================

【基准测试】BenchmarkDotNet介绍

BenchmarkDotNet 概述

BenchmarkDotNet helps you to transform methods into benchmarks, track their performance, and share reproducible measurement experiments. It's no harder than writing unit tests

提取几个关键字（其实是只认识那几个英文单词）

将方法转换基准测试
跟踪性能
可重复实验
不必单元测试难

说白了，就是代码的性能测试，通常是用来比较两段代码/方法，或者在不同平台上的执行效果。

BenchmarkDotNet 快速入门

添加包

dotnet add package BenchmarkDotNet

添加需要基准测试的方法（这里我准备两个排序算法，快速排序 && 堆排序）

[Benchmark]
[Arguments(new int[] { 3, 1, 10, 9, 6, 2, 5, 7, 8, 4 })]
public void QuickSort(int[] nums) => Demo.BenchmarkDotNet.QuickSort.Sort(nums);

[Benchmark]
[Arguments(new int[] { 3, 1, 10, 9, 6, 2, 5, 7, 8, 4 })]
public void HeapSort(int[] nums) => Demo.BenchmarkDotNet.HeapSort.Sort(nums);

Main里执行BenchmarkRunner.Run

var summary = BenchmarkRunner.Run<QuickSortVsHeapSort>();

执行（需要Release模式）

dotnet run -c=Release

分析结果

BenchmarkDotNet=v0.12.1, OS=Windows 10.0.18363.778 (1909/November2018Update/19H2)
Intel Core i7-10510U CPU 1.80GHz, 1 CPU, 8 logical and 4 physical cores
.NET Core SDK=3.1.202
  [Host]     : .NET Core 3.1.4 (CoreCLR 4.700.20.20201, CoreFX 4.700.20.22101), X64 RyuJIT
  DefaultJob : .NET Core 3.1.4 (CoreCLR 4.700.20.20201, CoreFX 4.700.20.22101), X64 RyuJIT


|    Method |      nums |     Mean |    Error |   StdDev |
|---------- |---------- |---------:|---------:|---------:|
| QuickSort | Int32[10] | 61.98 ns | 0.242 ns | 0.202 ns |
|  HeapSort | Int32[10] | 89.19 ns | 0.374 ns | 0.332 ns |

除了控制台，还可以在BenchmarkDotNet.Artifacts/result找到多种格式的输出结果

可以看到QuickSort ，HeapSort比较接近，但是我们测试的数据量太少，所以这个没代表性

总结

可以看到BenchmarkDotNet对原来的代码是没有侵入式，通常我是新建一个测试类，然后再测试类初始化测试参数，这样对原来代码没有侵入

进阶用法

多组输入参数

[Benchmark]
[ArgumentsSource(nameof(Data))]
public void QuickSort(int[] nums) => Demo.BenchmarkDotNet.QuickSort.Sort(nums);

public IEnumerable<int[]> Data()
{
    var random = new Random();
    var datas = Enumerable.Range(1, 10000).ToArray();
    // 打乱数组
    for (int i = datas.Length - 1; i > 0; i--)
    {
        var value = datas[i];
        var randomIndex = random.Next(0, i);
        datas[i] = datas[randomIndex];
        datas[randomIndex] = value;
    }
    yield return datas.Take(100).ToArray();
    yield return datas.Take(1000).ToArray();
    yield return datas;
}

ArgumentsSource : 参数可以是方法/属性的名称

多平台比较

在基准测试类中添加SimpleJob

[SimpleJob(RuntimeMoniker.NetCoreApp31)]
[SimpleJob(RuntimeMoniker.Net472)]
public class QuickSortVsHeapSort
{
}

项目方案添加多个运行时

<TargetFrameworks>netcoreapp3.1;net472</TargetFrameworks>

添加统计字段

在基准测试类添加MaxColumn , MinColumn,MemoryDiagnoser

[MaxColumn, MinColumn, MemoryDiagnoser]
public class QuickSortVsHeapSort
{
  ...
}

添加基准

比较快速排序和堆排序，可以用其中一个作为基准，也可以新增一个作为基准作为参考。例如这里选择以冒泡排序作为基准，下图是各个排序算法的时间复杂度

[Benchmark(Baseline = true)]
[ArgumentsSource(nameof(Data))]
public void BubbleSort(int[] nums) => Demo.BenchmarkDotNet.BubbleSort.Sort(nums);

使用BenchmarkDotNet 模板

安装模板

dotnet new -i BenchmarkDotNet.Templates

创建模板

dotnet new benchmark

使用BenchmarkDotNet dotnet tool

安装

dotnet tool install -g BenchmarkDotNet.Tool

使用

dotnet benchmark [arguments] [options]

示例源码

出处 : https://www.cnblogs.com/WilsonPan/p/12904664.html

=======================================================================================

使用 BenchmarkDotnet 测试代码性能

先来点题外话，清明节前把工作辞了（去 tm 的垃圾团队，各种拉帮结派、勾心斗角）。这次找工作就得慢慢找了，不能急了，希望能找到个好团队，好岗位吧。顺便这段时间也算是比较闲，也能学习一下和填掉手上的坑。

说实话好久没写博客了，一个是手上的工作确实忙，第二个是还有各种各样的坑。写本文的原因也是因为手上的一个坑——ImageEx，WPF/UWP 上的图片缓存控件。

在我写的这个图片缓存控件中，其中有一个地方就是要根据图片的 url 地址，然后来存储或者获取本地的图片文件的。但是呢，我们不可能把 url 当作本地文件的文件名的，一个是可能包含非法字符（如斜杠），另一个是长度可能超出限制。想了一下，那就只能用哈希（hash）来解决了，其中 MD5 和 SHA1 两种算法我觉得都可以解决这个问题。但问题是，哪一个更好、更快呢？传统经验告诉我是 MD5，但是我觉得还是有必要手动实践一下，毕竟没有 100% 的把握。

先编写出如下的代码：

public static class HashHelper
{
    public static string GetMD5(string input)
    {
        if (input == null)
        {
            throw new ArgumentNullException(nameof(input));
        }

        using (var md5 = MD5.Create())
        {
            var buffer = Encoding.UTF8.GetBytes(input);
            var hashResult = md5.ComputeHash(buffer);
            return BitConverter.ToString(hashResult).Replace("-", string.Empty);
        }
    }

    public static string GetSHA1(string input)
    {
        if (input == null)
        {
            throw new ArgumentNullException(nameof(input));
        }

        using (var sha1 = SHA1.Create())
        {
            var buffer = Encoding.UTF8.GetBytes(input);
            var hashResult = sha1.ComputeHash(buffer);
            return BitConverter.ToString(hashResult).Replace("-", string.Empty);
        }
    }
}

作用是输入一个字符串，输出一个哈希后的字符串。

建立一个 .net core 的控制台项目，我就叫 TestBenchmarkDotnet。

然后安装 nuget 包，BenchmarkDotnet。

安装完成后编写如下代码：

public class TestContext
{
    [Benchmark]
    public void TestMD5()
    {
        HashHelper.GetMD5("https://www.baidu.com/img/bd_logo1.png");
    }

    [Benchmark]
    public void TestSHA1()
    {
        HashHelper.GetSHA1("https://www.baidu.com/img/bd_logo1.png");
    }
}

然后修改 Main 方法：

public class Program
{
    public static void Main(string[] args)
    {
        Summary summary = BenchmarkRunner.Run<TestContext>();
        Console.ReadLine();
    }
}

最后将 Debug 调成 Release 模式，不调试启动。

稍微等待一会儿就会出现结果了。

结论是 MD5 确实比 SHA1 快。

另外由于这是在 .net core 下的测试结果，而 WPF 是跑在 .net framework 下的，那么是否结果可能不一样呢？

Benchmark 支持多个 .net 环境的性能测试（.net framework, net core, mono）。

修改 TestContext 类的代码：

[ClrJob, CoreJob]
public class TestContext
{
    [Benchmark]
    public void TestMD5()
    {
        HashHelper.GetMD5("https://www.baidu.com/img/bd_logo1.png");
    }

    [Benchmark]
    public void TestSHA1()
    {
        HashHelper.GetSHA1("https://www.baidu.com/img/bd_logo1.png");
    }
}

添加了 ClrJob 和 CoreJob 两个标签

然后修改项目的 csproj 文件

将

<TargetFramework>netcoreapp2.0</TargetFramework>

一行改为

<TargetFrameworks>netcoreapp2.0;net471</TargetFrameworks>

回到 VS 重新编译，还原 nuget 包。

不调试启动。稍等片刻。

可见在 .net framework 环境下，仍然是 MD5 比 SHA1 快的。而且可以看见 .net core 比 .net framework 环境下快了很多。

另外在输出目录下，BenchmarkDotnet 会输出性能测试结果文件：

打开 html 版本后看到的跟刚才控制台的是一样的

出处：https://www.cnblogs.com/h82258652/p/8748345.html

=======================================================================================

.NET Core中的性能测试工具BenchmarkDotnet

背景介绍

之前一篇博客中，我们讲解.NET Core中的CSV解析库，在文章的最后，作者使用了性能基准测试工具BenchmarkDotNet测试了2个不同CSV解析库的性能，本篇我们来详细介绍一下BenchmarkDotNet。

原文链接：https://dotnetcoretutorials.com/2017/12/04/benchmarking-net-core-code-benchmarkdotnet/

为什么需要性能基准测试?

性能基准测试可以帮助程序员对比2个代码段或者方法的性能，这对于代码重写或者重构来说，可以提供一种很好的量化标准。如果没有性能基准测试，很难想象将方法A改为B方法时候，仅凭肉眼如何区分性能的变化。

BenchmarkDotNet

BenchmarkDotNet是一款强力的.NET性能基准测试库, 官网https://benchmarkdotnet.org/。

运行时支持

NET Framework (4.6+),
.NET Core (2.0+)
Mono
CoreRT。

BenchmarkDotnet为每个被测试的方法提供了孤立的环境, 使用BenchmarkDotnet, 程序员可以很容易的编写各种性能测试方法，并可以避免许多常见的坑。

代码基准测试(Code Benchmarking)

现在我们希望来对比一下Linq to object中First和Single方法的性能

虽然我们知道First的性能肯定比Single高, First方法会在查询到第一个满足条件的对象之后就停止集合遍历，而Single找到第一个满足条件的对象之后，不会停止查找，它会去继续查找集合中的剩余对象，直到遍历整个集合或者在集合中找到第二个匹配条件的对象。这里我们只是为了演示一下如何进行代码基准测试。

为了使用BenchmarkDotNet来进行代码基准测试，我们首先创建一个空的.Net Core控制台程序。

然后我们使用Package Manage Console添加BenchmarkDotNet库

PM> Install-Package BenchmarkDotNet

然后我们修改Program.cs文件, 代码如下

    public class Program
    {
        public class SingleVsFirst
        {
            private readonly List<string> _haystack = new List<string>();
            private readonly int _haystackSize = 1000000;
            private readonly string _needle = "needle";

            public SingleVsFirst()
            {
                //Add a large amount of items to our list. 
                Enumerable.Range(1, _haystackSize).ToList().ForEach(x => _haystack.Add(x.ToString()));
                //Insert the needle right in the middle. 
                _haystack.Insert(_haystackSize / 2, _needle);
            }

            [Benchmark]
            public string Single() => _haystack.SingleOrDefault(x => x == _needle);

            [Benchmark]
            public string First() => _haystack.FirstOrDefault(x => x == _needle);

        }

        public static void Main(string[] args)
        {
            var summary = BenchmarkRunner.Run<SingleVsFirst>();
            Console.ReadLine();
        }
    }

代码解释说明

以上代码中SingleVsFirst类是一个测试类。
测试类中我们生成了一个拥有100万对象的字符串集合。
我们在集合的中间位置插入了一个测试字符串，字符串的内容是"needle"。
代码中的Single和First方法，分别调用了Linq to object的SingleOrDefault和FirstOrDefault方法来查询字符串集合中的"needle"字符串。
在Single和First方法上，我们加入[Benchmark]特性, 拥有该特性的方法会出现在最后的基准检测报告中。

注意：

测试的方法必须是公开的(public), 如果把public去掉，程序不会产生任何结果

在运行程序之前，还有一步关键的操作，测试的程序需要使用Release模式编译，并且不能附加任何调试器(Debugger)

最终结果

现在我们运行程序，程序产生的最终报告如下

Method  |     Mean |     Error |   StdDev |   Median |
------- |---------:|----------:|---------:|---------:|
 Single | 28.12 ms | 0.9347 ms | 2.697 ms | 28.93 ms |
  First | 13.30 ms | 0.8394 ms | 2.475 ms | 14.48 ms |

结果中的第一列Mean表明了2个方法处理的平均响应时间，First比Single快了一倍(这和我们测试字符串放置的位置有关系)。

带测试参数的基准测试(Input Benchmarking)

BenchmarkDotNet中我们还可以使用[ParamsSource]参数来指定测试的用例范围。
在上面的代码中，我们测试了匹配字符串在集合中间位置时，First和Single的效率对比，下面我们修改上面的代码，我们希望分别测试匹配字符串在集合头部，尾部以及中间位置时First和Single的效率对比。


using System;
using System.Collections.Generic;
using System.Linq;
 
using BenchmarkDotNet.Attributes;
using BenchmarkDotNet.Running;
 
namespace BenchmarkExample
{
    public class SingleVsFirst
    {
        private readonly List<string> _haystack = new List<string>();
        private readonly int _haystackSize = 1000000;
 
        public List<string> _needles => new List<string> { "StartNeedle", "MiddleNeedle", "EndNeedle" };
 
        public SingleVsFirst()
        {
            //Add a large amount of items to our list. 
            Enumerable.Range(1, _haystackSize).ToList().ForEach(x => _haystack.Add(x.ToString()));
 
            //One at the start. 
            _haystack.Insert(0, _needles[0]);
            //One right in the middle. 
            _haystack.Insert(_haystackSize / 2, _needles[1]);
            //One at the end. 
            _haystack.Insert(_haystack.Count - 1, _needles[2]);
        }
 
        [ParamsSource(nameof(_needles))]
        public string Needle { get; set; }
 
        [Benchmark]
        public string Single() => _haystack.SingleOrDefault(x => x == Needle);
 
        [Benchmark]
        public string First() => _haystack.FirstOrDefault(x => x == Needle);
 
    }
 
    class Program
    {
        static void Main(string[] args)
        {
            var summary = BenchmarkRunner.Run<SingleVsFirst>();
            Console.ReadLine();
        }
    }
}

代码解释说明

我们创建了测试的用例字符串集合_needles
在构造函数中，我们在字符串集合的头部，中部，尾部分别插入了3个字符串
我们添加了一个属性Needle, 表示当前测试的用例，在被测试Single和First方法中，我们使用属性Needle来匹配
在属性Needle上我们加上了参数来源特性[ParamsSource], 并设置参数来源是_needles

最终效果

现在我们运行程序，程序产生的最终报告如下

 Method |       Needle |             Mean |          Error |           StdDev |           Median |
------- |------------- |-----------------:|---------------:|-----------------:|-----------------:|
 Single |    EndNeedle | 23,266,757.53 ns | 432,206.593 ns |   591,609.263 ns | 23,236,343.07 ns |
  First |    EndNeedle | 24,984,621.12 ns | 494,223.345 ns |   783,890.599 ns | 24,936,945.21 ns |
 Single | MiddleNeedle | 21,379,814.14 ns | 806,253.579 ns | 2,377,256.870 ns | 22,436,101.14 ns |
  First | MiddleNeedle | 11,984,519.09 ns | 315,184.021 ns |   924,380.173 ns | 12,233,700.94 ns |
 Single |  StartNeedle | 23,650,243.23 ns | 599,968.173 ns |   714,219.431 ns | 23,555,402.19 ns |
  First |  StartNeedle |         89.17 ns |       1.864 ns |         2.732 ns |         89.07 ns

从结果上看

当匹配字符串在集合头部的时候，First性能比Single高的多
当匹配字符串在集合中部的时候，First性能是比Single的一倍
当匹配字符串在集合尾部的时候，First和比Single的性能差不多

加入内存测试

在.NET Core中的CSV解析库中，我们使用了以下代码

    [MemoryDiagnoser]
    public class CsvBenchmarking
    {
        [Benchmark(Baseline =true)]
        public IEnumerable<Automobile> CSVHelper()
        {
            TextReader reader = new StreamReader("import.txt");
            var csvReader = new CsvReader(reader);
            var records = csvReader.GetRecords<Automobile>();
            return records.ToList();
        }
     
        [Benchmark]
        public IEnumerable<Automobile> TinyCsvParser()
        {
            CsvParserOptions csvParserOptions = new CsvParserOptions(true, ',');
            var csvParser = new CsvParser<Automobile>(csvParserOptions, new CsvAutomobileMapping());
     
            var records = csvParser.ReadFromFile("import.txt", Encoding.UTF8);
     
            return records.Select(x => x.Result).ToList();
        }
    }

其中除了[Benchmark]特性，我们还在测试类CsvBenchmarking上添加了[MemoryDiagnoser]特性，该特性会在测试报告中追加，2个方法执行时的内存使用情况。

        Method |       Mean | Scaled | Allocated |
-------------- |-----------:|-------:|----------:|
     CSVHelper | 1,404.5 ms |   1.00 | 244.39 MB |
 TinyCsvParser |   381.6 ms |   0.27 |  32.53 MB |

其中Allocated表明了内存占用情况。

总结

BenchmarkDotNet绝对是.NET开发人员了解代码性能，以及对比代码性能的必备神器。你的项目里用了BenchmarkDotnet了么？

本文源代码

出处：https://www.cnblogs.com/lwqlun/p/9671611.html

=======================================================================================

posted on 2023-02-03 13:39 jack_Meng 阅读(578) 评论(0) 编辑收藏举报

刷新页面返回顶部

Jack_孟

BenchmarkDotNet 基准测试 .NET 库

【基准测试】BenchmarkDotNet介绍

BenchmarkDotNet 概述

BenchmarkDotNet 快速入门

进阶用法

多组输入参数

多平台比较

添加统计字段

添加基准

使用BenchmarkDotNet 模板

使用BenchmarkDotNet dotnet tool

使用 BenchmarkDotnet 测试代码性能

.NET Core中的性能测试工具BenchmarkDotnet

背景介绍

为什么需要性能基准测试?

BenchmarkDotNet

代码基准测试(Code Benchmarking)

代码解释说明

最终结果

带测试参数的基准测试(Input Benchmarking)

代码解释说明

最终效果

加入内存测试

总结

导航

公告