Fix async GlobalSetup/GlobalCleanup not being awaited with InProcessEmit toolchain.

Author: timcassell

src/BenchmarkDotNet/Toolchains/InProcess.Emit.Implementation/Emitters/RunnableEmitter.cs

@@ -245,6 +245,10 @@ private static void EmitNoArgsMethodCallPopReturn(
  private TypeBuilder runnableBuilder;
  private ConsumableTypeInfo consumableInfo;
  private ConsumeEmitter consumeEmitter;
+ private ConsumableTypeInfo globalSetupReturnInfo;
+ private ConsumableTypeInfo globalCleanupReturnInfo;
+ private ConsumableTypeInfo iterationSetupReturnInfo;
+ private ConsumableTypeInfo iterationCleanupReturnInfo;
 
  private FieldBuilder awaitHelperField;
  private FieldBuilder globalSetupActionField;
@@ -358,13 +362,22 @@ private void InitForEmitRunnable(BenchmarkBuildInfo newBenchmark)
 
  consumableInfo = new ConsumableTypeInfo(benchmark.BenchmarkCase.Descriptor.WorkloadMethod.ReturnType);
  consumeEmitter = ConsumeEmitter.GetConsumeEmitter(consumableInfo);
+ globalSetupReturnInfo = GetConsumableTypeInfo(benchmark.BenchmarkCase.Descriptor.GlobalSetupMethod?.ReturnType);
+ globalCleanupReturnInfo = GetConsumableTypeInfo(benchmark.BenchmarkCase.Descriptor.GlobalCleanupMethod?.ReturnType);
+ iterationSetupReturnInfo = GetConsumableTypeInfo(benchmark.BenchmarkCase.Descriptor.IterationSetupMethod?.ReturnType);
+ iterationCleanupReturnInfo = GetConsumableTypeInfo(benchmark.BenchmarkCase.Descriptor.IterationCleanupMethod?.ReturnType);
 
  // Init types
  runnableBuilder = DefineRunnableTypeBuilder(benchmark, moduleBuilder);
  overheadDelegateType = EmitOverheadDelegateType();
  workloadDelegateType = EmitWorkloadDelegateType();
  }
 
