add ByType rule

Author: YegorStepanov

src/BenchmarkDotNet/Configs/BenchmarkLogicalGroupRule.cs

@@ -2,6 +2,6 @@
 {
     public enum BenchmarkLogicalGroupRule
     {
-        ByMethod, ByJob, ByParams, ByCategory
+        ByMethod, ByJob, ByParams, ByCategory, ByType
     }
 }

src/BenchmarkDotNet/Order/DefaultOrderer.cs

@@ -4,6 +4,7 @@
 using System.Diagnostics.CodeAnalysis;
 using System.Linq;
 using BenchmarkDotNet.Configs;
+using BenchmarkDotNet.Extensions;
 using BenchmarkDotNet.Jobs;
 using BenchmarkDotNet.Parameters;
 using BenchmarkDotNet.Reports;
@@ -20,7 +21,8 @@ public class DefaultOrderer : IOrderer
         private readonly IComparer<string[]> categoryComparer = CategoryComparer.Instance;
         private readonly IComparer<ParameterInstances> paramsComparer = ParameterComparer.Instance;
         private readonly IComparer<Job> jobComparer = JobComparer.Instance;
-        private readonly IComparer<Descriptor> targetComparer;
+        private readonly IComparer<Descriptor> typeComparer = TypeComparer.Instance;
+        private readonly IComparer<Descriptor> methodComparer;
 
         public SummaryOrderPolicy SummaryOrderPolicy { get; }
         public MethodOrderPolicy MethodOrderPolicy { get; }
