chore: moves policies to own directory

Signed-off-by: Vincent Biret <[email protected]>

Author: baywet

performance/resultsComparer/Program.cs

@@ -2,6 +2,7 @@
 using System.CommandLine;
 using Microsoft.Extensions.Logging;
 using resultsComparer.Handlers;
+using resultsComparer.Policies;
 
 namespace resultsComparer;
 
@@ -26,11 +27,18 @@ internal static RootCommand CreateRootCommand()
         compareCommand.AddArgument(newResultsPathArgument);
         var logLevelOption = new Option<LogLevel>(["--log-level", "-l"], () => LogLevel.Warning, "The log level to use.");
         compareCommand.AddOption(logLevelOption);
+        var allPolicyNames = IBenchmarkComparisonPolicy.GetAllPolicies().Select(static p => p.Name).Order(StringComparer.OrdinalIgnoreCase).ToArray();
+        var policiesOption = new Option<string[]>(["--policies", "-p"], () => ["all"], $"The policies to use for comparison: {string.Join(',', allPolicyNames)}.")
+        {
+            Arity = ArgumentArity.ZeroOrMore
+        };
+        compareCommand.AddOption(policiesOption);
         compareCommand.Handler = new CompareCommandHandler
         {
             OldResultsPath = oldResultsPathArgument,
             NewResultsPath = newResultsPathArgument,
-            LogLevel = logLevelOption
+            LogLevel = logLevelOption,
+            Policies = policiesOption,
         };
         rootCommand.Add(compareCommand);
         return rootCommand;

performance/resultsComparer/handlers/CompareCommandHandler.cs

@@ -6,6 +6,7 @@
 using Microsoft.Extensions.DependencyInjection;
 using Microsoft.Extensions.Logging;
 using resultsComparer.Models;
+using resultsComparer.Policies;
 
 namespace resultsComparer.Handlers;
 
@@ -14,18 +15,21 @@ internal class CompareCommandHandler : AsyncCommandHandler
     public required Argument<string> OldResultsPath { get; set; }
     public required Argument<string> NewResultsPath { get; set; }
     public required Option<LogLevel> LogLevel { get; set; }
+    public required Option<string[]> Policies { get; set; }
 
     public override Task<int> InvokeAsync(InvocationContext context)
     {
         var cancellationToken = context.BindingContext.GetRequiredService<CancellationToken>();
         var oldResultsPath = context.ParseResult.GetValueForArgument(OldResultsPath);
         var newResultsPath = context.ParseResult.GetValueForArgument(NewResultsPath);
+        var policyNames = context.ParseResult.GetValueForOption(Policies) ?? [];
+        var policies = IBenchmarkComparisonPolicy.GetSelectedPolicies(policyNames).ToArray();
         var logLevel = context.ParseResult.GetValueForOption(LogLevel);
         using var loggerFactory = Logger.ConfigureLogger(logLevel);
         var logger = loggerFactory.CreateLogger<CompareCommandHandler>();
-        return CompareResultsAsync(oldResultsPath, newResultsPath, logger, cancellationToken);
+        return CompareResultsAsync(oldResultsPath, newResultsPath, logger, policies, cancellationToken);
     }