+ private static ConsumableTypeInfo GetConsumableTypeInfo(Type methodReturnType)
+ {
+ return methodReturnType == null ? null : new ConsumableTypeInfo(methodReturnType);
+ }
+
  private Type EmitOverheadDelegateType()
  {
  // .class public auto ansi sealed BenchmarkDotNet.Autogenerated.Runnable_0OverheadDelegate
@@ -908,34 +921,89 @@ private void EmitSetupCleanupMethods()
  {
  // Emit Setup/Cleanup methods
  // We emit empty method instead of EmptyAction = "() => { }"
- globalSetupMethod = EmitWrapperMethod(
- GlobalSetupMethodName,
- Descriptor.GlobalSetupMethod);
- globalCleanupMethod = EmitWrapperMethod(
- GlobalCleanupMethodName,
- Descriptor.GlobalCleanupMethod);
- iterationSetupMethod = EmitWrapperMethod(
- IterationSetupMethodName,
- Descriptor.IterationSetupMethod);
- iterationCleanupMethod = EmitWrapperMethod(
- IterationCleanupMethodName,
- Descriptor.IterationCleanupMethod);
+ globalSetupMethod = EmitWrapperMethod(GlobalSetupMethodName, Descriptor.GlobalSetupMethod, globalSetupReturnInfo);
+ globalCleanupMethod = EmitWrapperMethod(GlobalCleanupMethodName, Descriptor.GlobalCleanupMethod, globalCleanupReturnInfo);
+ iterationSetupMethod = EmitWrapperMethod(IterationSetupMethodName, Descriptor.IterationSetupMethod, iterationSetupReturnInfo);
+ iterationCleanupMethod = EmitWrapperMethod(IterationCleanupMethodName, Descriptor.IterationCleanupMethod, iterationCleanupReturnInfo);
  }
 
- private MethodBuilder EmitWrapperMethod(string methodName, MethodInfo optionalTargetMethod)
+ private MethodBuilder EmitWrapperMethod(string methodName, MethodInfo optionalTargetMethod, ConsumableTypeInfo returnTypeInfo)
  {
  var methodBuilder = runnableBuilder.DefinePrivateVoidInstanceMethod(methodName);
 
  var ilBuilder = methodBuilder.GetILGenerator();
 
  if (optionalTargetMethod != null)
- EmitNoArgsMethodCallPopReturn(methodBuilder, optionalTargetMethod, ilBuilder, forceDirectCall: true);
+ {
+ if (returnTypeInfo?.IsAwaitable == true)
+ {
+ EmitAwaitableSetupTeardown(methodBuilder, optionalTargetMethod, ilBuilder, returnTypeInfo);
+ }
+ else
+ {
+ EmitNoArgsMethodCallPopReturn(methodBuilder, optionalTargetMethod, ilBuilder, forceDirectCall: true);
+ }
+ }
 
  ilBuilder.EmitVoidReturn(methodBuilder);
 
  return methodBuilder;
  }
 
+ private void EmitAwaitableSetupTeardown(
+ MethodBuilder methodBuilder,
+ MethodInfo targetMethod,
+ ILGenerator ilBuilder,
+ ConsumableTypeInfo returnTypeInfo)
+ {
+ if (targetMethod == null)
+ throw new ArgumentNullException(nameof(targetMethod));
+
+ if (returnTypeInfo.WorkloadMethodReturnType == typeof(void))
+ {
+ ilBuilder.Emit(OpCodes.Ldarg_0);
+ }
+ /*
+ IL_0000: ldarg.0
+ IL_0001: ldfld class BenchmarkDotNet.Helpers.AwaitHelper BenchmarkDotNet.Helpers.Runnable_0::awaitHelper
+ */
+ ilBuilder.Emit(OpCodes.Ldarg_0);
+ ilBuilder.Emit(OpCodes.Ldfld, awaitHelperField);
+ /*
+ // call for instance
+ // GlobalSetup();
+ IL_0006: ldarg.0
+ IL_0007: call instance void [BenchmarkDotNet]BenchmarkDotNet.Samples.SampleBenchmark::GlobalSetup()
+ */
+ /*
+ // call for static
+ // GlobalSetup();
+ IL_0006: call string [BenchmarkDotNet]BenchmarkDotNet.Samples.SampleBenchmark::GlobalCleanup()
+ */
+ if (targetMethod.IsStatic)
+ {
+ ilBuilder.Emit(OpCodes.Call, targetMethod);
+
+ }
+ else if (methodBuilder.IsStatic)
+ {
+ throw new InvalidOperationException(
+ $"[BUG] Static method {methodBuilder.Name} tries to call instance member {targetMethod.Name}");
+ }
+ else
+ {
+ ilBuilder.Emit(OpCodes.Ldarg_0);
+ ilBuilder.Emit(OpCodes.Call, targetMethod);
+ }
+
+ /*
+ // awaitHelper.GetResult(...);
+ IL_000e: callvirt instance void BenchmarkDotNet.Helpers.AwaitHelper::GetResult(class [System.Private.CoreLib]System.Threading.Tasks.Task)
+ */
+ ilBuilder.Emit(OpCodes.Callvirt, returnTypeInfo.GetResultMethod);
+ ilBuilder.Emit(OpCodes.Pop);
+ }
+
  private void EmitCtorBody()
  {
  var ilBuilder = ctorMethod.GetILGenerator();

tests/BenchmarkDotNet.IntegrationTests/BenchmarkTestExecutor.cs

@@ -49,7 +49,7 @@ public Reports.Summary CanExecute<TBenchmark>(IConfig config = null, bool fullVa
  /// <param name="config">Optional custom config to be used instead of the default</param>
  /// <param name="fullValidation">Optional: disable validation (default = true/enabled)</param>
  /// <returns>The summary from the benchmark run</returns>
- protected Reports.Summary CanExecute(Type type, IConfig config = null, bool fullValidation = true)
+ public Reports.Summary CanExecute(Type type, IConfig config = null, bool fullValidation = true)
  {
  // Add logging, so the Benchmark execution is in the TestRunner output (makes Debugging easier)
  if (config == null)

tests/BenchmarkDotNet.IntegrationTests/InProcessEmitTest.cs

@@ -235,35 +235,123 @@ public static ValueTask<decimal> InvokeOnceStaticValueTaskOfT()
  }
  }
 
- [Fact]
- public void InProcessEmitToolchainSupportsIterationSetupAndCleanup()
+ [Theory]
+ [InlineData(typeof(IterationSetupCleanup))]
+ [InlineData(typeof(GlobalSetupCleanupTask))]
+ [InlineData(typeof(GlobalSetupCleanupValueTask))]
+ [InlineData(typeof(GlobalSetupCleanupValueTaskSource))]
+ public void InProcessEmitToolchainSupportsSetupAndCleanup(Type benchmarkType)
  {
  var logger = new OutputLogger(Output);
  var config = CreateInProcessConfig(logger);
 
- WithIterationSetupAndCleanup.SetupCounter = 0;
- WithIterationSetupAndCleanup.BenchmarkCounter = 0;
- WithIterationSetupAndCleanup.CleanupCounter = 0;
+ Counters.SetupCounter = 0;
+ Counters.BenchmarkCounter = 0;
+ Counters.CleanupCounter = 0;
 
- var summary = CanExecute<WithIterationSetupAndCleanup>(config);
+ var summary = CanExecute(benchmarkType, config);
 
- Assert.Equal(1, WithIterationSetupAndCleanup.SetupCounter);
- Assert.Equal(16, WithIterationSetupAndCleanup.BenchmarkCounter);
- Assert.Equal(1, WithIterationSetupAndCleanup.CleanupCounter);
+ Assert.Equal(1, Counters.SetupCounter);
+ Assert.Equal(16, Counters.BenchmarkCounter);
+ Assert.Equal(1, Counters.CleanupCounter);
  }
 
- public class WithIterationSetupAndCleanup
+ private static class Counters
  {
  public static int SetupCounter, BenchmarkCounter, CleanupCounter;
+ }
 
+ public class IterationSetupCleanup
+ {
  [IterationSetup]
- public void Setup() => Interlocked.Increment(ref SetupCounter);
+ public void Setup() => Interlocked.Increment(ref Counters.SetupCounter);
 
  [Benchmark]
- public void Benchmark() => Interlocked.Increment(ref BenchmarkCounter);
+ public void Benchmark() => Interlocked.Increment(ref Counters.BenchmarkCounter);
 
  [IterationCleanup]
- public void Cleanup() => Interlocked.Increment(ref CleanupCounter);
+ public void Cleanup() => Interlocked.Increment(ref Counters.CleanupCounter);
+ }
+
+ public class GlobalSetupCleanupTask
+ {
+ [GlobalSetup]
+ public static async Task GlobalSetup()
+ {
+ await Task.Yield();
+ Interlocked.Increment(ref Counters.SetupCounter);
+ }
+
+ [GlobalCleanup]
+ public async Task GlobalCleanup()
+ {
+ await Task.Yield();
+ Interlocked.Increment(ref Counters.CleanupCounter);
+ }
+
+ [Benchmark]
+ public void InvokeOnceVoid()
+ {
+ Interlocked.Increment(ref Counters.BenchmarkCounter);
+ }
+ }
+
+ public class GlobalSetupCleanupValueTask
+ {
+ [GlobalSetup]
+ public static async ValueTask GlobalSetup()
+ {
+ await Task.Yield();
+ Interlocked.Increment(ref Counters.SetupCounter);
+ }
+
+ [GlobalCleanup]
+ public async ValueTask GlobalCleanup()
+ {
+ await Task.Yield();
+ Interlocked.Increment(ref Counters.CleanupCounter);
+ }
+
+ [Benchmark]
+ public void InvokeOnceVoid()
+ {
+ Interlocked.Increment(ref Counters.BenchmarkCounter);
+ }
+ }
+
+ public class GlobalSetupCleanupValueTaskSource
+ {
+ private readonly static ValueTaskSource<int> valueTaskSource = new ();
+
+ [GlobalSetup]
+ public static ValueTask GlobalSetup()
+ {
+ valueTaskSource.Reset();
+ Task.Delay(1).ContinueWith(_ =>
+ {
+ Interlocked.Increment(ref Counters.SetupCounter);
+ valueTaskSource.SetResult(42);
+ });
+ return new ValueTask(valueTaskSource, valueTaskSource.Token);
+ }
+
+ [GlobalCleanup]
+ public ValueTask GlobalCleanup()
+ {
+ valueTaskSource.Reset();
+ Task.Delay(1).ContinueWith(_ =>
+ {
+ Interlocked.Increment(ref Counters.CleanupCounter);
+ valueTaskSource.SetResult(42);
+ });
+ return new ValueTask(valueTaskSource, valueTaskSource.Token);
+ }
+
+ [Benchmark]
+ public void InvokeOnceVoid()
+ {
+ Interlocked.Increment(ref Counters.BenchmarkCounter);
+ }
  }
  }
 }