Fixed InProcess (no emit) async tests.

timcassell · timcassell · commit 3d1d955471eb · 2022-03-26T21:45:36.000-04:00
diff --git a/src/BenchmarkDotNet/Toolchains/InProcess.NoEmit/BenchmarkActionFactory_Implementations.cs b/src/BenchmarkDotNet/Toolchains/InProcess.NoEmit/BenchmarkActionFactory_Implementations.cs
@@ -134,15 +134,15 @@ public BenchmarkActionTask(object instance, MethodInfo method, int unrollFactor)
 
             private ValueTask InvokeSingleHardcodedOverhead()
             {
-                InvokeNoUnrollHardcodedOverhead(1, null);
+                callback();
                 return new ValueTask();
             }
 
             private ValueTask<ClockSpan> InvokeNoUnrollHardcodedOverhead(long repeatCount, IClock clock)
             {
                 repeatsRemaining = repeatCount;
                 Task value = default;
-                startedClock = clock?.Start() ?? default;
+                startedClock = clock.Start();
                 try
                 {
                     while (--repeatsRemaining >= 0)
@@ -160,15 +160,14 @@ private ValueTask<ClockSpan> InvokeNoUnrollHardcodedOverhead(long repeatCount, I
 
             private ValueTask InvokeSingleHardcoded()
             {
-                InvokeNoUnrollHardcoded(1, null);
-                return new ValueTask(valueTaskSource, valueTaskSource.Version);
+                return AwaitHelper.ToValueTaskVoid(callback());
             }
 
             private ValueTask<ClockSpan> InvokeNoUnrollHardcoded(long repeatCount, IClock clock)
             {
                 repeatsRemaining = repeatCount;
                 valueTaskSource.Reset();
-                startedClock = clock?.Start() ?? default;
+                startedClock = clock.Start();
                 RunTask();
                 return new ValueTask<ClockSpan>(valueTaskSource, valueTaskSource.Version);
             }
@@ -253,15 +252,15 @@ public BenchmarkActionTask(object instance, MethodInfo method, int unrollFactor)
 
             private ValueTask InvokeSingleHardcodedOverhead()
             {
-                InvokeNoUnrollHardcodedOverhead(1, null);
+                callback();
                 return new ValueTask();
             }
 
             private ValueTask<ClockSpan> InvokeNoUnrollHardcodedOverhead(long repeatCount, IClock clock)
             {
                 repeatsRemaining = repeatCount;
                 Task<T> value = default;
-                startedClock = clock?.Start() ?? default;
+                startedClock = clock.Start();
                 try
                 {
                     while (--repeatsRemaining >= 0)
@@ -279,15 +278,14 @@ private ValueTask<ClockSpan> InvokeNoUnrollHardcodedOverhead(long repeatCount, I
 
             private ValueTask InvokeSingleHardcoded()
             {
-                InvokeNoUnrollHardcoded(1, null);
-                return new ValueTask(valueTaskSource, valueTaskSource.Version);
+                return AwaitHelper.ToValueTaskVoid(callback());
             }
 
             private ValueTask<ClockSpan> InvokeNoUnrollHardcoded(long repeatCount, IClock clock)
             {
                 repeatsRemaining = repeatCount;
                 valueTaskSource.Reset();
-                startedClock = clock?.Start() ?? default;
+                startedClock = clock.Start();
                 RunTask();
                 return new ValueTask<ClockSpan>(valueTaskSource, valueTaskSource.Version);
             }
@@ -373,15 +371,15 @@ public BenchmarkActionValueTask(object instance, MethodInfo method, int unrollFa
 
             private ValueTask InvokeSingleHardcodedOverhead()
             {
-                InvokeNoUnrollHardcodedOverhead(1, null);
+                callback();
                 return new ValueTask();
             }
 
             private ValueTask<ClockSpan> InvokeNoUnrollHardcodedOverhead(long repeatCount, IClock clock)
             {
                 repeatsRemaining = repeatCount;
                 ValueTask value = default;
-                startedClock = clock?.Start() ?? default;
+                startedClock = clock.Start();
                 try
                 {
                     while (--repeatsRemaining >= 0)
@@ -399,15 +397,14 @@ private ValueTask<ClockSpan> InvokeNoUnrollHardcodedOverhead(long repeatCount, I
 
             private ValueTask InvokeSingleHardcoded()
             {
-                InvokeNoUnrollHardcoded(1, null);
-                return new ValueTask(valueTaskSource, valueTaskSource.Version);
+                return AwaitHelper.ToValueTaskVoid(callback());
             }
 
             private ValueTask<ClockSpan> InvokeNoUnrollHardcoded(long repeatCount, IClock clock)
             {
                 repeatsRemaining = repeatCount;
                 valueTaskSource.Reset();
-                startedClock = clock?.Start() ?? default;
+                startedClock = clock.Start();
                 RunTask();
                 return new ValueTask<ClockSpan>(valueTaskSource, valueTaskSource.Version);
             }
@@ -492,15 +489,15 @@ public BenchmarkActionValueTask(object instance, MethodInfo method, int unrollFa
 
             private ValueTask InvokeSingleHardcodedOverhead()
             {
-                InvokeNoUnrollHardcodedOverhead(1, null);
+                callback();
                 return new ValueTask();
             }
 
             private ValueTask<ClockSpan> InvokeNoUnrollHardcodedOverhead(long repeatCount, IClock clock)
             {
                 repeatsRemaining = repeatCount;
                 ValueTask<T> value = default;
-                startedClock = clock?.Start() ?? default;
+                startedClock = clock.Start();
                 try
                 {
                     while (--repeatsRemaining >= 0)
@@ -518,15 +515,14 @@ private ValueTask<ClockSpan> InvokeNoUnrollHardcodedOverhead(long repeatCount, I
 
             private ValueTask InvokeSingleHardcoded()
             {
-                InvokeNoUnrollHardcoded(1, null);
-                return new ValueTask(valueTaskSource, valueTaskSource.Version);
+                return AwaitHelper.ToValueTaskVoid(callback());
             }
 
             private ValueTask<ClockSpan> InvokeNoUnrollHardcoded(long repeatCount, IClock clock)
             {
                 repeatsRemaining = repeatCount;
                 valueTaskSource.Reset();
-                startedClock = clock?.Start() ?? default;
+                startedClock = clock.Start();
                 RunTask();
                 return new ValueTask<ClockSpan>(valueTaskSource, valueTaskSource.Version);
             }
diff --git a/src/BenchmarkDotNet/Toolchains/InProcess/BenchmarkActionFactory_Implementations.cs b/src/BenchmarkDotNet/Toolchains/InProcess/BenchmarkActionFactory_Implementations.cs
@@ -166,14 +166,14 @@ public BenchmarkActionTask(object instance, MethodInfo method, BenchmarkActionCo
 
             private ValueTask InvokeSingleHardcodedOverhead()
             {
-                InvokeNoUnrollHardcodedOverhead(1, null);
+                callback();
                 return new ValueTask();
             }
 
             private ValueTask<ClockSpan> InvokeNoUnrollHardcodedOverhead(long repeatCount, IClock clock)
             {
                 repeatsRemaining = repeatCount;
-                startedClock = clock?.Start() ?? default;
+                startedClock = clock.Start();
                 try
                 {
                     while (--repeatsRemaining >= 0)
@@ -190,15 +190,14 @@ private ValueTask<ClockSpan> InvokeNoUnrollHardcodedOverhead(long repeatCount, I
 
             private ValueTask InvokeSingleHardcoded()
             {
-                InvokeNoUnrollHardcoded(1, null);
-                return new ValueTask(valueTaskSource, valueTaskSource.Version);
+                return AwaitHelper.ToValueTaskVoid(callback());
             }
 
             private ValueTask<ClockSpan> InvokeNoUnrollHardcoded(long repeatCount, IClock clock)
             {
                 repeatsRemaining = repeatCount;
                 valueTaskSource.Reset();
-                startedClock = clock?.Start() ?? default;
+                startedClock = clock.Start();
                 RunTask();
                 return new ValueTask<ClockSpan>(valueTaskSource, valueTaskSource.Version);
             }
@@ -283,14 +282,14 @@ public BenchmarkActionTask(object instance, MethodInfo method, BenchmarkActionCo
 
             private ValueTask InvokeSingleHardcodedOverhead()
             {
-                InvokeNoUnrollHardcodedOverhead(1, null);
+                callback();
                 return new ValueTask();
             }
 
             private ValueTask<ClockSpan> InvokeNoUnrollHardcodedOverhead(long repeatCount, IClock clock)
             {
                 repeatsRemaining = repeatCount;
-                startedClock = clock?.Start() ?? default;
+                startedClock = clock.Start();
                 try
                 {
                     while (--repeatsRemaining >= 0)
@@ -307,15 +306,14 @@ private ValueTask<ClockSpan> InvokeNoUnrollHardcodedOverhead(long repeatCount, I
 
             private ValueTask InvokeSingleHardcoded()
             {
-                InvokeNoUnrollHardcoded(1, null);
-                return new ValueTask(valueTaskSource, valueTaskSource.Version);
+                return AwaitHelper.ToValueTaskVoid(callback());
             }
 
             private ValueTask<ClockSpan> InvokeNoUnrollHardcoded(long repeatCount, IClock clock)
             {
                 repeatsRemaining = repeatCount;
                 valueTaskSource.Reset();
-                startedClock = clock?.Start() ?? default;
+                startedClock = clock.Start();
                 RunTask();
                 return new ValueTask<ClockSpan>(valueTaskSource, valueTaskSource.Version);
             }
@@ -401,14 +399,14 @@ public BenchmarkActionValueTask(object instance, MethodInfo method, BenchmarkAct
 
             private ValueTask InvokeSingleHardcodedOverhead()
             {
-                InvokeNoUnrollHardcodedOverhead(1, null);
+                callback();
                 return new ValueTask();
             }
 
             private ValueTask<ClockSpan> InvokeNoUnrollHardcodedOverhead(long repeatCount, IClock clock)
             {
                 repeatsRemaining = repeatCount;
-                startedClock = clock?.Start() ?? default;
+                startedClock = clock.Start();
                 try
                 {
                     while (--repeatsRemaining >= 0)
@@ -425,15 +423,14 @@ private ValueTask<ClockSpan> InvokeNoUnrollHardcodedOverhead(long repeatCount, I
 
             private ValueTask InvokeSingleHardcoded()
             {
-                InvokeNoUnrollHardcoded(1, null);
-                return new ValueTask(valueTaskSource, valueTaskSource.Version);
+                return AwaitHelper.ToValueTaskVoid(callback());
             }
 
             private ValueTask<ClockSpan> InvokeNoUnrollHardcoded(long repeatCount, IClock clock)
             {
                 repeatsRemaining = repeatCount;
                 valueTaskSource.Reset();
-                startedClock = clock?.Start() ?? default;
+                startedClock = clock.Start();
                 RunTask();
                 return new ValueTask<ClockSpan>(valueTaskSource, valueTaskSource.Version);
             }
@@ -518,14 +515,14 @@ public BenchmarkActionValueTask(object instance, MethodInfo method, BenchmarkAct
 
             private ValueTask InvokeSingleHardcodedOverhead()
             {
-                InvokeNoUnrollHardcodedOverhead(1, null);
+                callback();
                 return new ValueTask();
             }
 
             private ValueTask<ClockSpan> InvokeNoUnrollHardcodedOverhead(long repeatCount, IClock clock)
             {
                 repeatsRemaining = repeatCount;
-                startedClock = clock?.Start() ?? default;
+                startedClock = clock.Start();
                 try
                 {
                     while (--repeatsRemaining >= 0)
@@ -542,15 +539,14 @@ private ValueTask<ClockSpan> InvokeNoUnrollHardcodedOverhead(long repeatCount, I
 
             private ValueTask InvokeSingleHardcoded()
             {
-                InvokeNoUnrollHardcoded(1, null);
-                return new ValueTask(valueTaskSource, valueTaskSource.Version);
+                return AwaitHelper.ToValueTaskVoid(callback());
             }
 
             private ValueTask<ClockSpan> InvokeNoUnrollHardcoded(long repeatCount, IClock clock)
             {
                 repeatsRemaining = repeatCount;
                 valueTaskSource.Reset();
-                startedClock = clock?.Start() ?? default;
+                startedClock = clock.Start();
                 RunTask();
                 return new ValueTask<ClockSpan>(valueTaskSource, valueTaskSource.Version);
             }

Original file line number	Diff line number	Diff line change
`@@ -134,15 +134,15 @@ public BenchmarkActionTask(object instance, MethodInfo method, int unrollFactor)`
`134`	`134`
`135`	`135`	`private ValueTask InvokeSingleHardcodedOverhead()`
`136`	`136`	`{`
`137`		`- InvokeNoUnrollHardcodedOverhead(1, null);`
	`137`	`+ callback();`
`138`	`138`	`return new ValueTask();`
`139`	`139`	`}`
`140`	`140`
`141`	`141`	`private ValueTask<ClockSpan> InvokeNoUnrollHardcodedOverhead(long repeatCount, IClock clock)`
`142`	`142`	`{`
`143`	`143`	`repeatsRemaining = repeatCount;`
`144`	`144`	`Task value = default;`
`145`		`- startedClock = clock?.Start() ?? default;`
	`145`	`+ startedClock = clock.Start();`
`146`	`146`	`try`
`147`	`147`	`{`
`148`	`148`	`while (--repeatsRemaining >= 0)`
`@@ -160,15 +160,14 @@ private ValueTask<ClockSpan> InvokeNoUnrollHardcodedOverhead(long repeatCount, I`
`160`	`160`
`161`	`161`	`private ValueTask InvokeSingleHardcoded()`
`162`	`162`	`{`
`163`		`- InvokeNoUnrollHardcoded(1, null);`
`164`		`- return new ValueTask(valueTaskSource, valueTaskSource.Version);`
	`163`	`+ return AwaitHelper.ToValueTaskVoid(callback());`
`165`	`164`	`}`
`166`	`165`
`167`	`166`	`private ValueTask<ClockSpan> InvokeNoUnrollHardcoded(long repeatCount, IClock clock)`
`168`	`167`	`{`
`169`	`168`	`repeatsRemaining = repeatCount;`
`170`	`169`	`valueTaskSource.Reset();`
`171`		`- startedClock = clock?.Start() ?? default;`
	`170`	`+ startedClock = clock.Start();`
`172`	`171`	`RunTask();`
`173`	`172`	`return new ValueTask<ClockSpan>(valueTaskSource, valueTaskSource.Version);`
`174`	`173`	`}`
`@@ -253,15 +252,15 @@ public BenchmarkActionTask(object instance, MethodInfo method, int unrollFactor)`
`253`	`252`
`254`	`253`	`private ValueTask InvokeSingleHardcodedOverhead()`
`255`	`254`	`{`
`256`		`- InvokeNoUnrollHardcodedOverhead(1, null);`
	`255`	`+ callback();`
`257`	`256`	`return new ValueTask();`
`258`	`257`	`}`
`259`	`258`
`260`	`259`	`private ValueTask<ClockSpan> InvokeNoUnrollHardcodedOverhead(long repeatCount, IClock clock)`
`261`	`260`	`{`
`262`	`261`	`repeatsRemaining = repeatCount;`
`263`	`262`	`Task<T> value = default;`
`264`		`- startedClock = clock?.Start() ?? default;`
	`263`	`+ startedClock = clock.Start();`
`265`	`264`	`try`
`266`	`265`	`{`
`267`	`266`	`while (--repeatsRemaining >= 0)`
`@@ -279,15 +278,14 @@ private ValueTask<ClockSpan> InvokeNoUnrollHardcodedOverhead(long repeatCount, I`
`279`	`278`
`280`	`279`	`private ValueTask InvokeSingleHardcoded()`
`281`	`280`	`{`
`282`		`- InvokeNoUnrollHardcoded(1, null);`
`283`		`- return new ValueTask(valueTaskSource, valueTaskSource.Version);`
	`281`	`+ return AwaitHelper.ToValueTaskVoid(callback());`
`284`	`282`	`}`
`285`	`283`
`286`	`284`	`private ValueTask<ClockSpan> InvokeNoUnrollHardcoded(long repeatCount, IClock clock)`
`287`	`285`	`{`
`288`	`286`	`repeatsRemaining = repeatCount;`
`289`	`287`	`valueTaskSource.Reset();`
`290`		`- startedClock = clock?.Start() ?? default;`
	`288`	`+ startedClock = clock.Start();`
`291`	`289`	`RunTask();`
`292`	`290`	`return new ValueTask<ClockSpan>(valueTaskSource, valueTaskSource.Version);`
`293`	`291`	`}`
`@@ -373,15 +371,15 @@ public BenchmarkActionValueTask(object instance, MethodInfo method, int unrollFa`
`373`	`371`
`374`	`372`	`private ValueTask InvokeSingleHardcodedOverhead()`
`375`	`373`	`{`
`376`		`- InvokeNoUnrollHardcodedOverhead(1, null);`
	`374`	`+ callback();`
`377`	`375`	`return new ValueTask();`
`378`	`376`	`}`
`379`	`377`
`380`	`378`	`private ValueTask<ClockSpan> InvokeNoUnrollHardcodedOverhead(long repeatCount, IClock clock)`
`381`	`379`	`{`
`382`	`380`	`repeatsRemaining = repeatCount;`
`383`	`381`	`ValueTask value = default;`
`384`		`- startedClock = clock?.Start() ?? default;`
	`382`	`+ startedClock = clock.Start();`
`385`	`383`	`try`
`386`	`384`	`{`
`387`	`385`	`while (--repeatsRemaining >= 0)`
`@@ -399,15 +397,14 @@ private ValueTask<ClockSpan> InvokeNoUnrollHardcodedOverhead(long repeatCount, I`
`399`	`397`
`400`	`398`	`private ValueTask InvokeSingleHardcoded()`
`401`	`399`	`{`
`402`		`- InvokeNoUnrollHardcoded(1, null);`
`403`		`- return new ValueTask(valueTaskSource, valueTaskSource.Version);`
	`400`	`+ return AwaitHelper.ToValueTaskVoid(callback());`
`404`	`401`	`}`
`405`	`402`
`406`	`403`	`private ValueTask<ClockSpan> InvokeNoUnrollHardcoded(long repeatCount, IClock clock)`
`407`	`404`	`{`
`408`	`405`	`repeatsRemaining = repeatCount;`
`409`	`406`	`valueTaskSource.Reset();`
`410`		`- startedClock = clock?.Start() ?? default;`
	`407`	`+ startedClock = clock.Start();`
`411`	`408`	`RunTask();`
`412`	`409`	`return new ValueTask<ClockSpan>(valueTaskSource, valueTaskSource.Version);`
`413`	`410`	`}`
`@@ -492,15 +489,15 @@ public BenchmarkActionValueTask(object instance, MethodInfo method, int unrollFa`
`492`	`489`
`493`	`490`	`private ValueTask InvokeSingleHardcodedOverhead()`
`494`	`491`	`{`
`495`		`- InvokeNoUnrollHardcodedOverhead(1, null);`
	`492`	`+ callback();`
`496`	`493`	`return new ValueTask();`
`497`	`494`	`}`
`498`	`495`
`499`	`496`	`private ValueTask<ClockSpan> InvokeNoUnrollHardcodedOverhead(long repeatCount, IClock clock)`
`500`	`497`	`{`
`501`	`498`	`repeatsRemaining = repeatCount;`
`502`	`499`	`ValueTask<T> value = default;`
`503`		`- startedClock = clock?.Start() ?? default;`
	`500`	`+ startedClock = clock.Start();`
`504`	`501`	`try`
`505`	`502`	`{`
`506`	`503`	`while (--repeatsRemaining >= 0)`
`@@ -518,15 +515,14 @@ private ValueTask<ClockSpan> InvokeNoUnrollHardcodedOverhead(long repeatCount, I`
`518`	`515`
`519`	`516`	`private ValueTask InvokeSingleHardcoded()`
`520`	`517`	`{`
`521`		`- InvokeNoUnrollHardcoded(1, null);`
`522`		`- return new ValueTask(valueTaskSource, valueTaskSource.Version);`
	`518`	`+ return AwaitHelper.ToValueTaskVoid(callback());`
`523`	`519`	`}`
`524`	`520`
`525`	`521`	`private ValueTask<ClockSpan> InvokeNoUnrollHardcoded(long repeatCount, IClock clock)`
`526`	`522`	`{`
`527`	`523`	`repeatsRemaining = repeatCount;`
`528`	`524`	`valueTaskSource.Reset();`
`529`		`- startedClock = clock?.Start() ?? default;`
	`525`	`+ startedClock = clock.Start();`
`530`	`526`	`RunTask();`
`531`	`527`	`return new ValueTask<ClockSpan>(valueTaskSource, valueTaskSource.Version);`
`532`	`528`	`}`
Original file line number	Diff line number	Diff line change
`@@ -166,14 +166,14 @@ public BenchmarkActionTask(object instance, MethodInfo method, BenchmarkActionCo`
`166`	`166`
`167`	`167`	`private ValueTask InvokeSingleHardcodedOverhead()`
`168`	`168`	`{`
`169`		`- InvokeNoUnrollHardcodedOverhead(1, null);`
	`169`	`+ callback();`
`170`	`170`	`return new ValueTask();`
`171`	`171`	`}`
`172`	`172`
`173`	`173`	`private ValueTask<ClockSpan> InvokeNoUnrollHardcodedOverhead(long repeatCount, IClock clock)`
`174`	`174`	`{`
`175`	`175`	`repeatsRemaining = repeatCount;`
`176`		`- startedClock = clock?.Start() ?? default;`
	`176`	`+ startedClock = clock.Start();`
`177`	`177`	`try`
`178`	`178`	`{`
`179`	`179`	`while (--repeatsRemaining >= 0)`
`@@ -190,15 +190,14 @@ private ValueTask<ClockSpan> InvokeNoUnrollHardcodedOverhead(long repeatCount, I`
`190`	`190`
`191`	`191`	`private ValueTask InvokeSingleHardcoded()`
`192`	`192`	`{`
`193`		`- InvokeNoUnrollHardcoded(1, null);`
`194`		`- return new ValueTask(valueTaskSource, valueTaskSource.Version);`
	`193`	`+ return AwaitHelper.ToValueTaskVoid(callback());`
`195`	`194`	`}`
`196`	`195`
`197`	`196`	`private ValueTask<ClockSpan> InvokeNoUnrollHardcoded(long repeatCount, IClock clock)`
`198`	`197`	`{`
`199`	`198`	`repeatsRemaining = repeatCount;`
`200`	`199`	`valueTaskSource.Reset();`
`201`		`- startedClock = clock?.Start() ?? default;`
	`200`	`+ startedClock = clock.Start();`
`202`	`201`	`RunTask();`
`203`	`202`	`return new ValueTask<ClockSpan>(valueTaskSource, valueTaskSource.Version);`
`204`	`203`	`}`
`@@ -283,14 +282,14 @@ public BenchmarkActionTask(object instance, MethodInfo method, BenchmarkActionCo`
`283`	`282`
`284`	`283`	`private ValueTask InvokeSingleHardcodedOverhead()`
`285`	`284`	`{`
`286`		`- InvokeNoUnrollHardcodedOverhead(1, null);`
	`285`	`+ callback();`
`287`	`286`	`return new ValueTask();`
`288`	`287`	`}`
`289`	`288`
`290`	`289`	`private ValueTask<ClockSpan> InvokeNoUnrollHardcodedOverhead(long repeatCount, IClock clock)`
`291`	`290`	`{`
`292`	`291`	`repeatsRemaining = repeatCount;`
`293`		`- startedClock = clock?.Start() ?? default;`
	`292`	`+ startedClock = clock.Start();`
`294`	`293`	`try`
`295`	`294`	`{`
`296`	`295`	`while (--repeatsRemaining >= 0)`
`@@ -307,15 +306,14 @@ private ValueTask<ClockSpan> InvokeNoUnrollHardcodedOverhead(long repeatCount, I`
`307`	`306`
`308`	`307`	`private ValueTask InvokeSingleHardcoded()`
`309`	`308`	`{`
`310`		`- InvokeNoUnrollHardcoded(1, null);`
`311`		`- return new ValueTask(valueTaskSource, valueTaskSource.Version);`
	`309`	`+ return AwaitHelper.ToValueTaskVoid(callback());`
`312`	`310`	`}`
`313`	`311`
`314`	`312`	`private ValueTask<ClockSpan> InvokeNoUnrollHardcoded(long repeatCount, IClock clock)`
`315`	`313`	`{`
`316`	`314`	`repeatsRemaining = repeatCount;`
`317`	`315`	`valueTaskSource.Reset();`
`318`		`- startedClock = clock?.Start() ?? default;`
	`316`	`+ startedClock = clock.Start();`
`319`	`317`	`RunTask();`
`320`	`318`	`return new ValueTask<ClockSpan>(valueTaskSource, valueTaskSource.Version);`
`321`	`319`	`}`
`@@ -401,14 +399,14 @@ public BenchmarkActionValueTask(object instance, MethodInfo method, BenchmarkAct`
`401`	`399`
`402`	`400`	`private ValueTask InvokeSingleHardcodedOverhead()`
`403`	`401`	`{`
`404`		`- InvokeNoUnrollHardcodedOverhead(1, null);`
	`402`	`+ callback();`
`405`	`403`	`return new ValueTask();`
`406`	`404`	`}`
`407`	`405`
`408`	`406`	`private ValueTask<ClockSpan> InvokeNoUnrollHardcodedOverhead(long repeatCount, IClock clock)`
`409`	`407`	`{`
`410`	`408`	`repeatsRemaining = repeatCount;`
`411`		`- startedClock = clock?.Start() ?? default;`
	`409`	`+ startedClock = clock.Start();`
`412`	`410`	`try`
`413`	`411`	`{`
`414`	`412`	`while (--repeatsRemaining >= 0)`
`@@ -425,15 +423,14 @@ private ValueTask<ClockSpan> InvokeNoUnrollHardcodedOverhead(long repeatCount, I`
`425`	`423`
`426`	`424`	`private ValueTask InvokeSingleHardcoded()`
`427`	`425`	`{`
`428`		`- InvokeNoUnrollHardcoded(1, null);`
`429`		`- return new ValueTask(valueTaskSource, valueTaskSource.Version);`
	`426`	`+ return AwaitHelper.ToValueTaskVoid(callback());`
`430`	`427`	`}`
`431`	`428`
`432`	`429`	`private ValueTask<ClockSpan> InvokeNoUnrollHardcoded(long repeatCount, IClock clock)`
`433`	`430`	`{`
`434`	`431`	`repeatsRemaining = repeatCount;`
`435`	`432`	`valueTaskSource.Reset();`
`436`		`- startedClock = clock?.Start() ?? default;`
	`433`	`+ startedClock = clock.Start();`
`437`	`434`	`RunTask();`
`438`	`435`	`return new ValueTask<ClockSpan>(valueTaskSource, valueTaskSource.Version);`
`439`	`436`	`}`
`@@ -518,14 +515,14 @@ public BenchmarkActionValueTask(object instance, MethodInfo method, BenchmarkAct`
`518`	`515`
`519`	`516`	`private ValueTask InvokeSingleHardcodedOverhead()`
`520`	`517`	`{`
`521`		`- InvokeNoUnrollHardcodedOverhead(1, null);`
	`518`	`+ callback();`
`522`	`519`	`return new ValueTask();`
`523`	`520`	`}`
`524`	`521`
`525`	`522`	`private ValueTask<ClockSpan> InvokeNoUnrollHardcodedOverhead(long repeatCount, IClock clock)`
`526`	`523`	`{`
`527`	`524`	`repeatsRemaining = repeatCount;`
`528`		`- startedClock = clock?.Start() ?? default;`
	`525`	`+ startedClock = clock.Start();`
`529`	`526`	`try`
`530`	`527`	`{`
`531`	`528`	`while (--repeatsRemaining >= 0)`
`@@ -542,15 +539,14 @@ private ValueTask<ClockSpan> InvokeNoUnrollHardcodedOverhead(long repeatCount, I`
`542`	`539`
`543`	`540`	`private ValueTask InvokeSingleHardcoded()`
`544`	`541`	`{`
`545`		`- InvokeNoUnrollHardcoded(1, null);`
`546`		`- return new ValueTask(valueTaskSource, valueTaskSource.Version);`
	`542`	`+ return AwaitHelper.ToValueTaskVoid(callback());`
`547`	`543`	`}`
`548`	`544`
`549`	`545`	`private ValueTask<ClockSpan> InvokeNoUnrollHardcoded(long repeatCount, IClock clock)`
`550`	`546`	`{`
`551`	`547`	`repeatsRemaining = repeatCount;`
`552`	`548`	`valueTaskSource.Reset();`
`553`		`- startedClock = clock?.Start() ?? default;`
	`549`	`+ startedClock = clock.Start();`
`554`	`550`	`RunTask();`
`555`	`551`	`return new ValueTask<ClockSpan>(valueTaskSource, valueTaskSource.Version);`
`556`	`552`	`}`