Capture total memory before and after running workload to calculate survived memory.

Add survived memory value to Measurement, only print it if it's non-zero.

Author: timcassell

src/BenchmarkDotNet/Engines/Engine.cs

@@ -2,6 +2,7 @@
 using System.Collections.Generic;
 using System.Globalization;
 using System.Linq;
+using System.Runtime.CompilerServices;
 using BenchmarkDotNet.Characteristics;
 using BenchmarkDotNet.Jobs;
 using BenchmarkDotNet.Portability;
@@ -80,6 +81,12 @@ internal Engine(
             warmupStage = new EngineWarmupStage(this);
             pilotStage = new EnginePilotStage(this);
             actualStage = new EngineActualStage(this);
+
+            if (includeSurvivedMemory)
+            {
+                // Run the clock once to set static memory (necessary for CORE runtimes).
+                MeasureAction(_ => { }, 0);
+            }
         }
 
         public void Dispose()
@@ -136,8 +143,8 @@ public RunResults Run()
                 EngineEventSource.Log.BenchmarkStop(BenchmarkName);
 
             var outlierMode = TargetJob.ResolveValue(AccuracyMode.OutlierModeCharacteristic, Resolver);
-            
-            return new RunResults(idle, main, outlierMode, workGcHasDone.WithSurvivedBytes(includeSurvivedMemory), threadingStats);
+
+            return new RunResults(idle, main, outlierMode, workGcHasDone, threadingStats);
         }
 
         public Measurement RunIteration(IterationData data)
@@ -158,9 +165,9 @@ public Measurement RunIteration(IterationData data)
                 EngineEventSource.Log.IterationStart(data.IterationMode, data.IterationStage, totalOperations);
 
             // Measure
-            var clock = Clock.Start();
-            action(invokeCount / unrollFactor);
-            var clockSpan = clock.GetElapsed();
+            GcStats.StartMeasuringSurvived(includeSurvivedMemory);
+            double nanoseconds = MeasureAction(action, invokeCount / unrollFactor);
+            long survivedBytes = GcStats.StopMeasuringSurvived(includeSurvivedMemory);
 
             if (EngineEventSource.Log.IsEnabled())
                 EngineEventSource.Log.IterationStop(data.IterationMode, data.IterationStage, totalOperations);
@@ -171,12 +178,21 @@ 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, survivedBytes);
             WriteLine(measurement.ToString());
 
             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) GetExtraStats(IterationData data)
         {
             // we enable monitoring after main target run, for this single iteration which is executed at the end
@@ -196,7 +212,7 @@ public Measurement RunIteration(IterationData data)
 
             IterationCleanupAction(); // we run iteration cleanup after collecting GC stats
 
-            GcStats gcStats = (finalGcStats - initialGcStats).WithTotalOperations(data.InvokeCount * OperationsPerInvoke);
+            GcStats gcStats = (finalGcStats - initialGcStats).WithTotalOperationsAndSurvivedBytes(data.InvokeCount * OperationsPerInvoke);
             ThreadingStats threadingStats = (finalThreadingStats - initialThreadingStats).WithTotalOperations(data.InvokeCount * OperationsPerInvoke);
 
             return (gcStats, threadingStats);

src/BenchmarkDotNet/Engines/GcStats.cs

@@ -77,11 +77,8 @@ public long BytesAllocatedPerOperation
                 Math.Max(0, left.SurvivedBytes - right.SurvivedBytes));
         }
 
-        public GcStats WithTotalOperations(long totalOperationsCount)
-            => this + new GcStats(0, 0, 0, 0, totalOperationsCount, 0);
-
-        public GcStats WithSurvivedBytes(bool getBytes)
-            => this + new GcStats(0, 0, 0, 0, 0, GetTotalBytes(getBytes));
+        public GcStats WithTotalOperationsAndSurvivedBytes(long totalOperationsCount)
+            => this + new GcStats(0, 0, 0, 0, totalOperationsCount, _totalMeasured);
 
         public int GetCollectionsCount(int generation)
         {
@@ -141,24 +138,6 @@ public static GcStats ReadFinal()
         public static GcStats FromForced(int forcedFullGarbageCollections)
             => new GcStats(forcedFullGarbageCollections, forcedFullGarbageCollections, forcedFullGarbageCollections, 0, 0, 0);
 
-        private static long GetTotalBytes(bool actual)
-        {
-            if (!actual)
-                return 0;
-
-            if (RuntimeInformation.IsFullFramework) // it can be a .NET app consuming our .NET Standard package
-            {
-                AppDomain.MonitoringIsEnabled = true;
-
-                // Enforce GC.Collect here just to make sure we get accurate results
-                GC.Collect();
-                return AppDomain.CurrentDomain.MonitoringSurvivedMemorySize;
-            }
-
-            GC.Collect();
-            return GC.GetTotalMemory(true);
-        }
-
         private static long GetAllocatedBytes()
         {
             if (RuntimeInformation.IsMono) // Monitoring is not available in Mono, see http://stackoverflow.com/questions/40234948/how-to-get-the-number-of-allocated-bytes-
@@ -272,5 +251,35 @@ 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;
+        }
+
+        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;
+        }
     }
 }

