Overwrite field to null instead of calling DeadCodeEliminationHelper.KeepAliveWithoutBoxing.

Author: timcassell

src/BenchmarkDotNet/Engines/Consumer.cs

@@ -30,8 +30,9 @@ private static readonly HashSet<Type> SupportedTypes
         private double doubleHolder;
         private long longHolder;
         private ulong ulongHolder;
-        private IntPtr ptrHolder;
-        private UIntPtr uptrHolder;
+        private volatile object objectHolder;
+        private volatile IntPtr ptrHolder;
+        private volatile UIntPtr uptrHolder;
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         [PublicAPI]
@@ -82,11 +83,11 @@ private static readonly HashSet<Type> SupportedTypes
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         [PublicAPI]
-        public void Consume(IntPtr intPtrValue) => Volatile.Write(ref ptrHolder, intPtrValue);
+        public void Consume(IntPtr intPtrValue) => ptrHolder = intPtrValue;
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         [PublicAPI]
-        public void Consume(UIntPtr uintPtrValue) => Volatile.Write(ref uptrHolder, uintPtrValue);
+        public void Consume(UIntPtr uintPtrValue) => uptrHolder = uintPtrValue;
 
         [CLSCompliant(false)]
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
@@ -95,22 +96,35 @@ private static readonly HashSet<Type> SupportedTypes
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         [PublicAPI]
-        public void Consume(string stringValue) => DeadCodeEliminationHelper.KeepAliveWithoutBoxing(stringValue);
+        public void Consume(string stringValue)
+        {
+            // Write to volatile field to prevent dead code elimination and out-of-order execution.
+            objectHolder = stringValue;
+            // Overwrite field to null so we aren't holding onto references to affect GC behavior. (#1942)
+            objectHolder = null;
+        }
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         [PublicAPI]
-        public void Consume(object objectValue) => DeadCodeEliminationHelper.KeepAliveWithoutBoxing(objectValue);
+        public void Consume(object objectValue)
+        {
+            objectHolder = objectValue;
+            objectHolder = null;
+        }
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         [PublicAPI]
         public void Consume<T>(T objectValue) where T : class // class constraint prevents from boxing structs
-            => DeadCodeEliminationHelper.KeepAliveWithoutBoxing(objectValue);
+        {
+            objectHolder = objectValue;
+            objectHolder = null;
+        }
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public unsafe void Consume<T>(T* ptrValue) where T: unmanaged => Volatile.Write(ref ptrHolder, (IntPtr)ptrValue);
+        public unsafe void Consume<T>(T* ptrValue) where T : unmanaged => ptrHolder = (IntPtr) ptrValue;
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public unsafe void Consume(void* ptrValue) => Volatile.Write(ref ptrHolder, (IntPtr)ptrValue);
+        public unsafe void Consume(void* ptrValue) => ptrHolder = (IntPtr) ptrValue;
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public void Consume<T>(in T value)
@@ -139,6 +153,11 @@ public void Consume<T>(in T value)
                 Volatile.Write(ref longHolder, (long)(object)value);
             else if (typeof(T) == typeof(ulong))
                 Volatile.Write(ref ulongHolder, (ulong)(object)value);
+            else if (default(T) == null && !typeof(T).IsValueType)
+            {
+                objectHolder = value;
+                objectHolder = null;
+            }
             else
                 DeadCodeEliminationHelper.KeepAliveWithoutBoxingReadonly(value); // non-primitive and nullable value types
         }