Clear from consumer.

timcassell · timcassell · commit 41164284a812 · 2020-12-13T17:29:31.000-05:00
Added survived memory tests.
diff --git a/src/BenchmarkDotNet/Engines/Consumer.cs b/src/BenchmarkDotNet/Engines/Consumer.cs
@@ -33,6 +33,14 @@ private static readonly HashSet<Type> SupportedTypes
         private string stringHolder;
         private object objectHolder;
 
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        [PublicAPI]
+        public void Clear()
+        {
+            Volatile.Write(ref stringHolder, null);
+            Volatile.Write(ref objectHolder, null);
+        }
+
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         [PublicAPI]
         public void Consume(byte byteValue) => byteHolder = byteValue;
diff --git a/src/BenchmarkDotNet/Engines/Engine.cs b/src/BenchmarkDotNet/Engines/Engine.cs
@@ -130,6 +130,12 @@ private Func<long> GetTotalBytesFunc()
             }
         }
 
+        private static void ResetSurvived()
+        {
+            survivedBytes = 0;
+            survivedBytesMeasured = false;
+        }
+
         public void Dispose()
         {
             try
@@ -284,6 +290,7 @@ private double MeasureAction(Action<long> action, long arg)
             GcStats gcStats = (finalGcStats - initialGcStats).WithTotalOperationsAndSurvivedBytes(data.InvokeCount * OperationsPerInvoke, survivedBytes);
             ThreadingStats threadingStats = (finalThreadingStats - initialThreadingStats).WithTotalOperations(data.InvokeCount * OperationsPerInvoke);
 
+            ResetSurvived();
             return (gcStats, threadingStats);
         }
 
diff --git a/src/BenchmarkDotNet/Templates/BenchmarkType.txt b/src/BenchmarkDotNet/Templates/BenchmarkType.txt
@@ -121,6 +121,7 @@
             {
                 consumer.Consume(overheadDelegate($PassArguments$));@Unroll@
             }
+            consumer.Clear(); // Necessary for survived memory diagnoser.
         }
 
         private void OverheadActionNoUnroll(System.Int64 invokeCount)
@@ -130,6 +131,7 @@
             {
                 consumer.Consume(overheadDelegate($PassArguments$));
             }
+            consumer.Clear(); // Necessary for survived memory diagnoser.
         }
 
         private void WorkloadActionUnroll(System.Int64 invokeCount)
@@ -139,6 +141,7 @@
             {
                 consumer.Consume(workloadDelegate($PassArguments$)$ConsumeField$);@Unroll@
             }
+            consumer.Clear(); // Necessary for survived memory diagnoser.
         }
 
         private void WorkloadActionNoUnroll(System.Int64 invokeCount)
@@ -148,6 +151,7 @@
             {
                 consumer.Consume(workloadDelegate($PassArguments$)$ConsumeField$);
             }
+            consumer.Clear(); // Necessary for survived memory diagnoser.
         }
         
         [System.Runtime.CompilerServices.MethodImpl(System.Runtime.CompilerServices.MethodImplOptions.NoOptimization | System.Runtime.CompilerServices.MethodImplOptions.NoInlining)]
diff --git a/src/BenchmarkDotNet/Toolchains/InProcess.Emit.Implementation/Emitters/ConsumableConsumeEmitter.cs b/src/BenchmarkDotNet/Toolchains/InProcess.Emit.Implementation/Emitters/ConsumableConsumeEmitter.cs
@@ -122,5 +122,13 @@ protected override void EmitActionAfterCallOverride(ILGenerator ilBuilder)
                 }
             }
         }
+
+        protected override void EmitActionAfterLoopOverride(ILGenerator ilBuilder)
+        {
+            var clearMethod = typeof(Consumer).GetMethod(nameof(Consumer.Clear));
+            ilBuilder.Emit(OpCodes.Ldarg_0);
+            ilBuilder.Emit(OpCodes.Ldfld, consumerField);
+            ilBuilder.Emit(OpCodes.Callvirt, clearMethod);
+        }
     }
 }
