Understanding how your code performs and how it impacts system resources is crucial for building high-quality, efficient applications. BenchmarkDotNet is an essential tool that helps developers analyze and optimize the performance of their .NET code. Let’s explore how to effectively use BenchmarkDotNet for parameterized benchmarks, testing in different environments, customizing output, and performing memory diagnostics.
Parameterized Benchmarks: Flexibility in Testing with Params and ParamsAllValues
One of the key features of BenchmarkDotNet is the ability to parameterize your benchmarks. This allows you to run the same tests with different input values, making it easier to analyze performance across various scenarios.
Using Params
The Params attribute lets you specify a set of values to be passed to your benchmark method. This means you can test your code with different inputs and get results for each one.
Example:
public class MyBenchmark
{
[Params(10, 100, 1000)]
public int N;
[Benchmark]
public void MyTest()
{
// Code under test
for (int i = 0; i < N; i++)
{
// Some operation
}
}
}In this example, the test will be executed three times—with N = 10, N = 100, and N = 1000. This way, you’ll get separate performance results for each value of N.
Using ParamsAllValues
ParamsAllValues is particularly useful when you need to test all possible values of an enumeration (enum). If your code relies on different enum options, this attribute allows you to thoroughly evaluate the performance for each case.
Example:
public enum MyEnum
{
OptionA,
OptionB,
OptionC
}
public class MyBenchmark
{
[ParamsAllValues]
public MyEnum EnumOption;
[Benchmark]
public void MyTest()
{
switch (EnumOption)
{
case MyEnum.OptionA:
// Operation for OptionA
break;
case MyEnum.OptionB:
// Operation for OptionB
break;
case MyEnum.OptionC:
// Operation for OptionC
break;
}
}
}In this example, the test will run for each value of MyEnum, giving you a complete view of how different options impact performance.
Multiple Runs and Testing in Different Environments
BenchmarkDotNet also allows you to run tests in different environments, which is especially useful for analyzing the performance of cross-platform applications or apps running on different versions of .NET.
Benchmarking Against Different .NET Runtimes
With BenchmarkDotNet, you can easily test your code on multiple versions of .NET, including .NET Framework, .NET Core, and .NET 5/6/7. This is essential for comparing performance across different platforms.
Example:
[SimpleJob(RuntimeMoniker.Net48)]
[SimpleJob(RuntimeMoniker.NetCoreApp31)]
[SimpleJob(RuntimeMoniker.Net60)]
public class MyBenchmark
{
[Benchmark]
public void MyTest()
{
// Code under test
}
}This code runs the benchmark on .NET Framework 4.8, .NET Core 3.1, and .NET 6.0, allowing you to compare the results for each runtime version.
Using Different JIT Modes
The JIT (Just-In-Time) compiler mode can significantly affect performance. BenchmarkDotNet supports testing with different JIT modes, such as LegacyJit and RyuJit, giving you the flexibility to optimize your code for specific .NET versions.
Example:
[SimpleJob(RuntimeMoniker.Net60, Jit = Jit.RyuJit)]
[SimpleJob(RuntimeMoniker.Net60, Jit = Jit.LegacyJit)]
public class MyBenchmark
{
[Benchmark]
public void MyTest()
{
// Code under test
}
}This example allows you to compare the performance of the same code using different JIT compilers, which can be critical for fine-tuning your application.
Customizing Output: Exporting Results and Visualizing Data
For easier analysis and integration into your development workflows, BenchmarkDotNet provides extensive options for customizing the output of your benchmark results.
Exporting Results to Different Formats
BenchmarkDotNet supports exporting results to various formats such as CSV, HTML, Markdown, and more. This makes it easier to analyze data, share results with your team, or include them in documentation.
Exporter examples:
[CsvExporter]
[HtmlExporter]
[MarkdownExporter]
public class MyBenchmark
{
[Benchmark]
public void MyTest()
{
// Code under test
}
}This code allows you to export benchmark results in CSV, HTML, and Markdown formats, making them accessible for different purposes.
Visualizing Data: Plots and Graphs
BenchmarkDotNet also supports generating plots and graphs to visually represent your benchmark results. Using RPlotExporter, you can create visualizations that are particularly helpful when comparing the performance of different methods.
Example:
[RPlotExporter]
public class MyBenchmark
{
[Params(10, 100, 1000)]
public int N;
[Benchmark]
public void MyTest()
{
// Code under test
}
}This example generates graphs that show how performance changes with different values of N, helping you quickly assess the efficiency of your code.
Memory Diagnostics: Analyzing Allocations and Garbage Collection Metrics
Efficient memory usage is a key factor in application performance. BenchmarkDotNet provides tools for detailed analysis of memory allocations and garbage collection (GC) behavior.
Analyzing Memory Allocations
By applying the MemoryDiagnoser attribute, you can gather detailed data about memory allocations during your benchmarks.
Example:
[MemoryDiagnoser]
public class MyBenchmark
{
[Benchmark]
public void MyTest()
{
var list = new List<int>();
for (int i = 0; i < 1000; i++)
{
list.Add(i);
}
}
}After running this benchmark, BenchmarkDotNet will generate a report containing information about the amount of memory allocated, the number of objects in each generation of the garbage collector, and other important metrics.
Garbage Collection Metrics
BenchmarkDotNet also provides data on garbage collection activity, including the number of collections in Gen 0, Gen 1, and Gen 2. This data helps you identify memory management issues and optimize your application.
Example report:
| Method | Mean | Error | StdDev | Gen 0 | Gen 1 | Gen 2 | Allocated |
|------------- |---------:|--------:|--------:|-------:|-------:|-------:|----------:|
| MyTest | 1.234 ms | 0.023 ms| 0.045 ms| 1000 | 20 | 5 | 100 KB |This report gives you a complete view of how your application uses memory and helps you identify potential bottlenecks related to frequent garbage collections.
BenchmarkDotNet is a powerful tool for analyzing and optimizing the performance of your .NET applications. Its capabilities for parameterized benchmarks, testing in different environments, customizing output, and memory diagnostics make it an indispensable resource for developers who are serious about improving the efficiency and reliability of their code. Whether you’re just starting with performance tuning or you’re a seasoned developer looking to fine-tune your applications, BenchmarkDotNet provides the insights you need to take your software to the next level. Start using BenchmarkDotNet today, and see the difference it can make in your development process.
