Only do an extra WorkloadAction measurement if totalOperations > 1.

Author: timcassell

src/BenchmarkDotNet/Engines/Engine.cs

@@ -19,7 +19,7 @@ public class Engine : IEngine
 
         [PublicAPI] public IHost Host { get; }
         [PublicAPI] public Action<long> WorkloadAction { get; }
-        [PublicAPI] public Action WorkloadActionSingleInvoke { get; }
+        [PublicAPI] public Action<long> WorkloadActionNoUnroll { get; }
         [PublicAPI] public Action Dummy1Action { get; }
         [PublicAPI] public Action Dummy2Action { get; }
         [PublicAPI] public Action Dummy3Action { get; }
@@ -54,13 +54,13 @@ public class Engine : IEngine
         internal Engine(
             IHost host,
             IResolver resolver,
-            Action dummy1Action, Action dummy2Action, Action dummy3Action, Action<long> overheadAction, Action<long> workloadAction, Action workloadActionSingleInvoke, Job targetJob,
+            Action dummy1Action, Action dummy2Action, Action dummy3Action, Action<long> overheadAction, Action<long> workloadAction, Action<long> workloadActionNoUnroll, Job targetJob,
             Action globalSetupAction, Action globalCleanupAction, Action iterationSetupAction, Action iterationCleanupAction, long operationsPerInvoke,
             bool includeExtraStats, bool includeSurvivedMemory, string benchmarkName)
         {
             Host = host;
             OverheadAction = overheadAction;
-            WorkloadActionSingleInvoke = workloadActionSingleInvoke;
+            WorkloadActionNoUnroll = workloadActionNoUnroll;
             Dummy1Action = dummy1Action;
             Dummy2Action = dummy2Action;
             Dummy3Action = dummy3Action;
@@ -96,7 +96,7 @@ internal Engine(
                 // Measure bytes to allow GC monitor to make its allocations.
                 GetTotalBytes();
                 // Run the clock once to allow it to make its allocations.
-                MeasureAction(() => { });
+                MeasureAction(_ => { }, 0);
                 GetTotalBytes();
             }
         }
@@ -197,32 +197,46 @@ public Measurement RunIteration(IterationData data)
             bool isOverhead = data.IterationMode == IterationMode.Overhead;
             var action = isOverhead ? OverheadAction : WorkloadAction;
 
-            double nanoseconds = 0;
             if (!isOverhead)
             {
                 IterationSetupAction();
+            }
+
+            GcCollect();
+
+            if (EngineEventSource.Log.IsEnabled())
+                EngineEventSource.Log.IterationStart(data.IterationMode, data.IterationStage, totalOperations);
 
-                if (includeSurvivedMemory && !survivedBytesMeasured)
+            bool needsSurvivedMeasurement = includeSurvivedMemory && !isOverhead && !survivedBytesMeasured;
+            double nanoseconds;
+            if (needsSurvivedMeasurement)
+            {
+                // Measure survived bytes for only the first invocation.
+                survivedBytesMeasured = true;
+                if (totalOperations == 1)
                 {
-                    // Measure survived bytes for only the first invocation.
-                    survivedBytesMeasured = true;
+                    // Measure normal invocation for both survived memory and time.
+                    long beforeBytes = GetTotalBytes();
+                    nanoseconds = MeasureAction(action, invokeCount / unrollFactor);
+                    long afterBytes = GetTotalBytes();
+                    survivedBytes = afterBytes - beforeBytes;
+                }
+                else
+                {
+                    // Measure a single invocation for survived memory, plus normal invocations for time.
                     ++totalOperations;
                     long beforeBytes = GetTotalBytes();
-                    nanoseconds = MeasureAction(WorkloadActionSingleInvoke);
+                    nanoseconds = MeasureAction(WorkloadActionNoUnroll, 1);
                     long afterBytes = GetTotalBytes();
                     survivedBytes = afterBytes - beforeBytes;
+                    nanoseconds += MeasureAction(action, invokeCount / unrollFactor);
                 }
             }
-
-            GcCollect();
-
-            if (EngineEventSource.Log.IsEnabled())
-                EngineEventSource.Log.IterationStart(data.IterationMode, data.IterationStage, totalOperations);
-
-            // Measure
-            var clock = Clock.Start();
-            action(invokeCount / unrollFactor);
-            nanoseconds += clock.GetElapsed().GetNanoseconds();
+            else
+            {
+                // Measure time normally.
+                nanoseconds = MeasureAction(action, invokeCount / unrollFactor);
+            }
 
             if (EngineEventSource.Log.IsEnabled())
                 EngineEventSource.Log.IterationStop(data.IterationMode, data.IterationStage, totalOperations);
@@ -241,10 +255,10 @@ public Measurement RunIteration(IterationData data)
 
         // This is necessary for the CORE runtime to clean up the memory from the clock.
         [MethodImpl(MethodImplOptions.NoInlining)]
-        private double MeasureAction(Action action)
+        private double MeasureAction(Action<long> action, long arg)
         {
             var clock = Clock.Start();
-            action();
+            action(arg);
             return clock.GetElapsed().GetNanoseconds();
         }
 

src/BenchmarkDotNet/Engines/EngineFactory.cs

@@ -112,7 +112,7 @@ private static Engine CreateEngine(EngineParameters engineParameters, Job job, A
                 engineParameters.Dummy3Action,
                 idle,
                 main,
-                () => engineParameters.WorkloadActionNoUnroll(1),
+                engineParameters.WorkloadActionNoUnroll,
                 job,
                 engineParameters.GlobalSetupAction,
                 engineParameters.GlobalCleanupAction,