-    private static async Task<int> CompareResultsAsync(string existingReportPath, string newReportPath, ILogger logger, CancellationToken cancellationToken = default)
+    private static async Task<int> CompareResultsAsync(string existingReportPath, string newReportPath, ILogger logger, IBenchmarkComparisonPolicy[] comparisonPolicies, CancellationToken cancellationToken = default)
     {
 
         var existingBenchmark = await GetBenchmarksAllocatedBytes(existingReportPath, cancellationToken);
@@ -40,9 +44,6 @@ private static async Task<int> CompareResultsAsync(string existingReportPath, st
             logger.LogError("No new benchmark data found.");
             return 1;
         }
-        IBenchmarkComparisonPolicy[] comparisonPolicies = [
-            MemoryBenchmarkResultComparer.Instance
-        ];
         var hasErrors = false;
         foreach (var existingBenchmarkResult in existingBenchmark)
         {
@@ -88,29 +89,6 @@ private static async Task<int> CompareResultsAsync(string existingReportPath, st
             .ToDictionary(x => x.Method!, x => x.Memory!, StringComparer.OrdinalIgnoreCase);
     }
     private static readonly BenchmarkSourceGenerationContext serializationContext = new();
-
-    private interface IBenchmarkComparisonPolicy : IEqualityComparer<BenchmarkMemory>
-    {
-        string GetErrorMessage(BenchmarkMemory? x, BenchmarkMemory? y);
-    }
-    private sealed class MemoryBenchmarkResultComparer : IBenchmarkComparisonPolicy
-    {
-        public static MemoryBenchmarkResultComparer Instance { get; } = new MemoryBenchmarkResultComparer();
-        public bool Equals(BenchmarkMemory? x, BenchmarkMemory? y)
-        {
-            return x?.AllocatedBytes == y?.AllocatedBytes;
-        }
-
-        public string GetErrorMessage(BenchmarkMemory? x, BenchmarkMemory? y)
-        {
-            return $"Allocated bytes differ: {x?.AllocatedBytes} != {y?.AllocatedBytes}";
-        }
-
-        public int GetHashCode(BenchmarkMemory obj)
-        {
-            return obj.AllocatedBytes.GetHashCode();
-        }
-    }
 }
 
 [JsonSerializable(typeof(BenchmarkReport))]

performance/resultsComparer/policies/IBenchmarkComparisonPolicy.cs

@@ -0,0 +1,32 @@
+using resultsComparer.Models;
+
+namespace resultsComparer.Policies;
+
+internal interface IBenchmarkComparisonPolicy : IEqualityComparer<BenchmarkMemory>
+{
+    string GetErrorMessage(BenchmarkMemory? x, BenchmarkMemory? y);
+    string Name { get;}
+    public static IEnumerable<IBenchmarkComparisonPolicy> GetSelectedPolicies(string[] names)
+    {
+        if (names is [])
+        {
+            yield break;
+        }
+        if (names is ["all"])
+        {
+            foreach (var policy in GetAllPolicies())
+            {
+                yield return policy;
+            }
+        }
+        var indexedNames = names.ToHashSet(StringComparer.OrdinalIgnoreCase);
+        if (indexedNames.Contains(nameof(IdenticalMemoryUsagePolicy)))
+        {
+            yield return IdenticalMemoryUsagePolicy.Instance;
+        }
+    }
+    public static IBenchmarkComparisonPolicy[] GetAllPolicies()
+    {
+        return [IdenticalMemoryUsagePolicy.Instance];
+    }
+}

performance/resultsComparer/policies/IdenticalMemoryUsagePolicy.cs

@@ -0,0 +1,22 @@
+using resultsComparer.Models;
+
+namespace resultsComparer.Policies;
+internal sealed class IdenticalMemoryUsagePolicy : IBenchmarkComparisonPolicy
+{
+    public static IdenticalMemoryUsagePolicy Instance { get; } = new IdenticalMemoryUsagePolicy();
+    public string Name => nameof(IdenticalMemoryUsagePolicy);
+    public bool Equals(BenchmarkMemory? x, BenchmarkMemory? y)
+    {
+        return x?.AllocatedBytes == y?.AllocatedBytes;
+    }
+
+    public string GetErrorMessage(BenchmarkMemory? x, BenchmarkMemory? y)
+    {
+        return $"Allocated bytes differ: {x?.AllocatedBytes} != {y?.AllocatedBytes}";
+    }
+
+    public int GetHashCode(BenchmarkMemory obj)
+    {
+        return obj.AllocatedBytes.GetHashCode();
+    }
+}