Added memory diagnoser option to measure survived memory from the first benchmark run.

Author: timcassell

src/BenchmarkDotNet/Attributes/MemoryDiagnoserAttribute.cs

@@ -10,9 +10,10 @@ public class MemoryDiagnoserAttribute : Attribute, IConfigSource
         public IConfig Config { get; }
 
         /// <param name="displayGenColumns">Display Garbage Collections per Generation columns (Gen 0, Gen 1, Gen 2). True by default.</param>
-        public MemoryDiagnoserAttribute(bool displayGenColumns = true)
+        /// <param name="includeSurvived">If true, monitoring will be enabled and survived memory will be measured on the first benchmark run.</param>
+        public MemoryDiagnoserAttribute(bool displayGenColumns = true, bool includeSurvived = false)
         {
-            Config = ManualConfig.CreateEmpty().AddDiagnoser(new MemoryDiagnoser(new MemoryDiagnoserConfig(displayGenColumns)));
+            Config = ManualConfig.CreateEmpty().AddDiagnoser(new MemoryDiagnoser(new MemoryDiagnoserConfig(displayGenColumns, includeSurvived)));
         }
     }
 }

src/BenchmarkDotNet/Code/CodeGenerator.cs

@@ -63,6 +63,7 @@ internal static string Generate(BuildPartition buildPartition)
                     .Replace("$PassArguments$", passArguments)
                     .Replace("$EngineFactoryType$", GetEngineFactoryTypeName(benchmark))
                     .Replace("$MeasureExtraStats$", buildInfo.Config.HasExtraStatsDiagnoser() ? "true" : "false")
+                    .Replace("$MeasureSurvivedMemory$", buildInfo.Config.HasSurvivedMemoryDiagnoser() ? "true" : "false")
                     .Replace("$DisassemblerEntryMethodName$", DisassemblerConstants.DisassemblerEntryMethodName)
                     .Replace("$WorkloadMethodCall$", provider.GetWorkloadMethodCall(passArguments))
                     .RemoveRedundantIfDefines(compilationId);

src/BenchmarkDotNet/Configs/ImmutableConfig.cs

@@ -104,6 +104,8 @@ internal ImmutableConfig(
 
         public bool HasMemoryDiagnoser() => diagnosers.OfType<MemoryDiagnoser>().Any();
 
+        public bool HasSurvivedMemoryDiagnoser() => diagnosers.Any(diagnoser => diagnoser is MemoryDiagnoser md && md.Config.IncludeSurvived);
+
         public bool HasThreadingDiagnoser() => diagnosers.Contains(ThreadingDiagnoser.Default);
 
         public bool HasExceptionDiagnoser() => diagnosers.Contains(ExceptionDiagnoser.Default);

src/BenchmarkDotNet/ConsoleArguments/CommandLineOptions.cs

@@ -62,6 +62,9 @@ public bool UseDisassemblyDiagnoser
         [Option('a', "artifacts", Required = false, HelpText = "Valid path to accessible directory")]
         public DirectoryInfo ArtifactsDirectory { get; set; }
 
+        [Option("memorySurvived", Required = false, Default = false, HelpText = "Measures survived memory.")]
+        public bool UseSurvivedMemoryDiagnoser { get; set; }
+
         [Option("outliers", Required = false, Default = OutlierMode.RemoveUpper, HelpText = "DontRemove/RemoveUpper/RemoveLower/RemoveAll")]
         public OutlierMode Outliers { get; set; }
 

src/BenchmarkDotNet/ConsoleArguments/ConfigParser.cs

@@ -210,8 +210,11 @@ private static IConfig CreateConfig(CommandLineOptions options, IConfig globalCo
                 .Select(counterName => (HardwareCounter)Enum.Parse(typeof(HardwareCounter), counterName, ignoreCase: true))
                 .ToArray());
 
-            if (options.UseMemoryDiagnoser)
+            if (options.UseSurvivedMemoryDiagnoser)
+                config.AddDiagnoser(new MemoryDiagnoser(new MemoryDiagnoserConfig(includeSurvived: true)));
+            else if (options.UseMemoryDiagnoser)
                 config.AddDiagnoser(MemoryDiagnoser.Default);
+
             if (options.UseThreadingDiagnoser)
                 config.AddDiagnoser(ThreadingDiagnoser.Default);
             if (options.UseExceptionDiagnoser)

src/BenchmarkDotNet/Diagnosers/MemoryDiagnoser.cs

@@ -42,6 +42,25 @@ public IEnumerable<Metric> ProcessResults(DiagnoserResults diagnoserResults)
                 yield return new Metric(GarbageCollectionsMetricDescriptor.Gen2, diagnoserResults.GcStats.Gen2Collections / (double)diagnoserResults.GcStats.TotalOperations * 1000);
 
             yield return new Metric(AllocatedMemoryMetricDescriptor.Instance, diagnoserResults.GcStats.GetBytesAllocatedPerOperation(diagnoserResults.BenchmarkCase));
+
+            if (Config.IncludeSurvived)
+            {
+                yield return new Metric(SurvivedMemoryMetricDescriptor.Instance, diagnoserResults.GcStats.SurvivedBytes);
+            }
+        }
+
+        private class SurvivedMemoryMetricDescriptor : IMetricDescriptor
+        {
+            internal static readonly IMetricDescriptor Instance = new SurvivedMemoryMetricDescriptor();
+
+            public string Id => "Survived Memory";
+            public string DisplayName => "Survived";
+            public string Legend => "Memory survived after the first operation (managed only, inclusive, 1KB = 1024B)";
+            public string NumberFormat => "N0";
+            public UnitType UnitType => UnitType.Size;
+            public string Unit => SizeUnit.B.Name;
+            public bool TheGreaterTheBetter => false;
+            public int PriorityInCategory { get; } = AllocatedMemoryMetricDescriptor.Instance.PriorityInCategory + 1;
         }
 
         private class GarbageCollectionsMetricDescriptor : IMetricDescriptor