src/BenchmarkDotNet/Engines/RunResults.cs

@@ -55,7 +55,8 @@ public IEnumerable<Measurement> GetMeasurements()
                     IterationStage.Result,
                     ++resultIndex,
                     measurement.Operations,
-                    value);
+                    value,
+                    measurement.SurvivedBytes);
             }
         }
 

src/BenchmarkDotNet/Reports/Measurement.cs

@@ -19,8 +19,9 @@ public struct Measurement : IComparable<Measurement>
 
         private const string NsSymbol = "ns";
         private const string OpSymbol = "op";
+        private const string SBSymbol = "B";
 
-        private static Measurement Error() => new Measurement(-1, IterationMode.Unknown, IterationStage.Unknown, 0, 0, 0);
+        private static Measurement Error() => new Measurement(-1, IterationMode.Unknown, IterationStage.Unknown, 0, 0, 0, 0);
 
         private static readonly int IterationInfoNameMaxWidth
             = Enum.GetNames(typeof(IterationMode)).Max(text => text.Length) + Enum.GetNames(typeof(IterationStage)).Max(text => text.Length);
@@ -43,6 +44,11 @@ private static readonly int IterationInfoNameMaxWidth
         /// </summary>
         public double Nanoseconds { get; }
 
+        /// <summary>
+        /// Gets the total number of survived bytes from all operations.
+        /// </summary>
+        public long SurvivedBytes { get; }
+
         /// <summary>
         /// Creates an instance of <see cref="Measurement"/> struct.
         /// </summary>
@@ -52,14 +58,16 @@ private static readonly int IterationInfoNameMaxWidth
         /// <param name="iterationIndex"></param>
         /// <param name="operations">The number of operations performed.</param>
         /// <param name="nanoseconds">The total number of nanoseconds it took to perform all operations.</param>
-        public Measurement(int launchIndex, IterationMode iterationMode, IterationStage iterationStage, int iterationIndex, long operations, double nanoseconds)
+        /// <param name="survivedBytes">The total number of survived bytes from all operations.</param>
+        public Measurement(int launchIndex, IterationMode iterationMode, IterationStage iterationStage, int iterationIndex, long operations, double nanoseconds, long survivedBytes)
         {
             Operations = operations;
             Nanoseconds = nanoseconds;
             LaunchIndex = launchIndex;
             IterationMode = iterationMode;
             IterationStage = iterationStage;
             IterationIndex = iterationIndex;
+            SurvivedBytes = survivedBytes;
         }
 
         private static IterationMode ParseIterationMode(string name) => Enum.TryParse(name, out IterationMode mode) ? mode : IterationMode.Unknown;
@@ -98,6 +106,15 @@ public override string ToString()
             builder.Append(GetAverageTime().ToString(MainCultureInfo).ToAscii());
             builder.Append("/op");
 
+            if (SurvivedBytes != 0)
+            {
+                builder.Append(", ");
+                builder.Append(SurvivedBytes.ToString(MainCultureInfo));
+                builder.Append(' ');
+                builder.Append(SBSymbol);
+                builder.Append(" Survived");
+            }
+
             return builder.ToString();
         }
 
@@ -146,6 +163,7 @@ public static Measurement Parse(ILogger logger, string line, int processIndex)
                 var measurementsInfoSplit = measurementsInfo.Split(new[] { ',' }, StringSplitOptions.RemoveEmptyEntries);
                 long op = 1L;
                 double ns = double.PositiveInfinity;
+                long survived = 0;
                 foreach (string item in measurementsInfoSplit)
                 {
                     var measurementSplit = item.Split(new[] { ' ' }, StringSplitOptions.RemoveEmptyEntries);
@@ -159,9 +177,12 @@ public static Measurement Parse(ILogger logger, string line, int processIndex)
                         case OpSymbol:
                             op = long.Parse(value, MainCultureInfo);
                             break;
+                        case SBSymbol:
+                            survived = long.Parse(value, MainCultureInfo);
+                            break;
                     }
                 }
-                return new Measurement(processIndex, iterationMode, iterationStage, iterationIndex, op, ns);
+                return new Measurement(processIndex, iterationMode, iterationStage, iterationIndex, op, ns, survived);
             }
             catch (Exception)
             {