Call benchmark method directly

src/BenchmarkDotNet/Code/CodeGenerator.cs

@@ -45,7 +45,6 @@ internal static string Generate(BuildPartition buildPartition)
                     .Replace("$ID$", buildInfo.Id.ToString())
                     .Replace("$OperationsPerInvoke$", provider.OperationsPerInvoke)
                     .Replace("$WorkloadTypeName$", provider.WorkloadTypeName)
-                    .Replace("$WorkloadMethodDelegate$", provider.WorkloadMethodDelegate(passArguments))
                     .Replace("$WorkloadMethodReturnType$", provider.WorkloadMethodReturnTypeName)
                     .Replace("$WorkloadMethodReturnTypeModifiers$", provider.WorkloadMethodReturnTypeModifiers)
                     .Replace("$OverheadMethodReturnTypeName$", provider.OverheadMethodReturnTypeName)

src/BenchmarkDotNet/Code/DeclarationsProvider.cs

@@ -36,8 +36,6 @@ internal abstract class DeclarationsProvider
 
         public virtual string WorkloadMethodReturnTypeName => WorkloadMethodReturnType.GetCorrectCSharpTypeName();
 
-        public virtual string WorkloadMethodDelegate(string passArguments) => Descriptor.WorkloadMethod.Name;
-
         public virtual string WorkloadMethodReturnTypeModifiers => null;
 
         public virtual string GetWorkloadMethodCall(string passArguments) => $"{Descriptor.WorkloadMethod.Name}({passArguments})";
@@ -149,9 +147,6 @@ internal class TaskDeclarationsProvider : VoidDeclarationsProvider
     {
         public TaskDeclarationsProvider(Descriptor descriptor) : base(descriptor) { }
 
-        public override string WorkloadMethodDelegate(string passArguments)
-            => $"({passArguments}) => {{ BenchmarkDotNet.Helpers.AwaitHelper.GetResult({Descriptor.WorkloadMethod.Name}({passArguments})); }}";
-
         public override string GetWorkloadMethodCall(string passArguments) => $"BenchmarkDotNet.Helpers.AwaitHelper.GetResult({Descriptor.WorkloadMethod.Name}({passArguments}))";
 
         protected override Type WorkloadMethodReturnType => typeof(void);
@@ -166,9 +161,6 @@ public GenericTaskDeclarationsProvider(Descriptor descriptor) : base(descriptor)
 
         protected override Type WorkloadMethodReturnType => Descriptor.WorkloadMethod.ReturnType.GetTypeInfo().GetGenericArguments().Single();
 
-        public override string WorkloadMethodDelegate(string passArguments)
-            => $"({passArguments}) => {{ return BenchmarkDotNet.Helpers.AwaitHelper.GetResult({Descriptor.WorkloadMethod.Name}({passArguments})); }}";
-
         public override string GetWorkloadMethodCall(string passArguments) => $"BenchmarkDotNet.Helpers.AwaitHelper.GetResult({Descriptor.WorkloadMethod.Name}({passArguments}))";
     }
 }

src/BenchmarkDotNet/Helpers/Reflection.Emit/IlGeneratorEmitOpExtensions.cs

@@ -116,6 +116,22 @@ public static void EmitLdarg(this ILGenerator ilBuilder, ParameterInfo argument)
             }
         }
 
+        public static void EmitStarg(this ILGenerator ilBuilder, ParameterInfo argument)
+        {
+            var position = argument.Position;
+            if (!((MethodBase) argument.Member).IsStatic)
+                position++;
+
+            if (position < 255)
+            {
+                ilBuilder.Emit(OpCodes.Starg_S, (byte) position);
+            }
+            else
+            {
+                ilBuilder.Emit(OpCodes.Starg, checked((short) position));
+            }
+        }
+
         public static void EmitLdindStind(this ILGenerator ilBuilder, Type resultType)
         {
             if (!resultType.IsByRef)

src/BenchmarkDotNet/Helpers/Reflection.Emit/IlGeneratorStatementExtensions.cs

@@ -84,64 +84,55 @@ public static void EmitSetDelegateToThisField(
             }
         }
 