diff --git a/tests/BenchmarkDotNet.IntegrationTests/MemoryDiagnoserTests.cs b/tests/BenchmarkDotNet.IntegrationTests/MemoryDiagnoserTests.cs
@@ -9,6 +9,7 @@
 using BenchmarkDotNet.Columns;
 using BenchmarkDotNet.Configs;
 using BenchmarkDotNet.Diagnosers;
+using BenchmarkDotNet.Engines;
 using BenchmarkDotNet.Extensions;
 using BenchmarkDotNet.IntegrationTests.Xunit;
 using BenchmarkDotNet.Jobs;
@@ -19,6 +20,7 @@
 using BenchmarkDotNet.Tests.XUnit;
 using BenchmarkDotNet.Toolchains;
 using BenchmarkDotNet.Toolchains.CoreRt;
+using BenchmarkDotNet.Toolchains.CsProj;
 using BenchmarkDotNet.Toolchains.InProcess.Emit;
 using Xunit;
 using Xunit.Abstractions;
@@ -69,6 +71,64 @@ public void MemoryDiagnoserIsAccurate(IToolchain toolchain)
             });
         }
 
+        public class AccurateSurvived
+        {
+            [Benchmark] public byte[] EightBytesArray() => new byte[8];
+            [Benchmark] public byte[] SixtyFourBytesArray() => new byte[64];
+            [Benchmark] public Task<int> AllocateTask() => Task.FromResult(default(int));
+
+
+            public byte[] bytes8;
+            public byte[] bytes64;
+            public Task<int> task;
+
+            [GlobalSetup(Targets = new string[] { nameof(EightBytesArrayNoAllocate), nameof(SixtyFourBytesArrayNoAllocate) })]
+            public void SetupNoAllocate()
+            {
+                bytes8 = new byte[8];
+                bytes64 = new byte[64];
+            }
+
+            [Benchmark] public byte[] EightBytesArrayNoAllocate() => bytes8;
+            [Benchmark] public byte[] SixtyFourBytesArrayNoAllocate() => bytes64;
+
+
+            [Benchmark] public void EightBytesArraySurvive() => bytes8 = new byte[8];
+            [Benchmark] public void SixtyFourBytesArraySurvive() => bytes64 = new byte[64];
+            [Benchmark] public void AllocateTaskSurvive() => task = Task.FromResult(default(int));
+
+
+            [Benchmark] public void EightBytesArrayAllocateNoSurvive() => DeadCodeEliminationHelper.KeepAliveWithoutBoxing(new byte[8]);
+            [Benchmark] public void SixtyFourBytesArrayAllocateNoSurvive() => DeadCodeEliminationHelper.KeepAliveWithoutBoxing(new byte[64]);
+            [Benchmark] public void TaskAllocateNoSurvive() => DeadCodeEliminationHelper.KeepAliveWithoutBoxing(Task.FromResult(default(int)));
+        }
+
+        [Theory, MemberData(nameof(GetToolchains))]
+        [Trait(Constants.Category, Constants.BackwardCompatibilityCategory)]
+        public void MemoryDiagnoserSurvivedIsAccurate(IToolchain toolchain)
+        {
+            long objectAllocationOverhead = IntPtr.Size * 2; // pointer to method table + object header word
+            long arraySizeOverhead = IntPtr.Size; // array length
+
+            AssertSurvived(toolchain, typeof(AccurateSurvived), new Dictionary<string, long>
+            {
+                { nameof(AccurateSurvived.EightBytesArray), 0 },
+                { nameof(AccurateSurvived.SixtyFourBytesArray), 0 },
+                { nameof(AccurateSurvived.AllocateTask), 0 },
+
+                { nameof(AccurateSurvived.EightBytesArrayNoAllocate), 0 },
+                { nameof(AccurateSurvived.SixtyFourBytesArrayNoAllocate), 0 },
+
+                { nameof(AccurateSurvived.EightBytesArraySurvive), 8 + objectAllocationOverhead + arraySizeOverhead },
+                { nameof(AccurateSurvived.SixtyFourBytesArraySurvive), 64 + objectAllocationOverhead + arraySizeOverhead },
+                { nameof(AccurateSurvived.AllocateTaskSurvive), CalculateRequiredSpace<Task<int>>() },
+
+                { nameof(AccurateSurvived.EightBytesArrayAllocateNoSurvive), 0 },
+                { nameof(AccurateSurvived.SixtyFourBytesArrayAllocateNoSurvive), 0 },
+                { nameof(AccurateSurvived.TaskAllocateNoSurvive), 0 },
+            });
+        }
+
         public class AllocatingGlobalSetupAndCleanup
         {
             private List<int> list;
@@ -102,6 +162,16 @@ public void MemoryDiagnoserDoesNotIncludeAllocationsFromSetupAndCleanup(IToolcha
             });
         }
 
