BenchmarkDotNet

lanwah發表於2024-04-21

官方開源地址和文件
How it works
Choosing RunStrategy
簡單使用示例
BenchmarkDotNet列印列的含義
Benchmark輸出列
Benchmark特性
相關參考
版權特別宣告

官方開源地址和文件

GitHub：GitHub - dotnet/BenchmarkDotNet: Powerful .NET library for benchmarking

文件首頁：Overview | BenchmarkDotNet

How it works

hand-right https://benchmarkdotnet.org/articles/guides/how-it-works.html

BenchmarkDotNet follows the following steps to run your benchmarks:

BenchmarkRunner generates an isolated project per each runtime settings and builds it in Release mode.
Next, we take each method/job/params combination and try to measure its performance by launching benchmark process several times (LaunchCount).
An invocation of the workload method is an operation . A bunch of operation is an iteration . If you have an IterationSetup method, it will be invoked before each iteration, but not between operations. We have the following type of iterations:
- Pilot: The best operation count will be chosen.
- OverheadWarmup, OverheadWorkload: BenchmarkDotNet overhead will be evaluated.
- ActualWarmup: Warmup of the workload method.
- ActualWorkload: Actual measurements.
- Result = ActualWorkload - <MedianOverhead>
After all of the measurements, BenchmarkDotNet creates:
- An instance of the Summary class that contains all information about benchmark runs.
- A set of files that contains summary in human-readable and machine-readable formats.
- A set of plots.

Choosing RunStrategy

If you run a benchmark, you always (explicitly or implicitly) use a job. Each Job has the RunStrategy parameter which allows switching between different benchmark modes. The default RunStrategy is Throughput, and it works fine for most cases. However, other strategies are also useful in some specific cases.

hand-right https://benchmarkdotnet.org/articles/guides/choosing-run-strategy.html

簡單使用示例

Program.cs

    /// <summary>
    /// https://benchmarkdotnet.org/articles/overview.html
    /// </summary>
    internal class Program
    {
        static void Main(string[] args)
        {
            //var hashHelper = new Md5VsSha256();
            //var byte1 = hashHelper.Md5();
            //var byte2 = hashHelper.Sha256();
            //var isEqual = byte1.SequenceEqual(byte2);


            var summary = BenchmarkRunner.Run<Md5VsSha256>();
            Console.ReadLine();
        }
    }

Md5VsSha256.cs

    [MemoryDiagnoser]
    //[SimpleJob(RunStrategy.ColdStart)]
    [SimpleJob(RunStrategy.ColdStart, iterationCount: 5)]
    public class Md5VsSha256
    {
        private const int N = 10000;
        private readonly byte[] data;

        private readonly SHA256 sha256 = SHA256.Create();
        private readonly MD5 md5 = MD5.Create();

        public Md5VsSha256()
        {
            data = new byte[N];
            new Random(42).NextBytes(data);
        }

        [Benchmark]
        public byte[] Sha256() => sha256.ComputeHash(data);

        [Benchmark(Baseline = true)]
        public byte[] Md5() => md5.ComputeHash(data);
    }