Moved survived bytes measurement from GcStats to Engine.

Fixed ImmutableConfig.HasSurvivedMemoryDiagnoser() (For some reason, Contains(MemoryDiagnoser.WithSurvived) was returning true when it shouldn't).

Author: timcassell

src/BenchmarkDotNet/Configs/ImmutableConfig.cs

@@ -94,7 +94,8 @@ internal ImmutableConfig(
 
         public bool HasMemoryDiagnoser() => diagnosers.Any(diagnoser => diagnoser is MemoryDiagnoser);
 
-        public bool HasSurvivedMemoryDiagnoser() => diagnosers.Contains(MemoryDiagnoser.WithSurvived);
+        // diagnosers.Contains(MemoryDiagnoser.WithSurvived) for some reason returns true when it shouldn't.
+        public bool HasSurvivedMemoryDiagnoser() => diagnosers.Any(diagnoser => diagnoser is MemoryDiagnoser md && md.IncludeSurvived);
 
         public bool HasThreadingDiagnoser() => diagnosers.Contains(ThreadingDiagnoser.Default);
 

src/BenchmarkDotNet/Engines/Engine.cs

@@ -45,14 +45,16 @@ public class Engine : IEngine
         private readonly EngineActualStage actualStage;
         private readonly bool includeExtraStats, includeSurvivedMemory;
 
+        private long _totalMeasuredSurvivedBytes;
+        private Func<long> GetTotalBytes { get; }
+
         internal Engine(
             IHost host,
             IResolver resolver,
             Action dummy1Action, Action dummy2Action, Action dummy3Action, Action<long> overheadAction, Action<long> workloadAction, Job targetJob,
             Action globalSetupAction, Action globalCleanupAction, Action iterationSetupAction, Action iterationCleanupAction, long operationsPerInvoke,
             bool includeExtraStats, bool includeSurvivedMemory, string benchmarkName)
         {
-
             Host = host;
             OverheadAction = overheadAction;
             Dummy1Action = dummy1Action;
@@ -82,16 +84,46 @@ internal Engine(
             pilotStage = new EnginePilotStage(this);
             actualStage = new EngineActualStage(this);
 
+            GetTotalBytes = GetTotalBytesFunc();
             // Necessary for CORE runtimes.
             if (includeSurvivedMemory)
             {
-                // Measure survived once to allow jit to make its allocations.
-                GcStats.StartMeasuringSurvived(includeSurvivedMemory);
-                // Run the clock once to set static memory.
+                // Measure bytes to allow GC monitor to make its allocations.
+                GetTotalBytes();
+                // Run the clock once to allow it to make its allocations.
                 MeasureAction(_ => { }, 0);
-                GcStats.StopMeasuringSurvived(includeSurvivedMemory);
-                // Clear total measured to not pollute actual measurement.
-                GcStats.ClearTotalMeasuredSurvived();
+                GetTotalBytes();
+            }
+        }
+
+        private Func<long> GetTotalBytesFunc()
+        {
+            // Only enable monitoring if memory diagnoser with survived memory is applied.
+            // Don't try to measure in Mono, Monitoring is not available, and GC.GetTotalMemory is very inaccurate.
+            if (!includeSurvivedMemory || 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);
+                };
             }
         }
 
@@ -171,9 +203,11 @@ public Measurement RunIteration(IterationData data)
                 EngineEventSource.Log.IterationStart(data.IterationMode, data.IterationStage, totalOperations);
 
             // Measure
-            GcStats.StartMeasuringSurvived(includeSurvivedMemory);
+            long beforeBytes = GetTotalBytes();
             double nanoseconds = MeasureAction(action, invokeCount / unrollFactor);
-            long survivedBytes = GcStats.StopMeasuringSurvived(includeSurvivedMemory);
+            long afterBytes = GetTotalBytes();
+            long survivedBytes = afterBytes - beforeBytes;
+            _totalMeasuredSurvivedBytes += survivedBytes;
 
             if (EngineEventSource.Log.IsEnabled())
                 EngineEventSource.Log.IterationStop(data.IterationMode, data.IterationStage, totalOperations);
@@ -218,7 +252,7 @@ private double MeasureAction(Action<long> action, long arg)
 
             IterationCleanupAction(); // we run iteration cleanup after collecting GC stats
 
-            GcStats gcStats = (finalGcStats - initialGcStats).WithTotalOperationsAndSurvivedBytes(data.InvokeCount * OperationsPerInvoke);
+            GcStats gcStats = (finalGcStats - initialGcStats).WithTotalOperationsAndSurvivedBytes(data.InvokeCount * OperationsPerInvoke, _totalMeasuredSurvivedBytes);
             ThreadingStats threadingStats = (finalThreadingStats - initialThreadingStats).WithTotalOperations(data.InvokeCount * OperationsPerInvoke);
 
             return (gcStats, threadingStats);

src/BenchmarkDotNet/Engines/GcStats.cs

@@ -77,8 +77,8 @@ public long BytesAllocatedPerOperation
                 Math.Max(0, left.SurvivedBytes - right.SurvivedBytes));
         }
 
-        public GcStats WithTotalOperationsAndSurvivedBytes(long totalOperationsCount)
-            => this + new GcStats(0, 0, 0, 0, totalOperationsCount, _totalMeasured);
+        public GcStats WithTotalOperationsAndSurvivedBytes(long totalOperationsCount, long survivedBytes)
+            => this + new GcStats(0, 0, 0, 0, totalOperationsCount, survivedBytes);
 
         public int GetCollectionsCount(int generation)
         {
@@ -252,40 +252,5 @@ public override int GetHashCode()
                 return hashCode;
             }
         }
-
-        private static long _totalMeasured = 0;
-        private static long _currentMeasured;
-
-        public static void StartMeasuringSurvived(bool measure)
-        {
-            _currentMeasured = GetTotalBytes(measure);
-        }
-
-        public static long StopMeasuringSurvived(bool measure)
-        {
-            long measured = GetTotalBytes(measure) - _currentMeasured;
-            _currentMeasured = 0;
-            _totalMeasured += measured;
-            return measured;
-        }
-
-        public static void ClearTotalMeasuredSurvived()
-        {
-            _totalMeasured = 0;
-        }
-
-        private static long GetTotalBytes(bool actual)
-        {
-            if (!actual || RuntimeInformation.IsMono) // Monitoring is not available in Mono.
-                return 0;
-
-            AppDomain.MonitoringIsEnabled = true;
-
-            // Enforce GC.Collect here to make sure we get accurate results.
-            GC.Collect();
-            GC.WaitForPendingFinalizers();
-            GC.Collect();
-            return AppDomain.CurrentDomain.MonitoringSurvivedMemorySize;
-        }
     }
 }