+        [Theory, MemberData(nameof(GetToolchains))]
+        [Trait(Constants.Category, Constants.BackwardCompatibilityCategory)]
+        public void MemoryDiagnoserDoesNotIncludeSurvivedFromSetupAndCleanup(IToolchain toolchain)
+        {
+            AssertSurvived(toolchain, typeof(AllocatingGlobalSetupAndCleanup), new Dictionary<string, long>
+            {
+                { nameof(AllocatingGlobalSetupAndCleanup.AllocateNothing), 0 }
+            });
+        }
+
         public class NoAllocationsAtAll
         {
             [Benchmark] public void EmptyMethod() { }
@@ -117,6 +187,16 @@ public void EngineShouldNotInterfereAllocationResults(IToolchain toolchain)
             });
         }
 
+        [Theory, MemberData(nameof(GetToolchains))]
+        [Trait(Constants.Category, Constants.BackwardCompatibilityCategory)]
+        public void EngineShouldNotInterfereSurvivedResults(IToolchain toolchain)
+        {
+            AssertSurvived(toolchain, typeof(NoAllocationsAtAll), new Dictionary<string, long>
+            {
+                { nameof(NoAllocationsAtAll.EmptyMethod), 0 }
+            });
+        }
+
         public class NoBoxing
         {
             [Benchmark] public ValueTuple<int> ReturnsValueType() => new ValueTuple<int>(0);
@@ -132,10 +212,29 @@ public void EngineShouldNotIntroduceBoxing(IToolchain toolchain)
             });
         }
 
+        [Theory, MemberData(nameof(GetToolchains))]
+        [Trait(Constants.Category, Constants.BackwardCompatibilityCategory)]
+        public void EngineShouldNotIntroduceBoxingSurvived(IToolchain toolchain)
+        {
+            AssertSurvived(toolchain, typeof(NoBoxing), new Dictionary<string, long>
+            {
+                { nameof(NoBoxing.ReturnsValueType), 0 }
+            });
+        }
+
         public class NonAllocatingAsynchronousBenchmarks
         {
             private readonly Task<int> completedTaskOfT = Task.FromResult(default(int)); // we store it in the field, because Task<T> is reference type so creating it allocates heap memory
 
+            [GlobalSetup]
+            public void Setup()
+            {
+                // Run once to set static memory.
+                DeadCodeEliminationHelper.KeepAliveWithoutBoxing(CompletedTask());
+                DeadCodeEliminationHelper.KeepAliveWithoutBoxing(CompletedTaskOfT());
+                DeadCodeEliminationHelper.KeepAliveWithoutBoxing(CompletedValueTaskOfT());
+            }
+
             [Benchmark] public Task CompletedTask() => Task.CompletedTask;
 
             [Benchmark] public Task<int> CompletedTaskOfT() => completedTaskOfT;
@@ -155,6 +254,18 @@ public void AwaitingTasksShouldNotInterfereAllocationResults(IToolchain toolchai
             });
         }
 