@@ -31,15 +33,15 @@ public DefaultOrderer(
         {
             SummaryOrderPolicy = summaryOrderPolicy;
             MethodOrderPolicy = methodOrderPolicy;
-            targetComparer = new DescriptorComparer(methodOrderPolicy);
+            methodComparer = new MethodComparer(methodOrderPolicy);
         }
 
         [PublicAPI]
         public virtual IEnumerable<BenchmarkCase> GetExecutionOrder(
             ImmutableArray<BenchmarkCase> benchmarkCases,
             IEnumerable<BenchmarkLogicalGroupRule> order = null)
         {
-            var benchmarkComparer = new BenchmarkComparer(categoryComparer, paramsComparer, jobComparer, targetComparer, order);
+            var benchmarkComparer = new BenchmarkComparer(categoryComparer, paramsComparer, jobComparer, typeComparer, methodComparer, order);
             var list = benchmarkCases.ToList();
             list.Sort(benchmarkComparer);
             return list;
@@ -87,8 +89,15 @@ public string GetLogicalGroupKey(ImmutableArray<BenchmarkCase> allBenchmarksCase
         {
             var explicitRules = benchmarkCase.Config.GetLogicalGroupRules().ToList();
             var implicitRules = new List<BenchmarkLogicalGroupRule>();
+
+            bool hasMultipleTypes = allBenchmarksCases.DistinctBy(b => b.Descriptor.Type).Count() > 1;
             bool hasJobBaselines = allBenchmarksCases.Any(b => b.Job.Meta.Baseline);
             bool hasDescriptorBaselines = allBenchmarksCases.Any(b => b.Descriptor.Baseline);
+
+            if (hasMultipleTypes)
+            {
+                implicitRules.Add(BenchmarkLogicalGroupRule.ByType);
+            }
             if (hasJobBaselines)
             {
                 implicitRules.Add(BenchmarkLogicalGroupRule.ByParams);
@@ -114,8 +123,11 @@ public string GetLogicalGroupKey(ImmutableArray<BenchmarkCase> allBenchmarksCase
             {
                 switch (rule)
                 {
+                    case BenchmarkLogicalGroupRule.ByType:
+                        keys.Add(benchmarkCase.Descriptor.TypeInfo);
+                        break;
                     case BenchmarkLogicalGroupRule.ByMethod:
-                        keys.Add(benchmarkCase.Descriptor.DisplayInfo);
+                        keys.Add(benchmarkCase.Descriptor.WorkloadMethodDisplayInfo);
                         break;
                     case BenchmarkLogicalGroupRule.ByJob:
                         keys.Add(benchmarkCase.Job.DisplayInfo);
@@ -139,7 +151,7 @@ public virtual IEnumerable<IGrouping<string, BenchmarkCase>> GetLogicalGroupOrde
             IEnumerable<IGrouping<string, BenchmarkCase>> logicalGroups,
             IEnumerable<BenchmarkLogicalGroupRule> order = null)
         {
-            var benchmarkComparer = new BenchmarkComparer(categoryComparer, paramsComparer, jobComparer, targetComparer, order);
+            var benchmarkComparer = new BenchmarkComparer(categoryComparer, paramsComparer, jobComparer, typeComparer, methodComparer, order);
             var logicalGroupComparer = new LogicalGroupComparer(benchmarkComparer);
             var list = logicalGroups.ToList();
             list.Sort(logicalGroupComparer);
@@ -153,6 +165,7 @@ private class BenchmarkComparer : IComparer<BenchmarkCase>
             private static readonly BenchmarkLogicalGroupRule[] DefaultOrder =
             {
                 BenchmarkLogicalGroupRule.ByCategory,
+                BenchmarkLogicalGroupRule.ByType,
                 BenchmarkLogicalGroupRule.ByParams,
                 BenchmarkLogicalGroupRule.ByJob,
                 BenchmarkLogicalGroupRule.ByMethod
@@ -161,18 +174,21 @@ private class BenchmarkComparer : IComparer<BenchmarkCase>
             private readonly IComparer<string[]> categoryComparer;
             private readonly IComparer<ParameterInstances> paramsComparer;
             private readonly IComparer<Job> jobComparer;
-            private readonly IComparer<Descriptor> targetComparer;
+            private readonly IComparer<Descriptor> typeComparer;
+            private readonly IComparer<Descriptor> methodComparer;
             private readonly List<BenchmarkLogicalGroupRule> order;
 
             public BenchmarkComparer(
                 IComparer<string[]> categoryComparer,
                 IComparer<ParameterInstances> paramsComparer,
                 IComparer<Job> jobComparer,
-                IComparer<Descriptor> targetComparer,
+                IComparer<Descriptor> typeComparer,
+                IComparer<Descriptor> methodComparer,
                 IEnumerable<BenchmarkLogicalGroupRule> order)
             {
                 this.categoryComparer = categoryComparer;
-                this.targetComparer = targetComparer;
+                this.typeComparer = typeComparer;
+                this.methodComparer = methodComparer;
                 this.jobComparer = jobComparer;
                 this.paramsComparer = paramsComparer;
 
@@ -192,7 +208,8 @@ public int Compare(BenchmarkCase x, BenchmarkCase y)
                 {
                     int compare = rule switch
                     {
-                        BenchmarkLogicalGroupRule.ByMethod => targetComparer?.Compare(x.Descriptor, y.Descriptor) ?? 0,
+                        BenchmarkLogicalGroupRule.ByType => typeComparer?.Compare(x.Descriptor, y.Descriptor) ?? 0,
+                        BenchmarkLogicalGroupRule.ByMethod => methodComparer?.Compare(x.Descriptor, y.Descriptor) ?? 0,
                         BenchmarkLogicalGroupRule.ByJob => jobComparer?.Compare(x.Job, y.Job) ?? 0,
                         BenchmarkLogicalGroupRule.ByParams => paramsComparer?.Compare(x.Parameters, y.Parameters) ?? 0,
                         BenchmarkLogicalGroupRule.ByCategory => categoryComparer?.Compare(x.Descriptor.Categories, y.Descriptor.Categories) ?? 0,

src/BenchmarkDotNet/Running/DescriptorComparer.cs

@@ -5,14 +5,14 @@
 
 namespace BenchmarkDotNet.Running
 {
-    internal class DescriptorComparer : IComparer<Descriptor>
+    internal class MethodComparer : IComparer<Descriptor>
     {
-        [PublicAPI] public static readonly IComparer<Descriptor> Alphabetical = new DescriptorComparer(MethodOrderPolicy.Alphabetical);
-        [PublicAPI] public static readonly IComparer<Descriptor> Declared = new DescriptorComparer(MethodOrderPolicy.Declared);
+        [PublicAPI] public static readonly IComparer<Descriptor> Alphabetical = new MethodComparer(MethodOrderPolicy.Alphabetical);
+        [PublicAPI] public static readonly IComparer<Descriptor> Declared = new MethodComparer(MethodOrderPolicy.Declared);
 
         private readonly MethodOrderPolicy methodOrderPolicy;
 
-        public DescriptorComparer(MethodOrderPolicy methodOrderPolicy)
+        public MethodComparer(MethodOrderPolicy methodOrderPolicy)
         {
             this.methodOrderPolicy = methodOrderPolicy;
         }
@@ -25,7 +25,7 @@ public int Compare(Descriptor x, Descriptor y)
             switch (methodOrderPolicy)
             {
                 case MethodOrderPolicy.Alphabetical:
-                    return string.CompareOrdinal(x.DisplayInfo, y.DisplayInfo);
+                    return string.CompareOrdinal(x.WorkloadMethodDisplayInfo, y.WorkloadMethodDisplayInfo);
                 case MethodOrderPolicy.Declared:
                     return x.MethodIndex - y.MethodIndex;
                 default:

src/BenchmarkDotNet/Running/TypeComparer.cs

@@ -0,0 +1,17 @@
+using System.Collections.Generic;
+
+namespace BenchmarkDotNet.Running
+{
+    internal class TypeComparer : IComparer<Descriptor>
+    {
+        public static readonly IComparer<Descriptor> Instance = new TypeComparer();
+
+        public int Compare(Descriptor x, Descriptor y)
+        {
+            if (x == null && y == null) return 0;
+            if (x != null && y == null) return 1;
+            if (x == null) return -1;
+            return string.CompareOrdinal(x.TypeInfo, y.TypeInfo);
+        }
+    }
+}