src/BenchmarkDotNet/Diagnosers/MemoryDiagnoserConfig.cs

@@ -5,12 +5,15 @@ namespace BenchmarkDotNet.Diagnosers
     public class MemoryDiagnoserConfig
     {
         /// <param name="displayGenColumns">Display Garbage Collections per Generation columns (Gen 0, Gen 1, Gen 2). True by default.</param>
+        /// <param name="includeSurvived">If true, monitoring will be enabled and survived memory will be measured on the first benchmark run.</param>
         [PublicAPI]
-        public MemoryDiagnoserConfig(bool displayGenColumns = true)
+        public MemoryDiagnoserConfig(bool displayGenColumns = true, bool includeSurvived = false)
         {
             DisplayGenColumns = displayGenColumns;
+            IncludeSurvived = includeSurvived;
         }
 
         public bool DisplayGenColumns { get; }
+        public bool IncludeSurvived { get; }
     }
 }

src/BenchmarkDotNet/Engines/Consumer.cs

@@ -35,6 +35,14 @@ private static readonly HashSet<Type> SupportedTypes
         private IntPtr ptrHolder;
         private UIntPtr uptrHolder;
 
+        [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;

src/BenchmarkDotNet/Engines/Engine.cs

@@ -20,6 +20,7 @@ public class Engine : IEngine
 
         [PublicAPI] public IHost Host { get; }
         [PublicAPI] public Action<long> WorkloadAction { get; }
+        [PublicAPI] public Action<long> WorkloadActionNoUnroll { get; }
         [PublicAPI] public Action Dummy1Action { get; }
         [PublicAPI] public Action Dummy2Action { get; }
         [PublicAPI] public Action Dummy3Action { get; }
@@ -44,19 +45,24 @@ public class Engine : IEngine
         private readonly EnginePilotStage pilotStage;
         private readonly EngineWarmupStage warmupStage;
         private readonly EngineActualStage actualStage;
-        private readonly bool includeExtraStats;
         private readonly Random random;
+        private readonly bool includeExtraStats, includeSurvivedMemory;
+
+        // These must be static since more than one Engine is used.
+        private static long survivedBytes;
+        private static bool survivedBytesMeasured;
+        private static Func<long> GetTotalBytes { get; set; }
 
         internal Engine(
             IHost host,
             IResolver resolver,
-            Action dummy1Action, Action dummy2Action, Action dummy3Action, Action<long> overheadAction, Action<long> workloadAction, 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, string benchmarkName)
+            bool includeExtraStats, bool includeSurvivedMemory, string benchmarkName)
         {
-
             Host = host;
             OverheadAction = overheadAction;
+            WorkloadActionNoUnroll = workloadActionNoUnroll;
             Dummy1Action = dummy1Action;
             Dummy2Action = dummy2Action;
             Dummy3Action = dummy3Action;
@@ -69,6 +75,7 @@ internal Engine(
             OperationsPerInvoke = operationsPerInvoke;
             this.includeExtraStats = includeExtraStats;
             BenchmarkName = benchmarkName;
+            this.includeSurvivedMemory = includeSurvivedMemory;
 
             Resolver = resolver;
 
@@ -84,6 +91,53 @@ internal Engine(
             actualStage = new EngineActualStage(this);
 
             random = new Random(12345); // we are using constant seed to try to get repeatable results
+
+            if (includeSurvivedMemory && GetTotalBytes is null)
+            {
+                // CreateGetTotalBytesFunc enables monitoring, so we only call it if we need to measure survived memory.
+                GetTotalBytes = CreateGetTotalBytesFunc();
+
+                // Necessary for CORE runtimes.
+                // Measure bytes to allow GC monitor to make its allocations.
+                GetTotalBytes();
+                // Run the clock once to allow it to make its allocations.
+                MeasureAction(_ => { }, 0);
+                GetTotalBytes();
+            }
+        }
+
+        private static Func<long> CreateGetTotalBytesFunc()
+        {
+            // Don't try to measure in Mono, Monitoring is not available, and GC.GetTotalMemory is very inaccurate.
+            if (RuntimeInformation.IsMono)
+                return () => 0;
+            try
+            {
+                // Docs say this should be available in .NET Core 2.1, but it throws an exception.
+                // Just try this on all non-Mono runtimes, fallback to GC.GetTotalMemory.
+                AppDomain.MonitoringIsEnabled = true;
+                return () =>
+                {
+                    // Enforce GC.Collect here to make sure we get accurate results.
+                    ForceGcCollect();
+                    return AppDomain.CurrentDomain.MonitoringSurvivedMemorySize;
+                };
+            }
+            catch
+            {
+                return () =>
+                {
+                    // Enforce GC.Collect here to make sure we get accurate results.
+                    ForceGcCollect();
+                    return GC.GetTotalMemory(true);
+                };
+            }
+        }
+
+        private static void ResetSurvived()
+        {
+            survivedBytes = 0;
+            survivedBytesMeasured = false;
         }
 
         public void Dispose()
@@ -155,7 +209,9 @@ public Measurement RunIteration(IterationData data)
             var action = isOverhead ? OverheadAction : WorkloadAction;
 
             if (!isOverhead)
+            {
                 IterationSetupAction();
+            }
 
             GcCollect();
 
@@ -164,10 +220,36 @@ public Measurement RunIteration(IterationData data)
 
             Span<byte> stackMemory = randomizeMemory ? stackalloc byte[random.Next(32)] : Span<byte>.Empty;
 
-            // Measure
-            var clock = Clock.Start();
-            action(invokeCount / unrollFactor);
-            var clockSpan = clock.GetElapsed();
+            bool needsSurvivedMeasurement = includeSurvivedMemory && !isOverhead && !survivedBytesMeasured;
+            double nanoseconds;
+            if (needsSurvivedMeasurement)
+            {
+                // Measure survived bytes for only the first invocation.
+                survivedBytesMeasured = true;
+                if (totalOperations == 1)
+                {
+                    // 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(WorkloadActionNoUnroll, 1);
+                    long afterBytes = GetTotalBytes();
+                    survivedBytes = afterBytes - beforeBytes;
+                    nanoseconds += MeasureAction(action, invokeCount / unrollFactor);
+                }
+            }
+            else
+            {
+                // Measure time normally.
+                nanoseconds = MeasureAction(action, invokeCount / unrollFactor);
+            }
 
             if (EngineEventSource.Log.IsEnabled())
                 EngineEventSource.Log.IterationStop(data.IterationMode, data.IterationStage, totalOperations);
@@ -181,14 +263,23 @@ public Measurement RunIteration(IterationData data)
             GcCollect();
 
             // Results
-            var measurement = new Measurement(0, data.IterationMode, data.IterationStage, data.Index, totalOperations, clockSpan.GetNanoseconds());
+            var measurement = new Measurement(0, data.IterationMode, data.IterationStage, data.Index, totalOperations, nanoseconds);
             WriteLine(measurement.ToString());
 
             Consume(stackMemory);
 
             return measurement;
         }
 
+        // This is necessary for the CORE runtime to clean up the memory from the clock.
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        private double MeasureAction(Action<long> action, long arg)
+        {
+            var clock = Clock.Start();
+            action(arg);
+            return clock.GetElapsed().GetNanoseconds();
+        }
+
         private (GcStats, ThreadingStats, double) GetExtraStats(IterationData data)
         {
             // we enable monitoring after main target run, for this single iteration which is executed at the end
@@ -212,9 +303,10 @@ public Measurement RunIteration(IterationData data)
             IterationCleanupAction(); // we run iteration cleanup after collecting GC stats
 
             var totalOperationsCount = data.InvokeCount * OperationsPerInvoke;
-            GcStats gcStats = (finalGcStats - initialGcStats).WithTotalOperations(totalOperationsCount);
+            GcStats gcStats = (finalGcStats - initialGcStats).WithTotalOperationsAndSurvivedBytes(data.InvokeCount * OperationsPerInvoke, survivedBytes);
             ThreadingStats threadingStats = (finalThreadingStats - initialThreadingStats).WithTotalOperations(data.InvokeCount * OperationsPerInvoke);
 
+            ResetSurvived();
             return (gcStats, threadingStats, exceptionsStats.ExceptionsCount / (double)totalOperationsCount);
         }
 

src/BenchmarkDotNet/Engines/EngineFactory.cs

@@ -118,13 +118,15 @@ private static Engine CreateEngine(EngineParameters engineParameters, Job job, A
                 engineParameters.Dummy3Action,
                 idle,
                 main,
+                engineParameters.WorkloadActionNoUnroll,
                 job,
                 engineParameters.GlobalSetupAction,
                 engineParameters.GlobalCleanupAction,
                 engineParameters.IterationSetupAction,
                 engineParameters.IterationCleanupAction,
                 engineParameters.OperationsPerInvoke,
                 engineParameters.MeasureExtraStats,
+                engineParameters.MeasureSurvivedMemory,
                 engineParameters.BenchmarkName);
     }
 }