PR feedback.

Author: timcassell

README.md

@@ -135,8 +135,8 @@ If you want to compare benchmarks with each other,
   mark one of the benchmarks as the [baseline](https://benchmarkdotnet.org/articles/features/baselines.html)
   via `[Benchmark(Baseline = true)]`: BenchmarkDotNet will compare it with all of the other benchmarks.
 If you want to compare performance in different environments, use [jobs](https://benchmarkdotnet.org/articles/configs/jobs.html).
-For example, you can run all the benchmarks on .NET Core 3.0 and Mono via
-  `[SimpleJob(RuntimeMoniker.NetCoreApp30)]` and `[SimpleJob(RuntimeMoniker.Mono)]`.
+For example, you can run all the benchmarks on .NET 8.0 and Mono via
+  `[SimpleJob(RuntimeMoniker.Net80)]` and `[SimpleJob(RuntimeMoniker.Mono)]`.
 
 If you don't like attributes, you can call most of the APIs via the fluent style and write code like this:
 

build/common.props

@@ -23,7 +23,7 @@
     <TreatWarningsAsErrors>true</TreatWarningsAsErrors>
 
     <Nullable>annotations</Nullable>
-    <!-- Suppress "System.Collections.Immutable 8.0.0 doesn't support netcoreapp3.1" warning -->
+    <!-- Suppress warning for nuget package used in old (unsupported) tfm. -->
     <SuppressTfmSupportBuildWarnings>true</SuppressTfmSupportBuildWarnings>
   </PropertyGroup>
 

docs/articles/configs/toolchains.md

@@ -18,23 +18,23 @@ When you run your benchmarks without specifying the toolchain in an explicit way
 If you want to test multiple frameworks, your project file **MUST target all of them** and you **MUST install the corresponding SDKs**:
 
 ```xml
-<TargetFrameworks>netcoreapp3.0;netcoreapp2.1;net48</TargetFrameworks>
+<TargetFrameworks>netcoreapp3.1;net8.0;net48</TargetFrameworks>
 ```
 
 If you run your benchmarks without specifying any custom settings, BenchmarkDotNet is going to run the benchmarks **using the same framework as the host process**:
 
 ```cmd
-dotnet run -c Release -f netcoreapp2.1 # is going to run the benchmarks using .NET Core 2.1
-dotnet run -c Release -f netcoreapp3.0 # is going to run the benchmarks using .NET Core 3.0
+dotnet run -c Release -f netcoreapp3.1 # is going to run the benchmarks using .NET Core 3.1
+dotnet run -c Release -f net8.0 # is going to run the benchmarks using .NET 8.0
 dotnet run -c Release -f net48         # is going to run the benchmarks using .NET 4.8
 mono $pathToExe                        # is going to run the benchmarks using Mono from your PATH
 ```
 
 To run the benchmarks for multiple runtimes with a single command, you need to specify the target framework moniker names via `--runtimes|-r` console argument:
 
 ```cmd
-dotnet run -c Release -f netcoreapp2.1 --runtimes netcoreapp2.1 netcoreapp3.0 # is going to run the benchmarks using .NET Core 2.1 and .NET Core 3.0
-dotnet run -c Release -f netcoreapp2.1 --runtimes netcoreapp2.1 net48         # is going to run the benchmarks using .NET Core 2.1 and .NET 4.8
+dotnet run -c Release -f net8.0 --runtimes net8.0 netcoreapp3.1 # is going to run the benchmarks using .NET 8.0 and .NET Core 3.1
+dotnet run -c Release -f net8.0 --runtimes net8.0 net48         # is going to run the benchmarks using .NET 8.0 and .NET 4.8
 ```
 
 What is going to happen if you provide multiple Full .NET Framework monikers? Let's say:
@@ -67,8 +67,8 @@ namespace BenchmarkDotNet.Samples
 {
     [SimpleJob(RuntimeMoniker.Net48)]
     [SimpleJob(RuntimeMoniker.Mono)]
-    [SimpleJob(RuntimeMoniker.NetCoreApp21)]
-    [SimpleJob(RuntimeMoniker.NetCoreApp30)]
+    [SimpleJob(RuntimeMoniker.NetCoreApp31)]
+    [SimpleJob(RuntimeMoniker.Net80)]
     public class TheClassWithBenchmarks
 ```
 
@@ -114,9 +114,9 @@ public class MyConfig : ManualConfig
         Add(Job.Default.With(
             CsProjCoreToolchain.From(
                 new NetCoreAppSettings(
-                    targetFrameworkMoniker: "netcoreapp2.1", 
-                    runtimeFrameworkVersion: "2.1.0-preview2-25628-01", 
-                    name: ".NET Core 2.1"))));
+                    targetFrameworkMoniker: "net8.0-windows",
+                    runtimeFrameworkVersion: "8.0.101",
+                    name: ".NET 8.0 Windows"))));
     }
 }
 ```
@@ -145,11 +145,11 @@ public class CustomPathsConfig : ManualConfig
     public CustomPathsConfig() 
     {
         var dotnetCli32bit = NetCoreAppSettings
-            .NetCoreApp20
+            .NetCoreApp31
             .WithCustomDotNetCliPath(@"C:\Program Files (x86)\dotnet\dotnet.exe", "32 bit cli");
 
         var dotnetCli64bit = NetCoreAppSettings
-            .NetCoreApp20
+            .NetCoreApp31
             .WithCustomDotNetCliPath(@"C:\Program Files\dotnet\dotnet.exe", "64 bit cli");
 
         AddJob(Job.RyuJitX86.WithToolchain(CsProjCoreToolchain.From(dotnetCli32bit)).WithId("32 bit cli"));

docs/articles/guides/console-args.md

@@ -117,29 +117,29 @@ You can also filter the benchmarks by categories:
 The `--runtimes` or just `-r` allows you to run the benchmarks for selected Runtimes. Available options are:
 
 * Clr - BDN will either use Roslyn (if you run it as .NET app) or latest installed .NET SDK to build the benchmarks (if you run it as .NET Core app).
-* Core - if you run it as .NET Core app, BDN will use the same target framework moniker, if you run it as .NET app it's going to use netcoreapp2.1.
+* Core - if you run it as .NET Core app, BDN will use the same target framework moniker, if you run it as .NET app it's going to use net8.0.
 * Mono - it's going to use the Mono from `$Path`, you can override  it with `--monoPath`.
 * net46, net461, net462, net47, net471, net472, net48, net481 - to build and run benchmarks against specific .NET Framework version.
-* netcoreapp2.0, netcoreapp2.1, netcoreapp2.2, netcoreapp3.0, netcoreapp3.1, net5.0, net6.0, net7.0, net8.0, net9.0 - to build and run benchmarks against specific .NET (Core) version.
+* netcoreapp3.1, net5.0, net6.0, net7.0, net8.0 - to build and run benchmarks against specific .NET (Core) version.
 * nativeaot5.0, nativeaot6.0, nativeaot7.0, nativeaot8.0 - to build and run benchmarks using NativeAOT. Can be customized with additional options: `--ilcPackages`, `--ilCompilerVersion`.
 * mono6.0, mono7.0, mono8.0 - to build and run benchmarks with .Net 6+ using MonoVM.
 
-Example: run the benchmarks for .NET 4.7.2 and .NET Core 2.1:
+Example: run the benchmarks for .NET 4.7.2 and .NET 8.0:
 
 ```log
-dotnet run -c Release -- --runtimes net472 netcoreapp2.1
+dotnet run -c Release -- --runtimes net472 net8.0
 ```
 
-Example: run the benchmarks for .NET Core 3.0 and latest .NET SDK installed on your PC:
+Example: run the benchmarks for .NET Core 3.1 and latest .NET SDK installed on your PC:
 
 ```log
-dotnet run -c Release -f netcoreapp3.0 -- --runtimes clr core
+dotnet run -c Release -f netcoreapp3.1 -- --runtimes clr core
 ```
 
-But same command executed with `-f netcoreapp2.0` is going to run the benchmarks for .NET Core 2.0:
+But same command executed with `-f net6.0` is going to run the benchmarks for .NET 6.0:
 
 ```log
-dotnet run -c Release -f netcoreapp2.0 -- --runtimes clr core
+dotnet run -c Release -f net6.0 -- --runtimes clr core
 ```
 
 ## Number of invocations and iterations
@@ -208,10 +208,10 @@ To perform a Mann–Whitney U Test and display the results in a dedicated column
 
 * `--statisticalTest`- Threshold for Mann–Whitney U Test. Examples: 5%, 10ms, 100ns, 1s
 
-Example: run Mann–Whitney U test with relative ratio of 5% for all benchmarks for .NET Core 2.0 (base) vs .NET Core 2.1 (diff). .NET Core 2.0 will be baseline because it was first.
+Example: run Mann–Whitney U test with relative ratio of 5% for all benchmarks for .NET 6.0 (base) vs .NET 8.0 (diff). .NET 6.0 will be baseline because it was first.
 
 ```log
-dotnet run -c Release -- --filter * --runtimes netcoreapp2.0 netcoreapp2.1 --statisticalTest 5%
+dotnet run -c Release -- --filter * --runtimes net6.0 net8.0 --statisticalTest 5%
 ```
 
 ## More

src/BenchmarkDotNet/ConsoleArguments/CommandLineOptions.cs

@@ -237,8 +237,8 @@ public static IEnumerable<Example> Examples
 
                 yield return new Example("Use Job.ShortRun for running the benchmarks", shortName, new CommandLineOptions { BaseJob = "short" });
                 yield return new Example("Run benchmarks in process", shortName, new CommandLineOptions { RunInProcess = true });
-                yield return new Example("Run benchmarks for .NET 4.7.2, .NET Core 2.1 and Mono. .NET 4.7.2 will be baseline because it was first.", longName, new CommandLineOptions { Runtimes = new[] { "net472", "netcoreapp2.1", "Mono" } });
-                yield return new Example("Run benchmarks for .NET Core 2.0, .NET Core 2.1 and .NET Core 2.2. .NET Core 2.0 will be baseline because it was first.", longName, new CommandLineOptions { Runtimes = new[] { "netcoreapp2.0", "netcoreapp2.1", "netcoreapp2.2" } });
+                yield return new Example("Run benchmarks for .NET 4.7.2, .NET 8.0 and Mono. .NET 4.7.2 will be baseline because it was first.", longName, new CommandLineOptions { Runtimes = new[] { "net472", "net8.0", "Mono" } });
+                yield return new Example("Run benchmarks for .NET Core 3.1, .NET 6.0 and .NET 8.0. .NET Core 3.1 will be baseline because it was first.", longName, new CommandLineOptions { Runtimes = new[] { "netcoreapp3.1", "net6.0", "net8.0" } });
                 yield return new Example("Use MemoryDiagnoser to get GC stats", shortName, new CommandLineOptions { UseMemoryDiagnoser = true });
                 yield return new Example("Use DisassemblyDiagnoser to get disassembly", shortName, new CommandLineOptions { UseDisassemblyDiagnoser = true });
                 yield return new Example("Use HardwareCountersDiagnoser to get hardware counter info", longName, new CommandLineOptions { HardwareCounters = new[] { nameof(HardwareCounter.CacheMisses), nameof(HardwareCounter.InstructionRetired) } });
@@ -250,8 +250,8 @@ public static IEnumerable<Example> Examples
                 yield return new Example("Run selected benchmarks once per iteration", longName, new CommandLineOptions { RunOncePerIteration = true });
                 yield return new Example("Run selected benchmarks 100 times per iteration. Perform single warmup iteration and 5 actual workload iterations", longName, new CommandLineOptions { InvocationCount = 100, WarmupIterationCount = 1, IterationCount = 5});
                 yield return new Example("Run selected benchmarks 250ms per iteration. Perform from 9 to 15 iterations", longName, new CommandLineOptions { IterationTimeInMilliseconds = 250, MinIterationCount = 9, MaxIterationCount = 15});
-                yield return new Example("Run MannWhitney test with relative ratio of 5% for all benchmarks for .NET Core 2.0 (base) vs .NET Core 2.1 (diff). .NET Core 2.0 will be baseline because it was provided as first.", longName,
-                    new CommandLineOptions { Filters = new[] { "*"}, Runtimes = new[] { "netcoreapp2.0", "netcoreapp2.1" }, StatisticalTestThreshold = "5%" });
+                yield return new Example("Run MannWhitney test with relative ratio of 5% for all benchmarks for .NET 6.0 (base) vs .NET 8.0 (diff). .NET Core 6.0 will be baseline because it was provided as first.", longName,
+                    new CommandLineOptions { Filters = new[] { "*"}, Runtimes = new[] { "net6.0", "net8.0" }, StatisticalTestThreshold = "5%" });
                 yield return new Example("Run benchmarks using environment variables 'ENV_VAR_KEY_1' with value 'value_1' and 'ENV_VAR_KEY_2' with value 'value_2'", longName,
                     new CommandLineOptions { EnvironmentVariables = new[] { "ENV_VAR_KEY_1:value_1", "ENV_VAR_KEY_2:value_2" } });
                 yield return new Example("Hide Mean and Ratio columns (use double quotes for multi-word columns: \"Alloc Ratio\")", shortName, new CommandLineOptions { HiddenColumns = new[] { "Mean", "Ratio" }, });

src/BenchmarkDotNet/Templates/CsProj.txt

@@ -26,7 +26,7 @@
     <AppendTargetFrameworkToOutputPath>true</AppendTargetFrameworkToOutputPath>
     <!-- fix for NETSDK1150: https://docs.microsoft.com/en-us/dotnet/core/compatibility/sdk/5.0/referencing-executable-generates-error -->
     <ValidateExecutableReferencesMatchSelfContained>false</ValidateExecutableReferencesMatchSelfContained>
-    <!-- fix System.Runtime.CompilerServices.Unsafe doesn't support netcoreapp2.0 -->
+    <!-- Suppress warning for nuget package used in old (unsupported) tfm. -->
     <SuppressTfmSupportBuildWarnings>true</SuppressTfmSupportBuildWarnings>
     <StartupObject>BenchmarkDotNet.Autogenerated.UniqueProgramName</StartupObject>
   </PropertyGroup>

src/BenchmarkDotNet/Templates/MonoAOTLLVMCsProj.txt

@@ -20,7 +20,7 @@
     <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
     <StartupObject>BenchmarkDotNet.Autogenerated.UniqueProgramName</StartupObject>
     <SelfContained>true</SelfContained>
-    <!-- fix System.Runtime.CompilerServices.Unsafe doesn't support netcoreapp2.0 -->
+    <!-- Suppress warning for nuget package used in old (unsupported) tfm. -->
     <SuppressTfmSupportBuildWarnings>true</SuppressTfmSupportBuildWarnings>
   </PropertyGroup>
 

src/BenchmarkDotNet/Templates/WasmCsProj.txt

@@ -26,7 +26,7 @@
     <ErrorOnDuplicatePublishOutputFiles>false</ErrorOnDuplicatePublishOutputFiles>
     <ValidateExecutableReferencesMatchSelfContained>false</ValidateExecutableReferencesMatchSelfContained>
     <EnableDefaultWasmAssembliesToBundle>false</EnableDefaultWasmAssembliesToBundle>
-    <!-- fix System.Runtime.CompilerServices.Unsafe doesn't support netcoreapp2.0 -->
+    <!-- Suppress warning for nuget package used in old (unsupported) tfm. -->
     <SuppressTfmSupportBuildWarnings>true</SuppressTfmSupportBuildWarnings>
     <StartupObject>BenchmarkDotNet.Autogenerated.UniqueProgramName</StartupObject>
   </PropertyGroup>

src/BenchmarkDotNet/Toolchains/CoreRun/CoreRunToolchain.cs

@@ -15,12 +15,12 @@ public class CoreRunToolchain : IToolchain
         /// </summary>
         /// <param name="coreRun">the path to CoreRun</param>
         /// /<param name="createCopy">should a copy of CoreRun be performed? True by default. <remarks>The toolchain replaces old dependencies in CoreRun folder with newer versions if used by the benchmarks.</remarks></param>
-        /// <param name="targetFrameworkMoniker">TFM, netcoreapp2.1 is the default</param>
+        /// <param name="targetFrameworkMoniker">TFM, net8.0 is the default</param>
         /// <param name="customDotNetCliPath">path to dotnet cli, if not provided the one from PATH will be used</param>
         /// <param name="displayName">display name, CoreRun is the default value</param>
         /// <param name="restorePath">the directory to restore packages to</param>
         public CoreRunToolchain(FileInfo coreRun, bool createCopy = true,
-            string targetFrameworkMoniker = "netcoreapp2.1",
+            string targetFrameworkMoniker = "net8.0",
             FileInfo? customDotNetCliPath = null, DirectoryInfo? restorePath = null,
             string displayName = "CoreRun")
         {

src/BenchmarkDotNet/Toolchains/NativeAot/Generator.cs

@@ -143,7 +143,7 @@ private string GenerateProjectForNuGetBuild(BuildPartition buildPartition, Artif
     <EnsureNETCoreAppRuntime>false</EnsureNETCoreAppRuntime> <!-- workaround for 'This runtime may not be supported by.NET Core.' error -->
     <ErrorOnDuplicatePublishOutputFiles>false</ErrorOnDuplicatePublishOutputFiles> <!-- workaround for 'Found multiple publish output files with the same relative path.' error -->
     <ValidateExecutableReferencesMatchSelfContained>false</ValidateExecutableReferencesMatchSelfContained>
-    <SuppressTfmSupportBuildWarnings>true</SuppressTfmSupportBuildWarnings> <!-- fix System.Runtime.CompilerServices.Unsafe doesn't support netcoreapp2.0 -->
+    <SuppressTfmSupportBuildWarnings>true</SuppressTfmSupportBuildWarnings> <!-- Suppress warning for nuget package used in old (unsupported) tfm. -->
     {GetInstructionSetSettings(buildPartition)}
   </PropertyGroup>
   {GetRuntimeSettings(buildPartition.RepresentativeBenchmarkCase.Job.Environment.Gc, buildPartition.Resolver)}

tests/BenchmarkDotNet.IntegrationTests.ManualRunning/LocalNativeAotToolchainTests.cs

@@ -13,7 +13,7 @@ namespace BenchmarkDotNet.IntegrationTests.ManualRunning
     /// to run these tests please clone and build NativeAOT first,
     /// then update the hardcoded path
     /// and run following command from console:
-    /// dotnet test -c Release -f netcoreapp2.1 --filter "FullyQualifiedName~BenchmarkDotNet.IntegrationTests.ManualRunning.LocalNativeAotToolchainTests"
+    /// dotnet test -c Release -f net8.0 --filter "FullyQualifiedName~BenchmarkDotNet.IntegrationTests.ManualRunning.LocalNativeAotToolchainTests"
     ///
     /// in perfect world we would do this OOB for you, but building NativeAOT
     /// so it's not part of our CI jobs
@@ -29,7 +29,7 @@ public void CanBenchmarkLocalBuildUsingRyuJit()
         {
             var config = ManualConfig.CreateEmpty()
                 .AddJob(Job.Dry
-                    .WithRuntime(NativeAotRuntime.Net60)
+                    .WithRuntime(NativeAotRuntime.Net80)
                     .WithToolchain(
                         NativeAotToolchain.CreateBuilder()
                             .UseLocalBuild(new System.IO.DirectoryInfo(IlcPath))

tests/BenchmarkDotNet.Tests/ConfigParserTests.cs

@@ -275,6 +275,12 @@ public void IlCompilerPathParsedCorrectly()
         [InlineData("netcoreapp2.1", true)]
         [InlineData("netcoreapp2.2", true)]
         [InlineData("netcoreapp3.0", true)]
+        [InlineData("netcoreapp3.1", true)]
+        [InlineData("net5.0", true)]
+        [InlineData("net6.0", true)]
+        [InlineData("net7.0", true)]
+        [InlineData("net8.0", true)]
+        [InlineData("net9.0", true)]
         [InlineData("net462", false)]
         [InlineData("net48", false)]
         public void DotNetCliParsedCorrectly(string tfm, bool isCore)

tests/BenchmarkDotNet.Tests/RuntimeVersionDetectionTests.cs

@@ -18,6 +18,10 @@ public class RuntimeVersionDetectionTests
         [InlineData(".NETCoreApp,Version=v3.0", RuntimeMoniker.NetCoreApp30, "netcoreapp3.0")]
         [InlineData(".NETCoreApp,Version=v3.1", RuntimeMoniker.NetCoreApp31, "netcoreapp3.1")]
         [InlineData(".NETCoreApp,Version=v5.0", RuntimeMoniker.Net50, "net5.0")]
+        [InlineData(".NETCoreApp,Version=v6.0", RuntimeMoniker.Net60, "net6.0")]
+        [InlineData(".NETCoreApp,Version=v7.0", RuntimeMoniker.Net70, "net7.0")]
+        [InlineData(".NETCoreApp,Version=v8.0", RuntimeMoniker.Net80, "net8.0")]
+        [InlineData(".NETCoreApp,Version=v9.0", RuntimeMoniker.Net90, "net9.0")]
         [InlineData(".NETCoreApp,Version=v123.0", RuntimeMoniker.NotRecognized, "net123.0")]
         public void TryGetVersionFromFrameworkNameHandlesValidInput(string frameworkName, RuntimeMoniker expectedTfm, string expectedMsBuildMoniker)
         {
@@ -125,6 +129,8 @@ public void CurrentRuntimeIsProperlyRecognized()
             Assert.True(runtime is CoreRuntime coreRuntime && coreRuntime.RuntimeMoniker == RuntimeMoniker.NetCoreApp31);
 #elif NETCOREAPP5_0
             Assert.True(runtime is CoreRuntime coreRuntime && coreRuntime.RuntimeMoniker == RuntimeMoniker.NetCoreApp50);
+#elif NET8_0
+            Assert.True(runtime is CoreRuntime coreRuntime && coreRuntime.RuntimeMoniker == RuntimeMoniker.Net80);
 #endif
         }
     }

tests/runCoreTests.cmd

@@ -12,24 +12,24 @@ if NOT %ERRORLEVEL% == 0 (
 )
 
 echo -----------------------------
-echo Running Core 2.1 Unit tests
+echo Running Core 8.0 Unit tests
 echo -----------------------------
 
-call dotnet test "BenchmarkDotNet.Tests\BenchmarkDotNet.Tests.csproj" --configuration Release --framework netcoreapp2.1
+call dotnet test "BenchmarkDotNet.Tests\BenchmarkDotNet.Tests.csproj" --configuration Release --framework net8.0
 
 if NOT %ERRORLEVEL% == 0 (
-    echo CORE 2.1 Unit tests has failed
+    echo Core 8.0 Unit tests has failed
     goto end
 )
 
 echo -----------------------------
-echo Running Core 2.1 Integration tests
+echo Running 8.0 Integration tests
 echo -----------------------------
 
-call dotnet test "BenchmarkDotNet.IntegrationTests\BenchmarkDotNet.IntegrationTests.csproj" --configuration Release --framework netcoreapp2.1
+call dotnet test "BenchmarkDotNet.IntegrationTests\BenchmarkDotNet.IntegrationTests.csproj" --configuration Release --framework net8.0
 
 if NOT %ERRORLEVEL% == 0 (
-    echo CORE 2.1 Integration tests has failed
+    echo Core 8.0 Integration tests has failed
     goto end
 )