+        [Theory, MemberData(nameof(GetToolchains))]
+        [Trait(Constants.Category, Constants.BackwardCompatibilityCategory)]
+        public void AwaitingTasksShouldNotInterfereSurvivedResults(IToolchain toolchain)
+        {
+            AssertSurvived(toolchain, typeof(NonAllocatingAsynchronousBenchmarks), new Dictionary<string, long>
+            {
+                { nameof(NonAllocatingAsynchronousBenchmarks.CompletedTask), 0 },
+                { nameof(NonAllocatingAsynchronousBenchmarks.CompletedTaskOfT), 0 },
+                { nameof(NonAllocatingAsynchronousBenchmarks.CompletedValueTaskOfT), 0 }
+            });
+        }
+
         public class WithOperationsPerInvokeBenchmarks
         {
             [Benchmark(OperationsPerInvoke = 4)]
@@ -257,7 +368,7 @@ public void MemoryDiagnoserIsAccurateForMultiThreadedBenchmarks(IToolchain toolc
 
         private void AssertAllocations(IToolchain toolchain, Type benchmarkType, Dictionary<string, long> benchmarksAllocationsValidators)
         {
-            var config = CreateConfig(toolchain);
+            var config = CreateConfig(toolchain, MemoryDiagnoser.Default);
             var benchmarks = BenchmarkConverter.TypeToBenchmarks(benchmarkType, config);
 
             var summary = BenchmarkRunner.Run(benchmarks);
@@ -285,7 +396,37 @@ private void AssertAllocations(IToolchain toolchain, Type benchmarkType, Diction
             }
         }
 
-        private IConfig CreateConfig(IToolchain toolchain)
+        private void AssertSurvived(IToolchain toolchain, Type benchmarkType, Dictionary<string, long> benchmarkSurvivedValidators)
+        {
+            // Core has survived memory measurement problems.
+            // See https://github.com/dotnet/runtime/issues/45446
+            if (toolchain is CsProjCoreToolchain || toolchain is CoreRtToolchain) // CoreRt actually does measure accurately in a normal benchmark run, but doesn't with the specific version used in these tests.
+                return;
+
+            var config = CreateConfig(toolchain, MemoryDiagnoser.WithSurvived);
+            var benchmarks = BenchmarkConverter.TypeToBenchmarks(benchmarkType, config);
+
+            var summary = BenchmarkRunner.Run(benchmarks);
+
+            foreach (var benchmarkSurvivedValidator in benchmarkSurvivedValidators)
+            {
+                // CoreRT is missing some of the CoreCLR threading/task related perf improvements, so sizeof(Task<int>) calculated for CoreCLR < sizeof(Task<int>) on CoreRT
+                // see https://github.com/dotnet/corert/issues/5705 for more
+                if (benchmarkSurvivedValidator.Key == nameof(AccurateSurvived.AllocateTaskSurvive) && toolchain is CoreRtToolchain)
+                    continue;
+
+                var survivedBenchmarks = benchmarks.BenchmarksCases.Where(benchmark => benchmark.Descriptor.WorkloadMethodDisplayInfo == benchmarkSurvivedValidator.Key).ToArray();
+
+                foreach (var benchmark in survivedBenchmarks)
+                {
+                    var benchmarkReport = summary.Reports.Single(report => report.BenchmarkCase == benchmark);
+
+                    Assert.Equal(benchmarkSurvivedValidator.Value, benchmarkReport.GcStats.SurvivedBytes);
+                }
+            }
+        }
+
+        private IConfig CreateConfig(IToolchain toolchain, MemoryDiagnoser memoryDiagnoser)
             => ManualConfig.CreateEmpty()
                 .AddJob(Job.ShortRun
                     .WithEvaluateOverhead(false) // no need to run idle for this test
@@ -294,7 +435,7 @@ private IConfig CreateConfig(IToolchain toolchain)
                     .WithGcForce(false)
                     .WithToolchain(toolchain))
                 .AddColumnProvider(DefaultColumnProviders.Instance)
-                .AddDiagnoser(MemoryDiagnoser.Default)
+                .AddDiagnoser(memoryDiagnoser)
                 .AddLogger(toolchain.IsInProcess ? ConsoleLogger.Default : new OutputLogger(output)); // we can't use OutputLogger for the InProcess toolchains because it allocates memory on the same thread
 
         // note: don't copy, never use in production systems (it should work but I am not 100% sure)

Original file line number	Diff line number	Diff line change
`@@ -130,6 +130,12 @@ private Func<long> GetTotalBytesFunc()`
`130`	`130`	`}`
`131`	`131`	`}`
`132`	`132`
	`133`	`+ private static void ResetSurvived()`
	`134`	`+ {`
	`135`	`+ survivedBytes = 0;`
	`136`	`+ survivedBytesMeasured = false;`
	`137`	`+ }`
	`138`	`+`
`133`	`139`	`public void Dispose()`
`134`	`140`	`{`
`135`	`141`	`try`
`@@ -284,6 +290,7 @@ private double MeasureAction(Action<long> action, long arg)`
`284`	`290`	`GcStats gcStats = (finalGcStats - initialGcStats).WithTotalOperationsAndSurvivedBytes(data.InvokeCount * OperationsPerInvoke, survivedBytes);`
`285`	`291`	`ThreadingStats threadingStats = (finalThreadingStats - initialThreadingStats).WithTotalOperations(data.InvokeCount * OperationsPerInvoke);`
`286`	`292`
	`293`	`+ ResetSurvived();`
`287`	`294`	`return (gcStats, threadingStats);`
`288`	`295`	`}`
`289`	`296`
Original file line number	Diff line number	Diff line change
`@@ -121,6 +121,7 @@`
`121`	`121`	`{`
`122`	`122`	`consumer.Consume(overheadDelegate($PassArguments$));@Unroll@`
`123`	`123`	`}`
	`124`	`+ consumer.Clear(); // Necessary for survived memory diagnoser.`
`124`	`125`	`}`
`125`	`126`
`126`	`127`	`private void OverheadActionNoUnroll(System.Int64 invokeCount)`
`@@ -130,6 +131,7 @@`
`130`	`131`	`{`
`131`	`132`	`consumer.Consume(overheadDelegate($PassArguments$));`
`132`	`133`	`}`
	`134`	`+ consumer.Clear(); // Necessary for survived memory diagnoser.`
`133`	`135`	`}`
`134`	`136`
`135`	`137`	`private void WorkloadActionUnroll(System.Int64 invokeCount)`
`@@ -139,6 +141,7 @@`
`139`	`141`	`{`
`140`	`142`	`consumer.Consume(workloadDelegate($PassArguments$)$ConsumeField$);@Unroll@`
`141`	`143`	`}`
	`144`	`+ consumer.Clear(); // Necessary for survived memory diagnoser.`
`142`	`145`	`}`
`143`	`146`
`144`	`147`	`private void WorkloadActionNoUnroll(System.Int64 invokeCount)`
`@@ -148,6 +151,7 @@`
`148`	`151`	`{`
`149`	`152`	`consumer.Consume(workloadDelegate($PassArguments$)$ConsumeField$);`
`150`	`153`	`}`
	`154`	`+ consumer.Clear(); // Necessary for survived memory diagnoser.`
`151`	`155`	`}`
`152`	`156`
`153`	`157`	`[System.Runtime.CompilerServices.MethodImpl(System.Runtime.CompilerServices.MethodImplOptions.NoOptimization \| System.Runtime.CompilerServices.MethodImplOptions.NoInlining)]`
Original file line number	Diff line number	Diff line change
`@@ -122,5 +122,13 @@ protected override void EmitActionAfterCallOverride(ILGenerator ilBuilder)`
`122`	`122`	`}`
`123`	`123`	`}`
`124`	`124`	`}`
	`125`	`+`
	`126`	`+ protected override void EmitActionAfterLoopOverride(ILGenerator ilBuilder)`
	`127`	`+ {`
	`128`	`+ var clearMethod = typeof(Consumer).GetMethod(nameof(Consumer.Clear));`
	`129`	`+ ilBuilder.Emit(OpCodes.Ldarg_0);`
	`130`	`+ ilBuilder.Emit(OpCodes.Ldfld, consumerField);`
	`131`	`+ ilBuilder.Emit(OpCodes.Callvirt, clearMethod);`
	`132`	`+ }`
`125`	`133`	`}`
`126`	`134`	`}`