-        public static void EmitLoopBeginFromLocToArg(
+        public static void EmitLoopBeginFromArgToZero(
             this ILGenerator ilBuilder,
             Label loopStartLabel,
-            Label loopHeadLabel,
-            LocalBuilder indexLocal,
-            ParameterInfo toArg)
+            Label loopHeadLabel)
         {
-            // loop counter stored as loc0, loop max passed as arg1
+            // invokeCount passed as arg
             /*
-                // for (long i = 0L; i < invokeCount; i++)
-                IL_0000: ldc.i4.0
-                IL_0001: conv.i8
-                IL_0002: stloc.0
+                // while (--invokeCount >= 0)
             */
-            ilBuilder.Emit(OpCodes.Ldc_I4_0);
-            ilBuilder.Emit(OpCodes.Conv_I8);
-            ilBuilder.EmitStloc(indexLocal);
 
-            // IL_0003: br.s IL_0036 // loop head: IL_0036 // we use long jump
+            // IL_0000: br.s IL_000e // loop head: IL_000e // we use long jump
             ilBuilder.Emit(OpCodes.Br, loopHeadLabel);
 
-            // loop start (head: IL_0036)
+            // loop start (head: IL_000e)
             ilBuilder.MarkLabel(loopStartLabel);
         }
 
-        public static void EmitLoopEndFromLocToArg(
+        public static void EmitLoopEndFromArgToZero(
             this ILGenerator ilBuilder,
             Label loopStartLabel,
             Label loopHeadLabel,
-            LocalBuilder indexLocal,
-            ParameterInfo toArg)
+            ParameterInfo arg)
         {
-            // loop counter stored as loc0, loop max passed as arg1
+            // invokeCount passed as arg
             /*
-                // for (long i = 0L; i < invokeCount; i++)
-                IL_0031: ldloc.0
-                IL_0032: ldc.i4.1
-                IL_0033: conv.i8
-                IL_0034: add
-                IL_0035: stloc.0
-             */
-            ilBuilder.EmitLdloc(indexLocal);
-            ilBuilder.Emit(OpCodes.Ldc_I4_1);
-            ilBuilder.Emit(OpCodes.Conv_I8);
-            ilBuilder.Emit(OpCodes.Add);
-            ilBuilder.EmitStloc(indexLocal);
-
-            /*
-                // for (long i = 0L; i < invokeCount; i++)
-                IL_0036: ldloc.0 // loop head: IL_0036
-                IL_0037: ldarg.1
-                IL_0038: blt.s IL_0005 // we use long jump
+                // while (--invokeCount >= 0)
+                IL_0008: ldarg.1
+                IL_0009: ldc.i4.1
+                IL_000a: conv.i8
+                IL_000b: sub
+                IL_000c: dup
+                IL_000d: starg.s invokeCount
+                IL_000f: ldc.i4.0
+                IL_0010: conv.i8
+                IL_0011: bge.s IL_0002
                 // end loop
              */
+
+            // loop head
             ilBuilder.MarkLabel(loopHeadLabel);
-            ilBuilder.EmitLdloc(indexLocal);
-            ilBuilder.EmitLdarg(toArg);
-            ilBuilder.Emit(OpCodes.Blt, loopStartLabel);
+            ilBuilder.EmitLdarg(arg);
+            ilBuilder.Emit(OpCodes.Ldc_I4_1);
+            ilBuilder.Emit(OpCodes.Conv_I8);
+            ilBuilder.Emit(OpCodes.Sub);
+            ilBuilder.Emit(OpCodes.Dup);
+            ilBuilder.EmitStarg(arg);
+            ilBuilder.Emit(OpCodes.Ldc_I4_0);
+            ilBuilder.Emit(OpCodes.Conv_I8);
+            ilBuilder.Emit(OpCodes.Bge, loopStartLabel);
         }
     }
 }

src/BenchmarkDotNet/Helpers/Reflection.Emit/MethodBuilderExtensions.cs

@@ -38,13 +38,5 @@ public static MethodBuilder SetNoOptimizationImplementationFlag(this MethodBuild
 
             return methodBuilder;
         }
-
-        public static MethodBuilder SetAggressiveOptimizationImplementationFlag(this MethodBuilder methodBuilder)
-        {
-            methodBuilder.SetImplementationFlags(
-                methodBuilder.GetMethodImplementationFlags() | CodeGenHelper.AggressiveOptimizationOptionForEmit);
-
-            return methodBuilder;
-        }
     }
 }

src/BenchmarkDotNet/Portability/CodeGen.cs

@@ -7,6 +7,5 @@ public static class CodeGenHelper
     {
         // AggressiveOptimization is not available in netstandard2.0, so just use the value casted to enum.
         public const MethodImplOptions AggressiveOptimizationOption = (MethodImplOptions) 512;
-        public const MethodImplAttributes AggressiveOptimizationOptionForEmit = (MethodImplAttributes) 512;
     }
 }