IBenchmarkActionFactory for InProcessNoEmitToolchain (#3063)

* `IBenchmarkActionFactory` for `InProcessNoEmitToolchain`

* Account for unrollfactor.

* Make benchmark actions public.

Author: timcassell

src/BenchmarkDotNet/Toolchains/InProcess/NoEmit/BenchmarkAction.cs

@@ -0,0 +1,67 @@
+using BenchmarkDotNet.Extensions;
+using Perfolizer.Horology;
+using System.Reflection;
+
+namespace BenchmarkDotNet.Toolchains.InProcess.NoEmit;
+
+/*
+    Design goals of the whole stuff:
+    0. Reusable API to call Setup/Clean/Overhead/Workload actions with arbitrary return value and store the result.
+        Supported ones are: void, T, Task, Task<T>, ValueTask<T>. No input args.
+    1. Overhead signature should match to the benchmark method signature (including static/instance modifier).
+    2. Should work under .Net native. Uses Delegate.Combine instead of emitting the code.
+    3. High data locality and no additional allocations / JIT where possible.
+        This means NO closures allowed, no allocations but in .ctor,
+        all state should be stored explicitly as BenchmarkFunc's fields.
+    4. There can be multiple benchmark actions per single target instance (workload, globalSetup, globalCleanup methods),
+        so target instantiation is not a responsibility of the benchmark action.
+    5. Implementation should match to the code in BenchmarkProgram.txt.
+ */
+
+// DONTTOUCH: Be VERY CAREFUL when changing the code.
+// Please, ensure that the implementation is in sync with content of BenchmarkType.txt
+/// <summary>Base class that provides reusable API for final implementations.</summary>
+public abstract class BenchmarkActionBase : IBenchmarkAction
+{
+    public required Func<ValueTask> InvokeSingle { get; init; }
+    public required Func<long, IClock, ValueTask<ClockSpan>> InvokeUnroll { get; init; }
+    public required Func<long, IClock, ValueTask<ClockSpan>> InvokeNoUnroll { get; init; }
+    public abstract void Complete();
+
+    protected static TDelegate CreateWorkload<TDelegate>(object? targetInstance, MethodInfo workloadMethod) where TDelegate : Delegate
+        => workloadMethod.IsStatic
+            ? workloadMethod.CreateDelegate<TDelegate>()
+            : workloadMethod.CreateDelegate<TDelegate>(targetInstance);
+
+    private protected Action CreateWorkloadOrOverhead(object? instance, MethodInfo? method)
+    {
+        if (method == null)
+        {
+            return instance == null ? OverheadStatic : OverheadInstance;
+        }
+        return method.IsStatic
+            ? method.CreateDelegate<Action>()
+            : method.CreateDelegate<Action>(instance);
+    }
+
+    protected static TDelegate Unroll<TDelegate>(TDelegate callback, int unrollFactor)
+         where TDelegate : notnull, Delegate
+    {
+        if (unrollFactor <= 1)
+        {
+            return callback;
+        }
+
+        var delegates = new Delegate[unrollFactor];
+        for (int i = 0; i < unrollFactor; i++)
+        {
+            delegates[i] = callback;
+        }
+
+        return (TDelegate) Delegate.Combine(delegates)!;
+    }
+
+    // must be kept in sync with Runnable_X.__Overhead
+    internal static void OverheadStatic() { }
+    private void OverheadInstance() { }
+}

src/BenchmarkDotNet/Toolchains/InProcess/NoEmit/BenchmarkActionBase.cs

@@ -1,28 +1,24 @@
-using BenchmarkDotNet.Extensions;
+using BenchmarkDotNet.Extensions;
 using BenchmarkDotNet.Running;
 using System.Reflection;
 using System.Runtime.CompilerServices;
 
 namespace BenchmarkDotNet.Toolchains.InProcess.NoEmit;
 
-internal static partial class BenchmarkActionFactory
+internal static class BenchmarkActionFactory
 {
-    /// <summary>
-    /// Dispatch method that creates <see cref="BenchmarkAction"/> using
-    /// <paramref name="targetMethod"/> or <paramref name="fallbackIdleSignature"/> to find correct implementation.
-    /// Either <paramref name="targetMethod"/> or <paramref name="fallbackIdleSignature"/> should be not <c>null</c>.
-    /// </summary>
-    private static BenchmarkAction CreateCore(object instance, MethodInfo? targetMethod, MethodInfo? fallbackIdleSignature, int unrollFactor)
+    private static IBenchmarkAction CreateCore(IBenchmarkActionFactory? factory, object instance, MethodInfo targetMethod, int unrollFactor)
     {
-        PrepareInstanceAndResultType(instance, targetMethod, fallbackIdleSignature, out var resultInstance, out var resultType);
+        if (factory?.TryCreate(instance, targetMethod, unrollFactor, out var benchmarkAction) == true)
+        {
+            return benchmarkAction;
+        }
+
+        PrepareInstanceAndResultType(instance, targetMethod, out var resultInstance, out var resultType);
 
         if (resultType == typeof(void))
             return new BenchmarkActionVoid(resultInstance, targetMethod, unrollFactor);
 
-        // targetMethod must not be null here. Because it's checked by PrepareInstanceAndResultType.
-        // Following null check is added to suppress nullable annotation errors.
-        ArgumentNullException.ThrowIfNull(targetMethod);
-
         if (resultType == typeof(void*))
             return new BenchmarkActionVoidPointer(resultInstance, targetMethod, unrollFactor);
 
@@ -71,7 +67,7 @@ private static BenchmarkAction CreateCore(object instance, MethodInfo? targetMet
 
         if (resultType.IsAwaitable())
         {
-            throw new NotSupportedException($"{nameof(InProcessNoEmitToolchain)} does not support returning awaitable types except (Value)Task(<T>).");
+            throw new NotSupportedException($"Default {nameof(BenchmarkActionFactory)} does not support returning awaitable types except (Value)Task(<T>).");
         }
 
         return Create(
@@ -81,21 +77,10 @@ private static BenchmarkAction CreateCore(object instance, MethodInfo? targetMet
             unrollFactor);
     }
 
-    private static void PrepareInstanceAndResultType(object instance, MethodInfo? targetMethod, MethodInfo? fallbackIdleSignature, out object? resultInstance, out Type resultType)
+    private static void PrepareInstanceAndResultType(object instance, MethodInfo targetMethod, out object? resultInstance, out Type resultType)
     {
-        var signature = targetMethod ?? fallbackIdleSignature;
-        if (signature == null)
-            throw new ArgumentNullException(
-                nameof(fallbackIdleSignature),
-                $"Either {nameof(targetMethod)} or  {nameof(fallbackIdleSignature)} should be not null.");
-
-        if (!signature.IsStatic && instance == null)
-            throw new ArgumentNullException(
-                nameof(instance),
-                $"The {nameof(instance)} parameter should be not null as invocation method is instance method.");
-
-        resultInstance = signature.IsStatic ? null : instance;
-        resultType = signature.ReturnType;
+        resultInstance = targetMethod.IsStatic ? null : instance;
+        resultType = targetMethod.ReturnType;
 
         if (resultType == typeof(void))
         {
@@ -107,32 +92,31 @@ private static void PrepareInstanceAndResultType(object instance, MethodInfo? ta
         }
         else if (resultType.IsPointer && resultType != typeof(void*))
         {
-            throw new NotSupportedException("InProcessNoEmitToolchain only supports void* return, not T*");
+            throw new NotSupportedException($"Default {nameof(BenchmarkActionFactory)} only supports void* return, not T*");
         }
     }
 
     /// <summary>Helper to enforce .ctor signature.</summary>
     private static BenchmarkActionBase Create(Type actionType, object? instance, MethodInfo method, int unrollFactor) =>
         (BenchmarkActionBase)Activator.CreateInstance(actionType, instance, method, unrollFactor)!;
 
-    private static void FallbackMethod() { }
-    private static readonly MethodInfo FallbackSignature = new Action(FallbackMethod).GetMethodInfo();
+    private static readonly MethodInfo FallbackSignature = new Action(BenchmarkActionBase.OverheadStatic).GetMethodInfo();
 
-    public static BenchmarkAction CreateWorkload(Descriptor descriptor, object instance, int unrollFactor) =>
-        CreateCore(instance, descriptor.WorkloadMethod, null, unrollFactor);
+    public static IBenchmarkAction CreateWorkload(IBenchmarkActionFactory? factory, Descriptor descriptor, object instance, int unrollFactor) =>
+        CreateCore(factory, instance, descriptor.WorkloadMethod, unrollFactor);
 
-    public static BenchmarkAction CreateOverhead(Descriptor descriptor, object instance, int unrollFactor) =>
-        CreateCore(instance, null, FallbackSignature, unrollFactor);
+    public static IBenchmarkAction CreateOverhead(IBenchmarkActionFactory? factory, Descriptor descriptor, object instance, int unrollFactor) =>
+        CreateCore(factory, instance, FallbackSignature, unrollFactor);
 
-    public static BenchmarkAction CreateGlobalSetup(Descriptor descriptor, object instance) =>
-        CreateCore(instance, descriptor.GlobalSetupMethod, FallbackSignature, 1);
+    public static IBenchmarkAction CreateGlobalSetup(IBenchmarkActionFactory? factory, Descriptor descriptor, object instance) =>
+        CreateCore(factory, instance, descriptor.GlobalSetupMethod ?? FallbackSignature, 1);
 
-    public static BenchmarkAction CreateGlobalCleanup(Descriptor descriptor, object instance) =>
-        CreateCore(instance, descriptor.GlobalCleanupMethod, FallbackSignature, 1);
+    public static IBenchmarkAction CreateGlobalCleanup(IBenchmarkActionFactory? factory, Descriptor descriptor, object instance) =>
+        CreateCore(factory, instance, descriptor.GlobalCleanupMethod ?? FallbackSignature, 1);
 
-    public static BenchmarkAction CreateIterationSetup(Descriptor descriptor, object instance) =>
-        CreateCore(instance, descriptor.IterationSetupMethod, FallbackSignature, 1);
+    public static IBenchmarkAction CreateIterationSetup(IBenchmarkActionFactory? factory, Descriptor descriptor, object instance) =>
+        CreateCore(factory, instance, descriptor.IterationSetupMethod ?? FallbackSignature, 1);
 
-    public static BenchmarkAction CreateIterationCleanup(Descriptor descriptor, object instance) =>
-        CreateCore(instance, descriptor.IterationCleanupMethod, FallbackSignature, 1);
+    public static IBenchmarkAction CreateIterationCleanup(IBenchmarkActionFactory? factory, Descriptor descriptor, object instance) =>
+        CreateCore(factory, instance, descriptor.IterationCleanupMethod ?? FallbackSignature, 1);
 }